Refactor canonicalizing array indices to a helper function

[jingyue]

Summary

No functionality changes.

[meheff]

LGTM

[jingyue]

Committed in r210438

lib/Transforms/Scalar/SeparateConstOffsetFromGEP.cpp

public:
   SeparateConstOffsetFromGEP() : FunctionPass(ID) {
     initializeSeparateConstOffsetFromGEPPass(*PassRegistry::getPassRegistry());
   }
 
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.addRequired<DataLayoutPass>();
     AU.addRequired<TargetTransformInfo>();
   }
+
+  bool doInitialization(Module &M) override {
+    DataLayoutPass *DLP = getAnalysisIfAvailable<DataLayoutPass>();
+    if (DLP == nullptr)
+      report_fatal_error("data layout missing");
+    DL = &DLP->getDataLayout();
+    return false;
+  }
+
   bool runOnFunction(Function &F) override;
 
  private:
   /// Tries to split the given GEP into a variadic base and a constant offset,
   /// and returns true if the splitting succeeds.
   bool splitGEP(GetElementPtrInst *GEP);
   /// Finds the constant offset within each index, and accumulates them. This
   /// function only inspects the GEP without changing it. The output
   /// NeedsExtraction indicates whether we can extract a non-zero constant
   /// offset from any index.
-  int64_t accumulateByteOffset(GetElementPtrInst *GEP, const DataLayout *DL,
-                               bool &NeedsExtraction);
+  int64_t accumulateByteOffset(GetElementPtrInst *GEP, bool &NeedsExtraction);
+  /// Canonicalize array indices to pointer-size integers. This helps to
+  /// simplify the logic of splitting a GEP. For example, if a + b is a
+  /// pointer-size integer, we have
+  ///   gep base, a + b = gep (gep base, a), b
+  /// However, this equality may not hold if the size of a + b is smaller than
+  /// the pointer size, because LLVM conceptually sign-extends GEP indices to
+  /// pointer size before computing the address
+  /// (http://llvm.org/docs/LangRef.html#id181).
+  ///
+  /// This canonicalization is very likely already done in clang and
+  /// instcombine. Therefore, the program will probably remain the same.
+  ///
+  /// Verified in @i32_add in split-gep.ll
+  bool canonicalizeArrayIndicesToPointerSize(GetElementPtrInst *GEP);
+
+  const DataLayout *DL;
 };
 }  // anonymous namespace
 
 char SeparateConstOffsetFromGEP::ID = 0;
 INITIALIZE_PASS_BEGIN(
     SeparateConstOffsetFromGEP, "separate-const-offset-from-gep",
     "Split GEPs to a variadic base and a constant offset for better CSE", false,
     false)
bool ConstantOffsetExtractor::NoCommonBits(Value *LHS, Value *RHS) const {
   assert(LHS->getType() == RHS->getType() &&
          "LHS and RHS should have the same type");
   APInt LHSKnownOne, LHSKnownZero, RHSKnownOne, RHSKnownZero;
   ComputeKnownBits(LHS, LHSKnownOne, LHSKnownZero);
   ComputeKnownBits(RHS, RHSKnownOne, RHSKnownZero);
   return (LHSKnownZero | RHSKnownZero).isAllOnesValue();
 }
 
