llvm/polly/lib/Support/SCEVAffinator.cpp

//===--------- SCEVAffinator.cpp  - Create Scops from LLVM IR -------------===//
//
// 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
//
//===----------------------------------------------------------------------===//
//
// Create a polyhedral description for a SCEV value.
//
//===----------------------------------------------------------------------===//

#include "polly/Support/SCEVAffinator.h"
#include "polly/Options.h"
#include "polly/ScopInfo.h"
#include "polly/Support/GICHelper.h"
#include "polly/Support/SCEVValidator.h"
#include "llvm/IR/DataLayout.h"
#include "isl/aff.h"
#include "isl/local_space.h"
#include "isl/set.h"
#include "isl/val.h"

usingnamespacellvm;
usingnamespacepolly;

static cl::opt<bool> IgnoreIntegerWrapping(
    "polly-ignore-integer-wrapping",
    cl::desc("Do not build run-time checks to proof absence of integer "
             "wrapping"),
    cl::Hidden, cl::cat(PollyCategory));

// The maximal number of basic sets we allow during the construction of a
// piecewise affine function. More complex ones will result in very high
// compile time.
static int const MaxDisjunctionsInPwAff = …;

// The maximal number of bits for which a general expression is modeled
// precisely.
static unsigned const MaxSmallBitWidth = …;

/// Add the number of basic sets in @p Domain to @p User
static isl_stat addNumBasicSets(__isl_take isl_set *Domain,
                                __isl_take isl_aff *Aff, void *User) { … }

/// Determine if @p PWAC is too complex to continue.
static bool isTooComplex(PWACtx PWAC) { … }

/// Return the flag describing the possible wrapping of @p Expr.
static SCEV::NoWrapFlags getNoWrapFlags(const SCEV *Expr) { … }

static PWACtx combine(PWACtx PWAC0, PWACtx PWAC1,
                      __isl_give isl_pw_aff *(Fn)(__isl_take isl_pw_aff *,
                                                  __isl_take isl_pw_aff *)) { … }

static __isl_give isl_pw_aff *getWidthExpValOnDomain(unsigned Width,
                                                     __isl_take isl_set *Dom) { … }

SCEVAffinator::SCEVAffinator(Scop *S, LoopInfo &LI)
    : … { … }

Loop *SCEVAffinator::getScope() { … }

void SCEVAffinator::interpretAsUnsigned(PWACtx &PWAC, unsigned Width) { … }

void SCEVAffinator::takeNonNegativeAssumption(
    PWACtx &PWAC, RecordedAssumptionsTy *RecordedAssumptions) { … }

PWACtx SCEVAffinator::getPWACtxFromPWA(isl::pw_aff PWA) { … }

PWACtx SCEVAffinator::getPwAff(const SCEV *Expr, BasicBlock *BB,
                               RecordedAssumptionsTy *RecordedAssumptions) { … }

PWACtx SCEVAffinator::checkForWrapping(const SCEV *Expr, PWACtx PWAC) const { … }

isl::pw_aff SCEVAffinator::addModuloSemantic(isl::pw_aff PWA,
                                             Type *ExprType) const { … }

bool SCEVAffinator::hasNSWAddRecForLoop(Loop *L) const { … }

bool SCEVAffinator::computeModuloForExpr(const SCEV *Expr) { … }

PWACtx SCEVAffinator::visit(const SCEV *Expr) { … }

PWACtx SCEVAffinator::visitConstant(const SCEVConstant *Expr) { … }

PWACtx SCEVAffinator::visitVScale(const SCEVVScale *VScale) { … }

PWACtx SCEVAffinator::visitPtrToIntExpr(const SCEVPtrToIntExpr *Expr) { … }

PWACtx SCEVAffinator::visitTruncateExpr(const SCEVTruncateExpr *Expr) { … }

PWACtx SCEVAffinator::visitZeroExtendExpr(const SCEVZeroExtendExpr *Expr) { … }

PWACtx SCEVAffinator::visitSignExtendExpr(const SCEVSignExtendExpr *Expr) { … }

PWACtx SCEVAffinator::visitAddExpr(const SCEVAddExpr *Expr) { … }

PWACtx SCEVAffinator::visitMulExpr(const SCEVMulExpr *Expr) { … }

PWACtx SCEVAffinator::visitAddRecExpr(const SCEVAddRecExpr *Expr) { … }

PWACtx SCEVAffinator::visitSMaxExpr(const SCEVSMaxExpr *Expr) { … }

PWACtx SCEVAffinator::visitSMinExpr(const SCEVSMinExpr *Expr) { … }

PWACtx SCEVAffinator::visitUMaxExpr(const SCEVUMaxExpr *Expr) { … }

PWACtx SCEVAffinator::visitUMinExpr(const SCEVUMinExpr *Expr) { … }

PWACtx
SCEVAffinator::visitSequentialUMinExpr(const SCEVSequentialUMinExpr *Expr) { … }

PWACtx SCEVAffinator::visitUDivExpr(const SCEVUDivExpr *Expr) { … }

PWACtx SCEVAffinator::visitSDivInstruction(Instruction *SDiv) { … }

PWACtx SCEVAffinator::visitSRemInstruction(Instruction *SRem) { … }

PWACtx SCEVAffinator::visitUnknown(const SCEVUnknown *Expr) { … }

PWACtx SCEVAffinator::complexityBailout() { … }