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