[X86][CostModel] Strip bitcasts when looking for store GEP operand

[aeubanks]

Summary

This heuristic was introduced in D35888. Assuming it is correct, this
patch should make cost modeling a bit more robust.

This came about when looking at opaque pointers where a bitcast that previously appeared hid this heuristic. This actually regresses the benchmark I was looking at due to less loop unrolling (gesummv in llvm-test-suite), but I'm not sure how else to solve that besides removing this heuristic entirely.

[RKSimon]

llvm/lib/Target/X86/X86TargetTransformInfo.cpp

3910

I wonder whether this needs inverting - and we default stores to a cost of TTI::TCC_Basic * 2 UNLESS after stripping we find all indices are constant?

[nikic]

llvm/lib/Target/X86/X86TargetTransformInfo.cpp

3910

I believe this code is intended to catch the case where we have a GEP that was modeled as free due to addressing mode support, but has non-constant indices and that addressing mode is non-free in store instructions. So I think the current logic is right, though could be more precise if we checked that the GEP cost is actually TCC_Free, otherwise we might double-cost the GEP.

llvm/lib/Target/X86/X86TargetTransformInfo.cpp

InstructionCost X86TTIImpl::getMemoryOpCost(unsigned Opcode, Type *Src,
                                             unsigned AddressSpace,
                                             TTI::TargetCostKind CostKind,
                                             const Instruction *I) {
   // TODO: Handle other cost kinds.
   if (CostKind != TTI::TCK_RecipThroughput) {
     if (auto *SI = dyn_cast_or_null<StoreInst>(I)) {
       // Store instruction with index and scale costs 2 Uops.
       // Check the preceding GEP to identify non-const indices.
-      if (auto *GEP = dyn_cast<GetElementPtrInst>(SI->getPointerOperand())) {
+      if (auto *GEP = dyn_cast<GetElementPtrInst>(
+              SI->getPointerOperand()->stripPointerCasts())) {
         if (!all_of(GEP->indices(), [](Value *V) { return isa<Constant>(V); }))
           return TTI::TCC_Basic * 2;
       }
     }
     return TTI::TCC_Basic;
   }
 
   assert((Opcode == Instruction::Load || Opcode == Instruction::Store) &&
          "Invalid Opcode");
   // Type legalization can't handle structs
   if (TLI->getValueType(DL, Src, true) == MVT::Other)
     return BaseT::getMemoryOpCost(Opcode, Src, Alignment, AddressSpace,
                                   CostKind);

llvm/test/Transforms/LoopUnroll/X86/store_cost.ll

loop.body:
   %val3 = add i32 %counter, 8
   %xptr3 = getelementptr [1024 x i32], [1024 x i32]* %x03, i32 0, i32 %counter
   store i32 %val3, i32* %xptr3
   %val4 = add i32 %counter, 9
   %xptr4 = getelementptr [1024 x i32], [1024 x i32]* %x04, i32 0, i32 %counter
   store i32 %val4, i32* %xptr4
   %val5 = add i32 %counter, 10
   %xptr5 = getelementptr [1024 x i32], [1024 x i32]* %x05, i32 0, i32 %counter
-  store i32 %val5, i32* %xptr5
+  %bc = bitcast i32* %xptr5 to i16*
+  %val5trunc = trunc i32 %val5 to i16
+  store i16 %val5trunc, i16* %bc
   br label %loop.inc
 
 loop.inc:
   %inc = add i32 %counter, 2
   %1 = icmp sge i32 %inc, 1023
   br i1 %1, label  %exit.0, label %loop.header
 
 exit.0: