RelLookupTableConverter.cpp Source File (original) (raw)

22using namespace llvm;

34 return false;

37 dyn_cast(GV.use_begin()->getUser());

38 if ( GEP || GEP ->hasOneUse() ||

40 return false;

42 LoadInst *Load = dyn_cast(GEP->use_begin()->getUser());

43 if (!Load || !Load->hasOneUse() ||

44 Load->getType() != GEP->getResultElementType())

45 return false;

57 return false;

60 if (!Array)

61 return false;

65 Type *ElemType = Array->getType()->getElementType();

66 if (!ElemType->isPointerTy() || DL.getPointerTypeSizeInBits(ElemType) != 64)

67 return false;

69 for (const Use &Op : Array->operands()) {

70 Constant *ConstOp = cast(&Op);

77 return false;

80 auto *GlovalVarOp = dyn_cast(GVOp);

81 if (!GlovalVarOp || !GlovalVarOp->isConstant())

82 return false;

84 if (!GlovalVarOp->hasLocalLinkage() ||

85 !GlovalVarOp->isDSOLocal() ||

86 !GlovalVarOp->isImplicitDSOLocal())

87 return false;

88 }

90 return true;

91}

95 Module &M = *Func.getParent();

97 cast(LookupTable.getInitializer());

101

103 M, IntArrayTy, LookupTable.isConstant(), LookupTable.getLinkage(),

104 nullptr, LookupTable.getName() + ".rel", &LookupTable,

105 LookupTable.getThreadLocalMode(), LookupTable.getAddressSpace(),

106 LookupTable.isExternallyInitialized());

107

110

111 for (Use &Operand : LookupTableArr->operands()) {

112 Constant *Element = cast(Operand);

113 Type *IntPtrTy = M.getDataLayout().getIntPtrType(M.getContext());

119 RelLookupTableContents[Idx++] = RelOffset;

120 }

121

125 RelLookupTable->setUnnamedAddr(GlobalValue::UnnamedAddr::Global);

127 return RelLookupTable;

128}

129

132 cast(LookupTable.use_begin()->getUser());

133 LoadInst *Load = cast(GEP->use_begin()->getUser());

134

135 Module &M = *LookupTable.getParent();

139

140

142

143

145 Value *Index = GEP->getOperand(2);

146 IntegerType *IntTy = cast(Index->getType());

148 Builder.CreateShl(Index, ConstantInt::get(IntTy, 2), "reltable.shift");

149

150

151

152

155 &M, Intrinsic::load_relative, {Index->getType()});

156

157

158

160 "reltable.intrinsic");

161

162

163 Load->replaceAllUsesWith(Result);

164

165 Load->eraseFromParent();

166 GEP->eraseFromParent();

167}

168

169

173 if (F.isDeclaration())

174 continue;

175

176

177 if (!GetTTI(F).shouldBuildRelLookupTables())

178 return false;

179

180

181 break;

182 }

183

184 bool Changed = false;

185

188 continue;

189

191

192

193 GV.eraseFromParent();

194

195 Changed = true;

196 }

197

198 return Changed;

199}

200

205

208 };

209

212

215 return PA;

216}

MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL

Returns the sub type a function will return at a given Idx Should correspond to the result type of an ExtractValue instruction executed with just that one unsigned Idx

Module.h This file contains the declarations for the Module class.

FunctionAnalysisManager FAM

static bool shouldConvertToRelLookupTable(Module &M, GlobalVariable &GV)

static void convertToRelLookupTable(GlobalVariable &LookupTable)

static bool convertToRelativeLookupTables(Module &M, function_ref< TargetTransformInfo &(Function &)> GetTTI)

static GlobalVariable * createRelLookupTable(Function &Func, GlobalVariable &LookupTable)

This file implements relative lookup table converter that converts lookup tables to relative lookup t...

This pass exposes codegen information to IR-level passes.

Class for arbitrary precision integers.

A container for analyses that lazily runs them and caches their results.

