lib/Transforms/Scalar/SeparateConstOffsetFromGEP.cpp

   1 //===-- SeparateConstOffsetFromGEP.cpp - ------------------------*- 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 // Loop unrolling may create many similar GEPs for array accesses.
  11 // e.g., a 2-level loop
  12 //
  13 // float a[32][32]; // global variable
  14 //
  15 // for (int i = 0; i < 2; ++i) {
  16 //   for (int j = 0; j < 2; ++j) {
  17 //     ...
  18 //     ... = a[x + i][y + j];
  19 //     ...
  20 //   }
  21 // }
  22 //
  23 // will probably be unrolled to:
  24 //
  25 // gep %a, 0, %x, %y; load
  26 // gep %a, 0, %x, %y + 1; load
  27 // gep %a, 0, %x + 1, %y; load
  28 // gep %a, 0, %x + 1, %y + 1; load
  29 //
  30 // LLVM's GVN does not use partial redundancy elimination yet, and is thus
  31 // unable to reuse (gep %a, 0, %x, %y). As a result, this misoptimization incurs
  32 // significant slowdown in targets with limited addressing modes. For instance,
  33 // because the PTX target does not support the reg+reg addressing mode, the
  34 // NVPTX backend emits PTX code that literally computes the pointer address of
  35 // each GEP, wasting tons of registers. It emits the following PTX for the
  36 // first load and similar PTX for other loads.
  37 //
  38 // mov.u32         %r1, %x;
  39 // mov.u32         %r2, %y;
  40 // mul.wide.u32    %rl2, %r1, 128;
  41 // mov.u64         %rl3, a;
  42 // add.s64         %rl4, %rl3, %rl2;
  43 // mul.wide.u32    %rl5, %r2, 4;
  44 // add.s64         %rl6, %rl4, %rl5;
  45 // ld.global.f32   %f1, [%rl6];
  46 //
  47 // To reduce the register pressure, the optimization implemented in this file
  48 // merges the common part of a group of GEPs, so we can compute each pointer
  49 // address by adding a simple offset to the common part, saving many registers.
  50 //
  51 // It works by splitting each GEP into a variadic base and a constant offset.
  52 // The variadic base can be computed once and reused by multiple GEPs, and the
  53 // constant offsets can be nicely folded into the reg+immediate addressing mode
  54 // (supported by most targets) without using any extra register.
  55 //
  56 // For instance, we transform the four GEPs and four loads in the above example
  57 // into:
  58 //
  59 // base = gep a, 0, x, y
  60 // load base
  61 // laod base + 1  * sizeof(float)
  62 // load base + 32 * sizeof(float)
  63 // load base + 33 * sizeof(float)
  64 //
  65 // Given the transformed IR, a backend that supports the reg+immediate
  66 // addressing mode can easily fold the pointer arithmetics into the loads. For
  67 // example, the NVPTX backend can easily fold the pointer arithmetics into the
  68 // ld.global.f32 instructions, and the resultant PTX uses much fewer registers.
  69 //
  70 // mov.u32         %r1, %tid.x;
  71 // mov.u32         %r2, %tid.y;
  72 // mul.wide.u32    %rl2, %r1, 128;
  73 // mov.u64         %rl3, a;
  74 // add.s64         %rl4, %rl3, %rl2;
  75 // mul.wide.u32    %rl5, %r2, 4;
  76 // add.s64         %rl6, %rl4, %rl5;
  77 // ld.global.f32   %f1, [%rl6]; // so far the same as unoptimized PTX
  78 // ld.global.f32   %f2, [%rl6+4]; // much better
  79 // ld.global.f32   %f3, [%rl6+128]; // much better
  80 // ld.global.f32   %f4, [%rl6+132]; // much better
  81 //
  82 //===----------------------------------------------------------------------===//
  83
  84 #include "llvm/Analysis/TargetTransformInfo.h"
  85 #include "llvm/Analysis/ValueTracking.h"
  86 #include "llvm/IR/Constants.h"
  87 #include "llvm/IR/DataLayout.h"
  88 #include "llvm/IR/Instructions.h"
  89 #include "llvm/IR/LLVMContext.h"
  90 #include "llvm/IR/Module.h"
  91 #include "llvm/IR/Operator.h"
  92 #include "llvm/Support/CommandLine.h"
  93 #include "llvm/Support/raw_ostream.h"
  94 #include "llvm/Transforms/Scalar.h"
  95
  96 using namespace llvm;
  97
  98 static cl::opt<bool> DisableSeparateConstOffsetFromGEP(
  99     "disable-separate-const-offset-from-gep", cl::init(false),
 100     cl::desc("Do not separate the constant offset from a GEP instruction"),
 101     cl::Hidden);
 102
 103 namespace {
 104
 105 /// \brief A helper class for separating a constant offset from a GEP index.
 106 ///
 107 /// In real programs, a GEP index may be more complicated than a simple addition
 108 /// of something and a constant integer which can be trivially splitted. For
 109 /// example, to split ((a << 3) | 5) + b, we need to search deeper for the
 110 /// constant offset, so that we can separate the index to (a << 3) + b and 5.
 111 ///
 112 /// Therefore, this class looks into the expression that computes a given GEP
 113 /// index, and tries to find a constant integer that can be hoisted to the
 114 /// outermost level of the expression as an addition. Not every constant in an
 115 /// expression can jump out. e.g., we cannot transform (b * (a + 5)) to (b * a +
 116 /// 5); nor can we transform (3 * (a + 5)) to (3 * a + 5), however in this case,
 117 /// -instcombine probably already optimized (3 * (a + 5)) to (3 * a + 15).
 118 class ConstantOffsetExtractor {
 119  public:
 120   /// Extracts a constant offset from the given GEP index. It outputs the
 121   /// numeric value of the extracted constant offset (0 if failed), and a
 122   /// new index representing the remainder (equal to the original index minus
 123   /// the constant offset).
 124   /// \p Idx    The given GEP index
 125   /// \p NewIdx The new index to replace (output)
 126   /// \p DL     The datalayout of the module
 127   /// \p GEP    The given GEP
 128   static int64_t Extract(Value *Idx, Value *&NewIdx, const DataLayout *DL,
 129                          GetElementPtrInst *GEP);
 130   /// Looks for a constant offset without extracting it. The meaning of the
 131   /// arguments and the return value are the same as Extract.
 132   static int64_t Find(Value *Idx, const DataLayout *DL, GetElementPtrInst *GEP);
 133
 134  private:
 135   ConstantOffsetExtractor(const DataLayout *Layout, Instruction *InsertionPt)
 136       : DL(Layout), IP(InsertionPt) {}
 137   /// Searches the expression that computes V for a non-zero constant C s.t.
 138   /// V can be reassociated into the form V' + C. If the searching is
 139   /// successful, returns C and update UserChain as a def-use chain from C to V;
 140   /// otherwise, UserChain is empty.
 141   ///
 142   /// \p V            The given expression
 143   /// \p SignExtended Whether V will be sign-extended in the computation of the
 144   ///                 GEP index
 145   /// \p ZeroExtended Whether V will be zero-extended in the computation of the
 146   ///                 GEP index
 147   /// \p NonNegative  Whether V is guaranteed to be non-negative. For example,
 148   ///                 an index of an inbounds GEP is guaranteed to be
 149   ///                 non-negative. Levaraging this, we can better split
 150   ///                 inbounds GEPs.
 151   APInt find(Value *V, bool SignExtended, bool ZeroExtended, bool NonNegative);
 152   /// A helper function to look into both operands of a binary operator.
 153   APInt findInEitherOperand(BinaryOperator *BO, bool SignExtended,
 154                             bool ZeroExtended);
 155   /// After finding the constant offset C from the GEP index I, we build a new
 156   /// index I' s.t. I' + C = I. This function builds and returns the new
 157   /// index I' according to UserChain produced by function "find".
 158   ///
 159   /// The building conceptually takes two steps:
 160   /// 1) iteratively distribute s/zext towards the leaves of the expression tree
 161   /// that computes I
 162   /// 2) reassociate the expression tree to the form I' + C.
 163   ///
 164   /// For example, to extract the 5 from sext(a + (b + 5)), we first distribute
 165   /// sext to a, b and 5 so that we have
 166   ///   sext(a) + (sext(b) + 5).
 167   /// Then, we reassociate it to
 168   ///   (sext(a) + sext(b)) + 5.
 169   /// Given this form, we know I' is sext(a) + sext(b).
 170   Value *rebuildWithoutConstOffset();
 171   /// After the first step of rebuilding the GEP index without the constant
 172   /// offset, distribute s/zext to the operands of all operators in UserChain.
 173   /// e.g., zext(sext(a + (b + 5)) (assuming no overflow) =>
 174   /// zext(sext(a)) + (zext(sext(b)) + zext(sext(5))).
 175   ///
 176   /// The function also updates UserChain to point to new subexpressions after
 177   /// distributing s/zext. e.g., the old UserChain of the above example is
 178   /// 5 -> b + 5 -> a + (b + 5) -> sext(...) -> zext(sext(...)),
 179   /// and the new UserChain is
 180   /// zext(sext(5)) -> zext(sext(b)) + zext(sext(5)) ->
 181   ///   zext(sext(a)) + (zext(sext(b)) + zext(sext(5))
 182   ///
 183   /// \p ChainIndex The index to UserChain. ChainIndex is initially
 184   ///               UserChain.size() - 1, and is decremented during
 185   ///               the recursion.
 186   Value *distributeExtsAndCloneChain(unsigned ChainIndex);
 187   /// Reassociates the GEP index to the form I' + C and returns I'.
 188   Value *removeConstOffset(unsigned ChainIndex);
 189   /// A helper function to apply ExtInsts, a list of s/zext, to value V.
 190   /// e.g., if ExtInsts = [sext i32 to i64, zext i16 to i32], this function
 191   /// returns "sext i32 (zext i16 V to i32) to i64".
 192   Value *applyExts(Value *V);
 193
 194   /// Returns true if LHS and RHS have no bits in common, i.e., LHS | RHS == 0.
 195   bool NoCommonBits(Value *LHS, Value *RHS) const;
 196   /// Computes which bits are known to be one or zero.
 197   /// \p KnownOne Mask of all bits that are known to be one.
 198   /// \p KnownZero Mask of all bits that are known to be zero.
 199   void ComputeKnownBits(Value *V, APInt &KnownOne, APInt &KnownZero) const;
 200   /// A helper function that returns whether we can trace into the operands
 201   /// of binary operator BO for a constant offset.
 202   ///
 203   /// \p SignExtended Whether BO is surrounded by sext
 204   /// \p ZeroExtended Whether BO is surrounded by zext
 205   /// \p NonNegative Whether BO is known to be non-negative, e.g., an in-bound
 206   ///                array index.
 207   bool CanTraceInto(bool SignExtended, bool ZeroExtended, BinaryOperator *BO,
 208                     bool NonNegative);
 209
 210   /// The path from the constant offset to the old GEP index. e.g., if the GEP
 211   /// index is "a * b + (c + 5)". After running function find, UserChain[0] will
 212   /// be the constant 5, UserChain[1] will be the subexpression "c + 5", and
 213   /// UserChain[2] will be the entire expression "a * b + (c + 5)".
 214   ///
 215   /// This path helps to rebuild the new GEP index.
 216   SmallVector<User *, 8> UserChain;
 217   /// A data structure used in rebuildWithoutConstOffset. Contains all
 218   /// sext/zext instructions along UserChain.
 219   SmallVector<CastInst *, 16> ExtInsts;
 220   /// The data layout of the module. Used in ComputeKnownBits.
 221   const DataLayout *DL;
 222   Instruction *IP;  /// Insertion position of cloned instructions.
 223 };
 224
 225 /// \brief A pass that tries to split every GEP in the function into a variadic
 226 /// base and a constant offset. It is a FunctionPass because searching for the
 227 /// constant offset may inspect other basic blocks.
 228 class SeparateConstOffsetFromGEP : public FunctionPass {
 229  public:
 230   static char ID;
 231   SeparateConstOffsetFromGEP() : FunctionPass(ID) {
 232     initializeSeparateConstOffsetFromGEPPass(*PassRegistry::getPassRegistry());
 233   }
 234
 235   void getAnalysisUsage(AnalysisUsage &AU) const override {
 236     AU.addRequired<DataLayoutPass>();
 237     AU.addRequired<TargetTransformInfo>();
 238   }
 239
 240   bool doInitialization(Module &M) override {
 241     DataLayoutPass *DLP = getAnalysisIfAvailable<DataLayoutPass>();
 242     if (DLP == nullptr)
 243       report_fatal_error("data layout missing");
 244     DL = &DLP->getDataLayout();
 245     return false;
 246   }
 247
 248   bool runOnFunction(Function &F) override;
 249
 250  private:
 251   /// Tries to split the given GEP into a variadic base and a constant offset,
 252   /// and returns true if the splitting succeeds.
 253   bool splitGEP(GetElementPtrInst *GEP);
 254   /// Finds the constant offset within each index, and accumulates them. This
 255   /// function only inspects the GEP without changing it. The output
 256   /// NeedsExtraction indicates whether we can extract a non-zero constant
 257   /// offset from any index.
 258   int64_t accumulateByteOffset(GetElementPtrInst *GEP, bool &NeedsExtraction);
 259   /// Canonicalize array indices to pointer-size integers. This helps to
 260   /// simplify the logic of splitting a GEP. For example, if a + b is a
 261   /// pointer-size integer, we have
 262   ///   gep base, a + b = gep (gep base, a), b
 263   /// However, this equality may not hold if the size of a + b is smaller than
 264   /// the pointer size, because LLVM conceptually sign-extends GEP indices to
 265   /// pointer size before computing the address
 266   /// (http://llvm.org/docs/LangRef.html#id181).
 267   ///
 268   /// This canonicalization is very likely already done in clang and
 269   /// instcombine. Therefore, the program will probably remain the same.
 270   ///
 271   /// Returns true if the module changes.
 272   ///
 273   /// Verified in @i32_add in split-gep.ll
 274   bool canonicalizeArrayIndicesToPointerSize(GetElementPtrInst *GEP);
 275
 276   const DataLayout *DL;
 277 };
 278 }  // anonymous namespace
 279
 280 char SeparateConstOffsetFromGEP::ID = 0;
 281 INITIALIZE_PASS_BEGIN(
 282     SeparateConstOffsetFromGEP, "separate-const-offset-from-gep",
 283     "Split GEPs to a variadic base and a constant offset for better CSE", false,
 284     false)
 285 INITIALIZE_AG_DEPENDENCY(TargetTransformInfo)
 286 INITIALIZE_PASS_DEPENDENCY(DataLayoutPass)
 287 INITIALIZE_PASS_END(
 288     SeparateConstOffsetFromGEP, "separate-const-offset-from-gep",
 289     "Split GEPs to a variadic base and a constant offset for better CSE", false,
 290     false)
 291
 292 FunctionPass *llvm::createSeparateConstOffsetFromGEPPass() {
 293   return new SeparateConstOffsetFromGEP();
 294 }
 295
 296 bool ConstantOffsetExtractor::CanTraceInto(bool SignExtended,
 297                                             bool ZeroExtended,
 298                                             BinaryOperator *BO,
 299                                             bool NonNegative) {
 300   // We only consider ADD, SUB and OR, because a non-zero constant found in
 301   // expressions composed of these operations can be easily hoisted as a
 302   // constant offset by reassociation.
 303   if (BO->getOpcode() != Instruction::Add &&
 304       BO->getOpcode() != Instruction::Sub &&
 305       BO->getOpcode() != Instruction::Or) {
 306     return false;
 307   }
 308
 309   Value *LHS = BO->getOperand(0), *RHS = BO->getOperand(1);
 310   // Do not trace into "or" unless it is equivalent to "add". If LHS and RHS
 311   // don't have common bits, (LHS | RHS) is equivalent to (LHS + RHS).
 312   if (BO->getOpcode() == Instruction::Or && !NoCommonBits(LHS, RHS))
 313     return false;
 314
 315   // In addition, tracing into BO requires that its surrounding s/zext (if
 316   // any) is distributable to both operands.
 317   //
 318   // Suppose BO = A op B.
 319   //  SignExtended | ZeroExtended | Distributable?
 320   // --------------+--------------+----------------------------------
 321   //       0       |      0       | true because no s/zext exists
 322   //       0       |      1       | zext(BO) == zext(A) op zext(B)
 323   //       1       |      0       | sext(BO) == sext(A) op sext(B)
 324   //       1       |      1       | zext(sext(BO)) ==
 325   //               |              |     zext(sext(A)) op zext(sext(B))
 326   if (BO->getOpcode() == Instruction::Add && !ZeroExtended && NonNegative) {
 327     // If a + b >= 0 and (a >= 0 or b >= 0), then
 328     //   sext(a + b) = sext(a) + sext(b)
 329     // even if the addition is not marked nsw.
 330     //
 331     // Leveraging this invarient, we can trace into an sext'ed inbound GEP
 332     // index if the constant offset is non-negative.
 333     //
 334     // Verified in @sext_add in split-gep.ll.
 335     if (ConstantInt *ConstLHS = dyn_cast<ConstantInt>(LHS)) {
 336       if (!ConstLHS->isNegative())
 337         return true;
 338     }
 339     if (ConstantInt *ConstRHS = dyn_cast<ConstantInt>(RHS)) {
 340       if (!ConstRHS->isNegative())
 341         return true;
 342     }
 343   }
 344
 345   // sext (add/sub nsw A, B) == add/sub nsw (sext A), (sext B)
 346   // zext (add/sub nuw A, B) == add/sub nuw (zext A), (zext B)
 347   if (BO->getOpcode() == Instruction::Add ||
 348       BO->getOpcode() == Instruction::Sub) {
 349     if (SignExtended && !BO->hasNoSignedWrap())
 350       return false;
 351     if (ZeroExtended && !BO->hasNoUnsignedWrap())
 352       return false;
 353   }
 354
 355   return true;
 356 }
 357
 358 APInt ConstantOffsetExtractor::findInEitherOperand(BinaryOperator *BO,
 359                                                    bool SignExtended,
 360                                                    bool ZeroExtended) {
 361   // BO being non-negative does not shed light on whether its operands are
 362   // non-negative. Clear the NonNegative flag here.
 363   APInt ConstantOffset = find(BO->getOperand(0), SignExtended, ZeroExtended,
 364                               /* NonNegative */ false);
 365   // If we found a constant offset in the left operand, stop and return that.
 366   // This shortcut might cause us to miss opportunities of combining the
 367   // constant offsets in both operands, e.g., (a + 4) + (b + 5) => (a + b) + 9.
 368   // However, such cases are probably already handled by -instcombine,
 369   // given this pass runs after the standard optimizations.
 370   if (ConstantOffset != 0) return ConstantOffset;
 371   ConstantOffset = find(BO->getOperand(1), SignExtended, ZeroExtended,
 372                         /* NonNegative */ false);
 373   // If U is a sub operator, negate the constant offset found in the right
 374   // operand.
 375   if (BO->getOpcode() == Instruction::Sub)
 376     ConstantOffset = -ConstantOffset;
 377   return ConstantOffset;
 378 }
 379
 380 APInt ConstantOffsetExtractor::find(Value *V, bool SignExtended,
 381                                     bool ZeroExtended, bool NonNegative) {
 382   // TODO(jingyue): We could trace into integer/pointer casts, such as
 383   // inttoptr, ptrtoint, bitcast, and addrspacecast. We choose to handle only
 384   // integers because it gives good enough results for our benchmarks.
 385   unsigned BitWidth = cast<IntegerType>(V->getType())->getBitWidth();
 386
 387   // We cannot do much with Values that are not a User, such as an Argument.
 388   User *U = dyn_cast<User>(V);
 389   if (U == nullptr) return APInt(BitWidth, 0);
 390
 391   APInt ConstantOffset(BitWidth, 0);
 392   if (ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
 393     // Hooray, we found it!
 394     ConstantOffset = CI->getValue();
 395   } else if (BinaryOperator *BO = dyn_cast<BinaryOperator>(V)) {
 396     // Trace into subexpressions for more hoisting opportunities.
 397     if (CanTraceInto(SignExtended, ZeroExtended, BO, NonNegative)) {
 398       ConstantOffset = findInEitherOperand(BO, SignExtended, ZeroExtended);
 399     }
 400   } else if (isa<SExtInst>(V)) {
 401     ConstantOffset = find(U->getOperand(0), /* SignExtended */ true,
 402                           ZeroExtended, NonNegative).sext(BitWidth);
 403   } else if (isa<ZExtInst>(V)) {
 404     // As an optimization, we can clear the SignExtended flag because
 405     // sext(zext(a)) = zext(a). Verified in @sext_zext in split-gep.ll.
 406     //
 407     // Clear the NonNegative flag, because zext(a) >= 0 does not imply a >= 0.
 408     ConstantOffset =
 409         find(U->getOperand(0), /* SignExtended */ false,
 410              /* ZeroExtended */ true, /* NonNegative */ false).zext(BitWidth);
 411   }
 412
 413   // If we found a non-zero constant offset, add it to the path for
 414   // rebuildWithoutConstOffset. Zero is a valid constant offset, but doesn't
 415   // help this optimization.
 416   if (ConstantOffset != 0)
 417     UserChain.push_back(U);
 418   return ConstantOffset;
 419 }
 420
 421 Value *ConstantOffsetExtractor::applyExts(Value *V) {
 422   Value *Current = V;
 423   // ExtInsts is built in the use-def order. Therefore, we apply them to V
 424   // in the reversed order.
 425   for (auto I = ExtInsts.rbegin(), E = ExtInsts.rend(); I != E; ++I) {
 426     if (Constant *C = dyn_cast<Constant>(Current)) {
 427       // If Current is a constant, apply s/zext using ConstantExpr::getCast.
 428       // ConstantExpr::getCast emits a ConstantInt if C is a ConstantInt.
 429       Current = ConstantExpr::getCast((*I)->getOpcode(), C, (*I)->getType());
 430     } else {
 431       Instruction *Ext = (*I)->clone();
 432       Ext->setOperand(0, Current);
 433       Ext->insertBefore(IP);
 434       Current = Ext;
 435     }
 436   }
 437   return Current;
 438 }
 439
 440 Value *ConstantOffsetExtractor::rebuildWithoutConstOffset() {
 441   distributeExtsAndCloneChain(UserChain.size() - 1);
 442   // Remove all nullptrs (used to be s/zext) from UserChain.
 443   unsigned NewSize = 0;
 444   for (auto I = UserChain.begin(), E = UserChain.end(); I != E; ++I) {
 445     if (*I != nullptr) {
 446       UserChain[NewSize] = *I;
 447       NewSize++;
 448     }
 449   }
 450   UserChain.resize(NewSize);
 451   return removeConstOffset(UserChain.size() - 1);
 452 }
 453
 454 Value *
 455 ConstantOffsetExtractor::distributeExtsAndCloneChain(unsigned ChainIndex) {
 456   User *U = UserChain[ChainIndex];
 457   if (ChainIndex == 0) {
 458     assert(isa<ConstantInt>(U));
 459     // If U is a ConstantInt, applyExts will return a ConstantInt as well.
 460     return UserChain[ChainIndex] = cast<ConstantInt>(applyExts(U));
 461   }
 462
 463   if (CastInst *Cast = dyn_cast<CastInst>(U)) {
 464     assert((isa<SExtInst>(Cast) || isa<ZExtInst>(Cast)) &&
 465            "We only traced into two types of CastInst: sext and zext");
 466     ExtInsts.push_back(Cast);
 467     UserChain[ChainIndex] = nullptr;
 468     return distributeExtsAndCloneChain(ChainIndex - 1);
 469   }
 470
 471   // Function find only trace into BinaryOperator and CastInst.
 472   BinaryOperator *BO = cast<BinaryOperator>(U);
 473   // OpNo = which operand of BO is UserChain[ChainIndex - 1]
 474   unsigned OpNo = (BO->getOperand(0) == UserChain[ChainIndex - 1] ? 0 : 1);
 475   Value *TheOther = applyExts(BO->getOperand(1 - OpNo));
 476   Value *NextInChain = distributeExtsAndCloneChain(ChainIndex - 1);
 477
 478   BinaryOperator *NewBO = nullptr;
 479   if (OpNo == 0) {
 480     NewBO = BinaryOperator::Create(BO->getOpcode(), NextInChain, TheOther,
 481                                    BO->getName(), IP);
 482   } else {
 483     NewBO = BinaryOperator::Create(BO->getOpcode(), TheOther, NextInChain,
 484                                    BO->getName(), IP);
 485   }
 486   return UserChain[ChainIndex] = NewBO;
 487 }
 488
 489 Value *ConstantOffsetExtractor::removeConstOffset(unsigned ChainIndex) {
 490   if (ChainIndex == 0) {
 491     assert(isa<ConstantInt>(UserChain[ChainIndex]));
 492     return ConstantInt::getNullValue(UserChain[ChainIndex]->getType());
 493   }
 494
 495   BinaryOperator *BO = cast<BinaryOperator>(UserChain[ChainIndex]);
 496   unsigned OpNo = (BO->getOperand(0) == UserChain[ChainIndex - 1] ? 0 : 1);
 497   assert(BO->getOperand(OpNo) == UserChain[ChainIndex - 1]);
 498   Value *NextInChain = removeConstOffset(ChainIndex - 1);
 499   Value *TheOther = BO->getOperand(1 - OpNo);
 500
 501   // If NextInChain is 0 and not the LHS of a sub, we can simplify the
 502   // sub-expression to be just TheOther.
 503   if (ConstantInt *CI = dyn_cast<ConstantInt>(NextInChain)) {
 504     if (CI->isZero() && !(BO->getOpcode() == Instruction::Sub && OpNo == 0))
 505       return TheOther;
 506   }
 507
 508   if (BO->getOpcode() == Instruction::Or) {
 509     // Rebuild "or" as "add", because "or" may be invalid for the new
 510     // epxression.
 511     //
 512     // For instance, given
 513     //   a | (b + 5) where a and b + 5 have no common bits,
 514     // we can extract 5 as the constant offset.
 515     //
 516     // However, reusing the "or" in the new index would give us
 517     //   (a | b) + 5
 518     // which does not equal a | (b + 5).
 519     //
 520     // Replacing the "or" with "add" is fine, because
 521     //   a | (b + 5) = a + (b + 5) = (a + b) + 5
 522     if (OpNo == 0) {
 523       return BinaryOperator::CreateAdd(NextInChain, TheOther, BO->getName(),
 524                                        IP);
 525     } else {
 526       return BinaryOperator::CreateAdd(TheOther, NextInChain, BO->getName(),
 527                                        IP);
 528     }
 529   }
 530
 531   // We can reuse BO in this case, because the new expression shares the same
 532   // instruction type and BO is used at most once.
 533   assert(BO->getNumUses() <= 1 &&
 534          "distributeExtsAndCloneChain clones each BinaryOperator in "
 535          "UserChain, so no one should be used more than "
 536          "once");
 537   BO->setOperand(OpNo, NextInChain);
 538   BO->setHasNoSignedWrap(false);
 539   BO->setHasNoUnsignedWrap(false);
 540   // Make sure it appears after all instructions we've inserted so far.
 541   BO->moveBefore(IP);
 542   return BO;
 543 }
 544
 545 int64_t ConstantOffsetExtractor::Extract(Value *Idx, Value *&NewIdx,
 546                                          const DataLayout *DL,
 547                                          GetElementPtrInst *GEP) {
 548   ConstantOffsetExtractor Extractor(DL, GEP);
 549   // Find a non-zero constant offset first.
 550   APInt ConstantOffset =
 551       Extractor.find(Idx, /* SignExtended */ false, /* ZeroExtended */ false,
 552                      GEP->isInBounds());
 553   if (ConstantOffset != 0) {
 554     // Separates the constant offset from the GEP index.
 555     NewIdx = Extractor.rebuildWithoutConstOffset();
 556   }
 557   return ConstantOffset.getSExtValue();
 558 }
 559
 560 int64_t ConstantOffsetExtractor::Find(Value *Idx, const DataLayout *DL,
 561       GetElementPtrInst *GEP) {
 562   // If Idx is an index of an inbound GEP, Idx is guaranteed to be non-negative.
 563   return ConstantOffsetExtractor(DL, GEP)
 564       .find(Idx, /* SignExtended */ false, /* ZeroExtended */ false,
 565             GEP->isInBounds())
 566       .getSExtValue();
 567 }
 568
 569 void ConstantOffsetExtractor::ComputeKnownBits(Value *V, APInt &KnownOne,
 570                                                APInt &KnownZero) const {
 571   IntegerType *IT = cast<IntegerType>(V->getType());
 572   KnownOne = APInt(IT->getBitWidth(), 0);
 573   KnownZero = APInt(IT->getBitWidth(), 0);
 574   llvm::computeKnownBits(V, KnownZero, KnownOne, DL, 0);
 575 }
 576
 577 bool ConstantOffsetExtractor::NoCommonBits(Value *LHS, Value *RHS) const {
 578   assert(LHS->getType() == RHS->getType() &&
 579          "LHS and RHS should have the same type");
 580   APInt LHSKnownOne, LHSKnownZero, RHSKnownOne, RHSKnownZero;
 581   ComputeKnownBits(LHS, LHSKnownOne, LHSKnownZero);
 582   ComputeKnownBits(RHS, RHSKnownOne, RHSKnownZero);
 583   return (LHSKnownZero | RHSKnownZero).isAllOnesValue();
 584 }
 585
 586 bool SeparateConstOffsetFromGEP::canonicalizeArrayIndicesToPointerSize(
 587     GetElementPtrInst *GEP) {
 588   bool Changed = false;
 589   Type *IntPtrTy = DL->getIntPtrType(GEP->getType());
 590   gep_type_iterator GTI = gep_type_begin(*GEP);
 591   for (User::op_iterator I = GEP->op_begin() + 1, E = GEP->op_end();
 592        I != E; ++I, ++GTI) {
 593     // Skip struct member indices which must be i32.
 594     if (isa<SequentialType>(*GTI)) {
 595       if ((*I)->getType() != IntPtrTy) {
 596         *I = CastInst::CreateIntegerCast(*I, IntPtrTy, true, "idxprom", GEP);
 597         Changed = true;
 598       }
 599     }
 600   }
 601   return Changed;
 602 }
 603
 604 int64_t
 605 SeparateConstOffsetFromGEP::accumulateByteOffset(GetElementPtrInst *GEP,
 606                                                  bool &NeedsExtraction) {
 607   NeedsExtraction = false;
 608   int64_t AccumulativeByteOffset = 0;
 609   gep_type_iterator GTI = gep_type_begin(*GEP);
 610   for (unsigned I = 1, E = GEP->getNumOperands(); I != E; ++I, ++GTI) {
 611     if (isa<SequentialType>(*GTI)) {
 612       // Tries to extract a constant offset from this GEP index.
 613       int64_t ConstantOffset =
 614           ConstantOffsetExtractor::Find(GEP->getOperand(I), DL, GEP);
 615       if (ConstantOffset != 0) {
 616         NeedsExtraction = true;
 617         // A GEP may have multiple indices.  We accumulate the extracted
 618         // constant offset to a byte offset, and later offset the remainder of
 619         // the original GEP with this byte offset.
 620         AccumulativeByteOffset +=
 621             ConstantOffset * DL->getTypeAllocSize(GTI.getIndexedType());
 622       }
 623     }
 624   }
 625   return AccumulativeByteOffset;
 626 }
 627
 628 bool SeparateConstOffsetFromGEP::splitGEP(GetElementPtrInst *GEP) {
 629   // Skip vector GEPs.
 630   if (GEP->getType()->isVectorTy())
 631     return false;
 632
 633   // The backend can already nicely handle the case where all indices are
 634   // constant.
 635   if (GEP->hasAllConstantIndices())
 636     return false;
 637
 638   bool Changed = canonicalizeArrayIndicesToPointerSize(GEP);
 639
 640   bool NeedsExtraction;
 641   int64_t AccumulativeByteOffset = accumulateByteOffset(GEP, NeedsExtraction);
 642
 643   if (!NeedsExtraction)
 644     return Changed;
 645   // Before really splitting the GEP, check whether the backend supports the
 646   // addressing mode we are about to produce. If no, this splitting probably
 647   // won't be beneficial.
 648   TargetTransformInfo &TTI = getAnalysis<TargetTransformInfo>();
 649   if (!TTI.isLegalAddressingMode(GEP->getType()->getElementType(),
 650                                  /*BaseGV=*/nullptr, AccumulativeByteOffset,
 651                                  /*HasBaseReg=*/true, /*Scale=*/0)) {
 652     return Changed;
 653   }
 654
 655   // Remove the constant offset in each GEP index. The resultant GEP computes
 656   // the variadic base.
 657   gep_type_iterator GTI = gep_type_begin(*GEP);
 658   for (unsigned I = 1, E = GEP->getNumOperands(); I != E; ++I, ++GTI) {
 659     if (isa<SequentialType>(*GTI)) {
 660       Value *NewIdx = nullptr;
 661       // Tries to extract a constant offset from this GEP index.
 662       int64_t ConstantOffset =
 663           ConstantOffsetExtractor::Extract(GEP->getOperand(I), NewIdx, DL, GEP);
 664       if (ConstantOffset != 0) {
 665         assert(NewIdx != nullptr &&
 666                "ConstantOffset != 0 implies NewIdx is set");
 667         GEP->setOperand(I, NewIdx);
 668       }
 669     }
 670   }
 671   // Clear the inbounds attribute because the new index may be off-bound.
 672   // e.g.,
 673   //
 674   // b = add i64 a, 5
 675   // addr = gep inbounds float* p, i64 b
 676   //
 677   // is transformed to:
 678   //
 679   // addr2 = gep float* p, i64 a
 680   // addr = gep float* addr2, i64 5
 681   //
 682   // If a is -4, although the old index b is in bounds, the new index a is
 683   // off-bound. http://llvm.org/docs/LangRef.html#id181 says "if the
 684   // inbounds keyword is not present, the offsets are added to the base
 685   // address with silently-wrapping two's complement arithmetic".
 686   // Therefore, the final code will be a semantically equivalent.
 687   //
 688   // TODO(jingyue): do some range analysis to keep as many inbounds as
 689   // possible. GEPs with inbounds are more friendly to alias analysis.
 690   GEP->setIsInBounds(false);
 691
 692   // Offsets the base with the accumulative byte offset.
 693   //
 694   //   %gep                        ; the base
 695   //   ... %gep ...
 696   //
 697   // => add the offset
 698   //
 699   //   %gep2                       ; clone of %gep
 700   //   %new.gep = gep %gep2, <offset / sizeof(*%gep)>
 701   //   %gep                        ; will be removed
 702   //   ... %gep ...
 703   //
 704   // => replace all uses of %gep with %new.gep and remove %gep
 705   //
 706   //   %gep2                       ; clone of %gep
 707   //   %new.gep = gep %gep2, <offset / sizeof(*%gep)>
 708   //   ... %new.gep ...
 709   //
 710   // If AccumulativeByteOffset is not a multiple of sizeof(*%gep), we emit an
 711   // uglygep (http://llvm.org/docs/GetElementPtr.html#what-s-an-uglygep):
 712   // bitcast %gep2 to i8*, add the offset, and bitcast the result back to the
 713   // type of %gep.
 714   //
 715   //   %gep2                       ; clone of %gep
 716   //   %0       = bitcast %gep2 to i8*
 717   //   %uglygep = gep %0, <offset>
 718   //   %new.gep = bitcast %uglygep to <type of %gep>
 719   //   ... %new.gep ...
 720   Instruction *NewGEP = GEP->clone();
 721   NewGEP->insertBefore(GEP);
 722
 723   uint64_t ElementTypeSizeOfGEP =
 724       DL->getTypeAllocSize(GEP->getType()->getElementType());
 725   Type *IntPtrTy = DL->getIntPtrType(GEP->getType());
 726   if (AccumulativeByteOffset % ElementTypeSizeOfGEP == 0) {
 727     // Very likely. As long as %gep is natually aligned, the byte offset we
 728     // extracted should be a multiple of sizeof(*%gep).
 729     // Per ANSI C standard, signed / unsigned = unsigned. Therefore, we
 730     // cast ElementTypeSizeOfGEP to signed.
 731     int64_t Index =
 732         AccumulativeByteOffset / static_cast<int64_t>(ElementTypeSizeOfGEP);
 733     NewGEP = GetElementPtrInst::Create(
 734         NewGEP, ConstantInt::get(IntPtrTy, Index, true), GEP->getName(), GEP);
 735   } else {
 736     // Unlikely but possible. For example,
 737     // #pragma pack(1)
 738     // struct S {
 739     //   int a[3];
 740     //   int64 b[8];
 741     // };
 742     // #pragma pack()
 743     //
 744     // Suppose the gep before extraction is &s[i + 1].b[j + 3]. After
 745     // extraction, it becomes &s[i].b[j] and AccumulativeByteOffset is
 746     // sizeof(S) + 3 * sizeof(int64) = 100, which is not a multiple of
 747     // sizeof(int64).
 748     //
 749     // Emit an uglygep in this case.
 750     Type *I8PtrTy = Type::getInt8PtrTy(GEP->getContext(),
 751                                        GEP->getPointerAddressSpace());
 752     NewGEP = new BitCastInst(NewGEP, I8PtrTy, "", GEP);
 753     NewGEP = GetElementPtrInst::Create(
 754         NewGEP, ConstantInt::get(IntPtrTy, AccumulativeByteOffset, true),
 755         "uglygep", GEP);
 756     if (GEP->getType() != I8PtrTy)
 757       NewGEP = new BitCastInst(NewGEP, GEP->getType(), GEP->getName(), GEP);
 758   }
 759
 760   GEP->replaceAllUsesWith(NewGEP);
 761   GEP->eraseFromParent();
 762
 763   return true;
 764 }
 765
 766 bool SeparateConstOffsetFromGEP::runOnFunction(Function &F) {
 767   if (DisableSeparateConstOffsetFromGEP)
 768     return false;
 769
 770   bool Changed = false;
 771   for (Function::iterator B = F.begin(), BE = F.end(); B != BE; ++B) {
 772     for (BasicBlock::iterator I = B->begin(), IE = B->end(); I != IE; ) {
 773       if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(I++)) {
 774         Changed |= splitGEP(GEP);
 775       }
 776       // No need to split GEP ConstantExprs because all its indices are constant
 777       // already.
 778     }
 779   }
 780   return Changed;
 781 }