[CodeGenPrepare][NFC] Replace GEP's offset computation with collectOffset

[nikic]

There is some small compile-time impact: https://llvm-compile-time-tracker.com/compare.php?from=d55982ac8cced9e5d4816494658d90c84d0b4301&to=e8999647fc7d8d3122a01871231f8dc306870f30&stat=instructions:u Probably either due to the round-trip through APInt, or the need to allocate the MapVector.

llvm/lib/CodeGen/CodeGenPrepare.cpp

int64_t Scale = Opcode == Instruction::Shl
                         ? 1LL << RHS->getLimitedValue(RHS->getBitWidth() - 1)
                         : RHS->getSExtValue();
 
     return matchScaledValue(AddrInst->getOperand(0), Scale, Depth);
   }
   case Instruction::GetElementPtr: {
     // Scan the GEP.  We check it if it contains constant offsets and at most
     // one variable offset.
-    int VariableOperand = -1;
     unsigned VariableScale = 0;
+    Value *VariableOperand = nullptr;
+
+    APInt Offset(DL.getIndexTypeSizeInBits(AddrInst->getOperand(0)->getType()),
+                 0);
+    MapVector<Value *, APInt> VariableOffsets;
+    cast<GEPOperator>(AddrInst)->collectOffset(DL, Offset.getBitWidth(),
+                                               VariableOffsets, Offset);
 
-    int64_t ConstantOffset = 0;
-    gep_type_iterator GTI = gep_type_begin(AddrInst);
-    for (unsigned i = 1, e = AddrInst->getNumOperands(); i != e; ++i, ++GTI) {
-      if (StructType *STy = GTI.getStructTypeOrNull()) {
-        const StructLayout *SL = DL.getStructLayout(STy);
-        unsigned Idx =
-            cast<ConstantInt>(AddrInst->getOperand(i))->getZExtValue();
-        ConstantOffset += SL->getElementOffset(Idx);
-      } else {
-        TypeSize TS = DL.getTypeAllocSize(GTI.getIndexedType());
-        if (TS.isNonZero()) {
-          // The optimisations below currently only work for fixed offsets.
-          if (TS.isScalable())
-            return false;
-          int64_t TypeSize = TS.getFixedValue();
-          if (ConstantInt *CI =
-                  dyn_cast<ConstantInt>(AddrInst->getOperand(i))) {
-            const APInt &CVal = CI->getValue();
-            if (CVal.getSignificantBits() <= 64) {
-              ConstantOffset += CVal.getSExtValue() * TypeSize;
-              continue;
-            }
-          }
-          // We only allow one variable index at the moment.
-          if (VariableOperand != -1)
-            return false;
+    if (VariableOffsets.size() > 1)
 
-          // Remember the variable index.
-          VariableOperand = i;
-          VariableScale = TypeSize;
-        }
-      }
+    if (VariableOffsets.size() == 1) {
+      VariableOperand = VariableOffsets.begin()->first;
+      VariableScale = VariableOffsets.begin()->second.getZExtValue();
     }
 
+    int64_t ConstantOffset = Offset.getSExtValue();
     // A common case is for the GEP to only do a constant offset.  In this case,
     // just add it to the disp field and check validity.
-    if (VariableOperand == -1) {
+    if (!VariableOperand) {
       AddrMode.BaseOffs += ConstantOffset;
       if (matchAddr(AddrInst->getOperand(0), Depth + 1)) {
           if (!cast<GEPOperator>(AddrInst)->isInBounds())
             AddrMode.InBounds = false;
           return true;
       }
       AddrMode.BaseOffs -= ConstantOffset;
 
if (!matchAddr(AddrInst->getOperand(0), Depth + 1)) {
         AddrModeInsts.resize(OldSize);
         return false;
       }
       AddrMode.HasBaseReg = true;
       AddrMode.BaseReg = AddrInst->getOperand(0);
     }
 
     // Match the remaining variable portion of the GEP.
-    if (!matchScaledValue(AddrInst->getOperand(VariableOperand), VariableScale,
-                          Depth)) {
+    if (!matchScaledValue(VariableOperand, VariableScale, Depth)) {
       // If it couldn't be matched, try stuffing the base into a register
       // instead of matching it, and retrying the match of the scale.
       AddrMode = BackupAddrMode;
       AddrModeInsts.resize(OldSize);
       if (AddrMode.HasBaseReg)
         return false;
       AddrMode.HasBaseReg = true;
       AddrMode.BaseReg = AddrInst->getOperand(0);
       AddrMode.BaseOffs += ConstantOffset;
-      if (!matchScaledValue(AddrInst->getOperand(VariableOperand),
-                            VariableScale, Depth)) {
+      if (!matchScaledValue(VariableOperand, VariableScale, Depth)) {
         // If even that didn't work, bail.
         AddrMode = BackupAddrMode;
         AddrModeInsts.resize(OldSize);
         return false;
       }
     }
 
     return true;