PassT::Result & getResult(IRUnitT &IR, ExtraArgTs... ExtraArgs)

Get the result of an analysis pass for a given IR unit.

uint64_t getNumElements() const

LLVM Basic Block Representation.

const Function * getParent() const

Return the enclosing method, or null if none.

Represents analyses that only rely on functions' control flow.

ConstantArray - Constant Array Declarations.

static Constant * get(ArrayType *T, ArrayRef< Constant * > V)

ArrayType * getType() const

Specialize the getType() method to always return an ArrayType, which reduces the amount of casting ne...

static Constant * getSub(Constant *C1, Constant *C2, bool HasNUW=false, bool HasNSW=false)

static Constant * getPtrToInt(Constant *C, Type *Ty, bool OnlyIfReduced=false)

static Constant * getTrunc(Constant *C, Type *Ty, bool OnlyIfReduced=false)

This is an important base class in LLVM.

This class represents an Operation in the Expression.

A parsed version of the target data layout string in and methods for querying it.

an instruction for type-safe pointer arithmetic to access elements of arrays and structs

void setAlignment(Align Align)

Sets the alignment attribute of the GlobalObject.

bool isImplicitDSOLocal() const

void setUnnamedAddr(UnnamedAddr Val)

bool hasLocalLinkage() const

Type * getValueType() const

const Constant * getInitializer() const

getInitializer - Return the initializer for this global variable.

void setInitializer(Constant *InitVal)

setInitializer - Sets the initializer for this global variable, removing any existing initializer if ...

bool hasInitializer() const

Definitions have initializers, declarations don't.

bool isConstant() const

If the value is a global constant, its value is immutable throughout the runtime execution of the pro...

Value * CreateShl(Value *LHS, Value *RHS, const Twine &Name="", bool HasNUW=false, bool HasNSW=false)

CallInst * CreateCall(FunctionType *FTy, Value *Callee, ArrayRef< Value * > Args={}, const Twine &Name="", MDNode *FPMathTag=nullptr)

void SetInsertPoint(BasicBlock *TheBB)

This specifies that created instructions should be appended to the end of the specified block.

This provides a uniform API for creating instructions and inserting them into a basic block: either a...

An analysis over an "outer" IR unit that provides access to an analysis manager over an "inner" IR un...

Class to represent integer types.

An instruction for reading from memory.

A Module instance is used to store all the information related to an LLVM module.

A set of analyses that are preserved following a run of a transformation pass.

static PreservedAnalyses all()

Construct a special preserved set that preserves all passes.

void preserveSet()

Mark an analysis set as preserved.

PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM)

This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.

Analysis pass providing the TargetTransformInfo.

This pass provides access to the codegen interfaces that are needed for IR-level transformations.

Target - Wrapper for Target specific information.

The instances of the Type class are immutable: once they are created, they are never changed.

bool isPointerTy() const

True if this is an instance of PointerType.

static IntegerType * getInt32Ty(LLVMContext &C)

A Use represents the edge between a Value definition and its users.

LLVM Value Representation.

bool hasOneUse() const

Return true if there is exactly one use of this value.

An efficient, type-erasing, non-owning reference to a callable.

Function * getOrInsertDeclaration(Module *M, ID id, ArrayRef< Type * > Tys={})

Look up the Function declaration of the intrinsic id in the Module M.

This is an optimization pass for GlobalISel generic memory operations.

bool IsConstantOffsetFromGlobal(Constant *C, GlobalValue *&GV, APInt &Offset, const DataLayout &DL, DSOLocalEquivalent **DSOEquiv=nullptr)

If this constant is a constant offset from a global, return the global and the constant.

iterator_range< early_inc_iterator_impl< detail::IterOfRange< RangeT > > > make_early_inc_range(RangeT &&Range)

Make a range that does early increment to allow mutation of the underlying range without disrupting i...

This struct is a compact representation of a valid (non-zero power of two) alignment.