llvm/polly/lib/CodeGen/IslExprBuilder.cpp

//===------ IslExprBuilder.cpp ----- Code generate isl AST expressions ----===//
//
// 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 "polly/CodeGen/IslExprBuilder.h"
#include "polly/CodeGen/RuntimeDebugBuilder.h"
#include "polly/Options.h"
#include "polly/ScopInfo.h"
#include "polly/Support/GICHelper.h"
#include "llvm/Transforms/Utils/BasicBlockUtils.h"

usingnamespacellvm;
usingnamespacepolly;

/// Different overflow tracking modes.
enum OverflowTrackingChoice { … };

static cl::opt<OverflowTrackingChoice> OTMode(
    "polly-overflow-tracking",
    cl::desc("Define where potential integer overflows in generated "
             "expressions should be tracked."),
    cl::values(clEnumValN(OT_NEVER, "never", "Never track the overflow bit."),
               clEnumValN(OT_REQUEST, "request",
                          "Track the overflow bit if requested."),
               clEnumValN(OT_ALWAYS, "always",
                          "Always track the overflow bit.")),
    cl::Hidden, cl::init(OT_REQUEST), cl::cat(PollyCategory));

IslExprBuilder::IslExprBuilder(Scop &S, PollyIRBuilder &Builder,
                               IDToValueTy &IDToValue, ValueMapT &GlobalMap,
                               const DataLayout &DL, ScalarEvolution &SE,
                               DominatorTree &DT, LoopInfo &LI,
                               BasicBlock *StartBlock)
    : … { … }

void IslExprBuilder::switchGeneratedFunc(llvm::Function *GenFn,
                                         llvm::DominatorTree *GenDT,
                                         llvm::LoopInfo *GenLI,
                                         llvm::ScalarEvolution *GenSE) { … }

void IslExprBuilder::setTrackOverflow(bool Enable) { … }

Value *IslExprBuilder::getOverflowState() const { … }

bool IslExprBuilder::hasLargeInts(isl::ast_expr Expr) { … }

Value *IslExprBuilder::createBinOp(BinaryOperator::BinaryOps Opc, Value *LHS,
                                   Value *RHS, const Twine &Name) { … }

Value *IslExprBuilder::createAdd(Value *LHS, Value *RHS, const Twine &Name) { … }

Value *IslExprBuilder::createSub(Value *LHS, Value *RHS, const Twine &Name) { … }

Value *IslExprBuilder::createMul(Value *LHS, Value *RHS, const Twine &Name) { … }

Type *IslExprBuilder::getWidestType(Type *T1, Type *T2) { … }

Value *IslExprBuilder::createOpUnary(__isl_take isl_ast_expr *Expr) { … }

Value *IslExprBuilder::createOpNAry(__isl_take isl_ast_expr *Expr) { … }

std::pair<Value *, Type *>
IslExprBuilder::createAccessAddress(__isl_take isl_ast_expr *Expr) { … }

Value *IslExprBuilder::createOpAccess(__isl_take isl_ast_expr *Expr) { … }

Value *IslExprBuilder::createOpBin(__isl_take isl_ast_expr *Expr) { … }

Value *IslExprBuilder::createOpSelect(__isl_take isl_ast_expr *Expr) { … }

Value *IslExprBuilder::createOpICmp(__isl_take isl_ast_expr *Expr) { … }

Value *IslExprBuilder::createOpBoolean(__isl_take isl_ast_expr *Expr) { … }

Value *
IslExprBuilder::createOpBooleanConditional(__isl_take isl_ast_expr *Expr) { … }

Value *IslExprBuilder::createOp(__isl_take isl_ast_expr *Expr) { … }

Value *IslExprBuilder::createOpAddressOf(__isl_take isl_ast_expr *Expr) { … }

Value *IslExprBuilder::createId(__isl_take isl_ast_expr *Expr) { … }

IntegerType *IslExprBuilder::getType(__isl_keep isl_ast_expr *Expr) { … }

Value *IslExprBuilder::createInt(__isl_take isl_ast_expr *Expr) { … }

Value *IslExprBuilder::create(__isl_take isl_ast_expr *Expr) { … }