llvm/lib/Analysis/Local.cpp

   1 //===- Local.cpp - Functions to perform local transformations -------------===//
   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 #include "llvm/Analysis/Utils/Local.h"
  15 #include "llvm/ADT/Twine.h"
  16 #include "llvm/IR/DataLayout.h"
  17 #include "llvm/IR/GetElementPtrTypeIterator.h"
  18 #include "llvm/IR/IRBuilder.h"
  19
  20 using namespace llvm;
  21
  22 Value *llvm::emitGEPOffset(IRBuilderBase *Builder, const DataLayout &DL,
  23                            User *GEP, bool NoAssumptions) {
  24   GEPOperator *GEPOp = cast<GEPOperator>(GEP);
  25   Type *IntIdxTy = DL.getIndexType(GEP->getType());
  26   Value *Result = nullptr;
  27
  28   // If the GEP is inbounds, we know that none of the addressing operations will
  29   // overflow in a signed sense.
  30   bool isInBounds = GEPOp->isInBounds() && !NoAssumptions;
  31   auto AddOffset = [&](Value *Offset) {
  32     if (Result)
  33       Result = Builder->CreateAdd(Result, Offset, GEP->getName() + ".offs",
  34                                   false /*NUW*/, isInBounds /*NSW*/);
  35     else
  36       Result = Offset;
  37   };
  38
  39   gep_type_iterator GTI = gep_type_begin(GEP);
  40   for (User::op_iterator i = GEP->op_begin() + 1, e = GEP->op_end(); i != e;
  41        ++i, ++GTI) {
  42     Value *Op = *i;
  43     if (Constant *OpC = dyn_cast<Constant>(Op)) {
  44       if (OpC->isZeroValue())
  45         continue;
  46
  47       // Handle a struct index, which adds its field offset to the pointer.
  48       if (StructType *STy = GTI.getStructTypeOrNull()) {
  49         uint64_t OpValue = OpC->getUniqueInteger().getZExtValue();
  50         uint64_t Size = DL.getStructLayout(STy)->getElementOffset(OpValue);
  51         if (!Size)
  52           continue;
  53
  54         AddOffset(ConstantInt::get(IntIdxTy, Size));
  55         continue;
  56       }
  57     }
  58
  59     // Splat the index if needed.
  60     if (IntIdxTy->isVectorTy() && !Op->getType()->isVectorTy())
  61       Op = Builder->CreateVectorSplat(
  62           cast<VectorType>(IntIdxTy)->getElementCount(), Op);
  63
  64     // Convert to correct type.
  65     if (Op->getType() != IntIdxTy)
  66       Op = Builder->CreateIntCast(Op, IntIdxTy, true, Op->getName() + ".c");
  67     TypeSize TSize = GTI.getSequentialElementStride(DL);
  68     if (TSize != TypeSize::getFixed(1)) {
  69       Value *Scale = Builder->CreateTypeSize(IntIdxTy->getScalarType(), TSize);
  70       if (IntIdxTy->isVectorTy())
  71         Scale = Builder->CreateVectorSplat(
  72             cast<VectorType>(IntIdxTy)->getElementCount(), Scale);
  73       // We'll let instcombine(mul) convert this to a shl if possible.
  74       Op = Builder->CreateMul(Op, Scale, GEP->getName() + ".idx", false /*NUW*/,
  75                               isInBounds /*NSW*/);
  76     }
  77     AddOffset(Op);
  78   }
  79   return Result ? Result : Constant::getNullValue(IntIdxTy);
  80 }