1 //===- Local.h - Functions to perform local transformations -----*- C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This family of functions perform various local transformations to the 11 // program. 12 // 13 //===----------------------------------------------------------------------===// 14 15 #ifndef LLVM_ANALYSIS_UTILS_LOCAL_H 16 #define LLVM_ANALYSIS_UTILS_LOCAL_H 17 18 #include "llvm/IR/DataLayout.h" 19 #include "llvm/IR/GetElementPtrTypeIterator.h" 20 21 namespace llvm { 22 23 /// Given a getelementptr instruction/constantexpr, emit the code necessary to 24 /// compute the offset from the base pointer (without adding in the base 25 /// pointer). Return the result as a signed integer of intptr size. 26 /// When NoAssumptions is true, no assumptions about index computation not 27 /// overflowing is made. 28 template <typename IRBuilderTy> 29 Value *EmitGEPOffset(IRBuilderTy *Builder, const DataLayout &DL, User *GEP, 30 bool NoAssumptions = false) { 31 GEPOperator *GEPOp = cast<GEPOperator>(GEP); 32 Type *IntPtrTy = DL.getIntPtrType(GEP->getType()); 33 Value *Result = Constant::getNullValue(IntPtrTy); 34 35 // If the GEP is inbounds, we know that none of the addressing operations will 36 // overflow in an unsigned sense. 37 bool isInBounds = GEPOp->isInBounds() && !NoAssumptions; 38 39 // Build a mask for high order bits. 40 unsigned IntPtrWidth = IntPtrTy->getScalarType()->getIntegerBitWidth(); 41 uint64_t PtrSizeMask = 42 std::numeric_limits<uint64_t>::max() >> (64 - IntPtrWidth); 43 44 gep_type_iterator GTI = gep_type_begin(GEP); 45 for (User::op_iterator i = GEP->op_begin() + 1, e = GEP->op_end(); i != e; 46 ++i, ++GTI) { 47 Value *Op = *i; 48 uint64_t Size = DL.getTypeAllocSize(GTI.getIndexedType()) & PtrSizeMask; 49 if (Constant *OpC = dyn_cast<Constant>(Op)) { 50 if (OpC->isZeroValue()) 51 continue; 52 53 // Handle a struct index, which adds its field offset to the pointer. 54 if (StructType *STy = GTI.getStructTypeOrNull()) { 55 if (OpC->getType()->isVectorTy()) 56 OpC = OpC->getSplatValue(); 57 58 uint64_t OpValue = cast<ConstantInt>(OpC)->getZExtValue(); 59 Size = DL.getStructLayout(STy)->getElementOffset(OpValue); 60 61 if (Size) 62 Result = Builder->CreateAdd(Result, ConstantInt::get(IntPtrTy, Size), 63 GEP->getName()+".offs"); 64 continue; 65 } 66 67 Constant *Scale = ConstantInt::get(IntPtrTy, Size); 68 Constant *OC = ConstantExpr::getIntegerCast(OpC, IntPtrTy, true /*SExt*/); 69 Scale = ConstantExpr::getMul(OC, Scale, isInBounds/*NUW*/); 70 // Emit an add instruction. 71 Result = Builder->CreateAdd(Result, Scale, GEP->getName()+".offs"); 72 continue; 73 } 74 // Convert to correct type. 75 if (Op->getType() != IntPtrTy) 76 Op = Builder->CreateIntCast(Op, IntPtrTy, true, Op->getName()+".c"); 77 if (Size != 1) { 78 // We'll let instcombine(mul) convert this to a shl if possible. 79 Op = Builder->CreateMul(Op, ConstantInt::get(IntPtrTy, Size), 80 GEP->getName()+".idx", isInBounds /*NUW*/); 81 } 82 83 // Emit an add instruction. 84 Result = Builder->CreateAdd(Op, Result, GEP->getName()+".offs"); 85 } 86 return Result; 87 } 88 89 } 90 91 #endif // LLVM_TRANSFORMS_UTILS_LOCAL_H 92