-int64_t SeparateConstOffsetFromGEP::accumulateByteOffset(
-    GetElementPtrInst *GEP, const DataLayout *DL, bool &NeedsExtraction) {
+bool SeparateConstOffsetFromGEP::canonicalizeArrayIndicesToPointerSize(
+    GetElementPtrInst *GEP) {
+  bool Changed = false;
+  Type *IntPtrTy = DL->getIntPtrType(GEP->getType());
+  gep_type_iterator GTI = gep_type_begin(*GEP);
+  for (User::op_iterator I = GEP->op_begin() + 1, E = GEP->op_end();
+       I != E; ++I, ++GTI) {
+    // Skip struct member indices which must be i32.
+    if (isa<SequentialType>(*GTI)) {
+      if ((*I)->getType() != IntPtrTy) {
+        *I = CastInst::CreateIntegerCast(*I, IntPtrTy, true, "idxprom", GEP);
+        Changed = true;
+      }
+    }
+  }
+  return Changed;
+}
+
+int64_t
+SeparateConstOffsetFromGEP::accumulateByteOffset(GetElementPtrInst *GEP,
+                                                 bool &NeedsExtraction) {
   NeedsExtraction = false;
   int64_t AccumulativeByteOffset = 0;
   gep_type_iterator GTI = gep_type_begin(*GEP);
   for (unsigned I = 1, E = GEP->getNumOperands(); I != E; ++I, ++GTI) {
     if (isa<SequentialType>(*GTI)) {
       // Tries to extract a constant offset from this GEP index.
       int64_t ConstantOffset =
           ConstantOffsetExtractor::Find(GEP->getOperand(I), DL, GEP);
if (GEP->getType()->isVectorTy())
     return false;
 
   // The backend can already nicely handle the case where all indices are
   // constant.
   if (GEP->hasAllConstantIndices())
     return false;
 
   bool Changed = false;
-  // Canonicalize array indices to pointer-size integers. This helps to simplify
-  // the logic of splitting a GEP. For example, if a + b is a pointer-size
-  // integer, we have
-  //   gep base, a + b = gep (gep base, a), b
-  // However, this equality may not hold if the size of a + b is smaller than
-  // the pointer size, because LLVM conceptually sign-extends GEP indices to
-  // pointer size before computing the address
-  // (http://llvm.org/docs/LangRef.html#id181).
-  //
-  // This canonicalization is very likely already done in clang and instcombine.
-  // Therefore, the program will probably remain the same.
-  //
-  // Verified in @i32_add in split-gep.ll
-  const DataLayout *DL = &getAnalysis<DataLayoutPass>().getDataLayout();
-  Type *IntPtrTy = DL->getIntPtrType(GEP->getType());
-  gep_type_iterator GTI = gep_type_begin(*GEP);
-  for (User::op_iterator I = GEP->op_begin() + 1, E = GEP->op_end();
-       I != E; ++I, ++GTI) {
-    if (isa<SequentialType>(*GTI)) {
-      if ((*I)->getType() != IntPtrTy) {
-        *I = CastInst::CreateIntegerCast(*I, IntPtrTy, true, "idxprom", GEP);
-        Changed = true;
-      }
-    }
-  }
+  Changed |= canonicalizeArrayIndicesToPointerSize(GEP);
 
   bool NeedsExtraction;
-  int64_t AccumulativeByteOffset =
-      accumulateByteOffset(GEP, DL, NeedsExtraction);
+  int64_t AccumulativeByteOffset = accumulateByteOffset(GEP, NeedsExtraction);
 
   if (!NeedsExtraction)
     return Changed;
   // Before really splitting the GEP, check whether the backend supports the
   // addressing mode we are about to produce. If no, this splitting probably
   // won't be beneficial.
   TargetTransformInfo &TTI = getAnalysis<TargetTransformInfo>();
   if (!TTI.isLegalAddressingMode(GEP->getType()->getElementType(),
                                  /*BaseGV=*/nullptr, AccumulativeByteOffset,
                                  /*HasBaseReg=*/true, /*Scale=*/0)) {
     return Changed;
   }
 
   // Remove the constant offset in each GEP index. The resultant GEP computes
   // the variadic base.
-  GTI = gep_type_begin(*GEP);
+  gep_type_iterator GTI = gep_type_begin(*GEP);
   for (unsigned I = 1, E = GEP->getNumOperands(); I != E; ++I, ++GTI) {
     if (isa<SequentialType>(*GTI)) {
       Value *NewIdx = nullptr;
       // Tries to extract a constant offset from this GEP index.
       int64_t ConstantOffset =
           ConstantOffsetExtractor::Extract(GEP->getOperand(I), NewIdx, DL, GEP);
       if (ConstantOffset != 0) {
         assert(NewIdx != nullptr &&
bool SeparateConstOffsetFromGEP::splitGEP(GetElementPtrInst *GEP) {
   //   %uglygep = gep %0, <offset>
   //   %new.gep = bitcast %uglygep to <type of %gep>
   //   ... %new.gep ...
   Instruction *NewGEP = GEP->clone();
   NewGEP->insertBefore(GEP);
 
   uint64_t ElementTypeSizeOfGEP =
       DL->getTypeAllocSize(GEP->getType()->getElementType());
+  Type *IntPtrTy = DL->getIntPtrType(GEP->getType());
   if (AccumulativeByteOffset % ElementTypeSizeOfGEP == 0) {
     // Very likely. As long as %gep is natually aligned, the byte offset we
     // extracted should be a multiple of sizeof(*%gep).
     // Per ANSI C standard, signed / unsigned = unsigned. Therefore, we
     // cast ElementTypeSizeOfGEP to signed.
     int64_t Index =
         AccumulativeByteOffset / static_cast<int64_t>(ElementTypeSizeOfGEP);
     NewGEP = GetElementPtrInst::Create(