llvm/mlir/lib/Analysis/Presburger/PresburgerSpace.cpp

//===- PresburgerSpace.cpp - MLIR PresburgerSpace Class -------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#include "mlir/Analysis/Presburger/PresburgerSpace.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/raw_ostream.h"
#include <algorithm>
#include <cassert>

usingnamespacemlir;
usingnamespacepresburger;

bool Identifier::isEqual(const Identifier &other) const { … }

void Identifier::print(llvm::raw_ostream &os) const { … }

void Identifier::dump() const { … }

PresburgerSpace PresburgerSpace::getDomainSpace() const { … }

PresburgerSpace PresburgerSpace::getRangeSpace() const { … }

PresburgerSpace PresburgerSpace::getSpaceWithoutLocals() const { … }

unsigned PresburgerSpace::getNumVarKind(VarKind kind) const { … }

unsigned PresburgerSpace::getVarKindOffset(VarKind kind) const { … }

unsigned PresburgerSpace::getVarKindEnd(VarKind kind) const { … }

unsigned PresburgerSpace::getVarKindOverlap(VarKind kind, unsigned varStart,
                                            unsigned varLimit) const { … }

VarKind PresburgerSpace::getVarKindAt(unsigned pos) const { … }

unsigned PresburgerSpace::insertVar(VarKind kind, unsigned pos, unsigned num) { … }

void PresburgerSpace::removeVarRange(VarKind kind, unsigned varStart,
                                     unsigned varLimit) { … }

void PresburgerSpace::convertVarKind(VarKind srcKind, unsigned srcPos,
                                     unsigned num, VarKind dstKind,
                                     unsigned dstPos) { … }

void PresburgerSpace::swapVar(VarKind kindA, VarKind kindB, unsigned posA,
                              unsigned posB) { … }

bool PresburgerSpace::isCompatible(const PresburgerSpace &other) const { … }

bool PresburgerSpace::isEqual(const PresburgerSpace &other) const { … }

/// Checks if the number of ids of the given kind in the two spaces are
/// equal and if the ids are equal. Assumes that both spaces are using
/// ids.
static bool areIdsEqual(const PresburgerSpace &spaceA,
                        const PresburgerSpace &spaceB, VarKind kind) { … }

bool PresburgerSpace::isAligned(const PresburgerSpace &other) const { … }

bool PresburgerSpace::isAligned(const PresburgerSpace &other,
                                VarKind kind) const { … }

void PresburgerSpace::setVarSymbolSeparation(unsigned newSymbolCount) { … }

void PresburgerSpace::mergeAndAlignSymbols(PresburgerSpace &other) { … }

void PresburgerSpace::print(llvm::raw_ostream &os) const { … }

void PresburgerSpace::dump() const { … }