Fix a bug when lead load isn't anchor load.

When lead load isn't anchor load, the new address will need
to be recalculated based on anchor's address. This issue
was exposed by ocl conformance test_conversions

Author: jgu222

IGC/Compiler/CISACodeGen/MemOpt.cpp

@@ -2377,6 +2377,14 @@ SymbolicPointer::decomposePointer(const Value* Ptr, SymbolicPointer& SymPtr,
     return true;
 }
 
+
+// Debugging
+//#define _LDST_DEBUG 1
+#undef _LDST_DEBUG
+#if defined(_LDST_DEBUG)
+static int _bundleid = 0;
+#endif
+
 namespace {
     enum class AddressModel {
         BTS, A32, SLM, A64
@@ -2765,13 +2773,6 @@ const BundleSize_t BundleConfig::m_d64VecSizes_u = { 2,3,4,8,16,32,64 };
 const BundleSize_t BundleConfig::m_d32VecSizes_u = { 2,3,4,8,16,32,64 };
 const BundleSize_t BundleConfig::m_d8VecSizes_u = { 2,4,8,16,32 };
 
-// Debugging
-//#define _LDST_DEBUG 1
-#undef _LDST_DEBUG
-#if defined(_LDST_DEBUG)
-static int _bundleid = 0;
-#endif
-
 bool IGC::doLdStCombine(const CodeGenContext* CGC) {
     if (CGC->type == ShaderType::OPENCL_SHADER) {
        auto oclCtx = (const OpenCLProgramContext*)CGC;
@@ -4753,7 +4754,10 @@ void LdStCombine::createCombinedLoads(Function& F)
 
         // find anchor load.
         LoadInst* anchorLoad = leadLoad;
-        int n = m_instOrder[anchorLoad];
+        const int leadLoadNum = m_instOrder[leadLoad];
+        const int leadOffset = (int)Loads[0].ByteOffset;
+        int anchorOffset = leadOffset;
+        int n = leadLoadNum;
         // insts are assigned order number starting from 0. Anchor load is
         // one with the smallest inst order number.
         for (int i = 1, sz = (int)bundle.LoadStores.size(); i < sz; ++i) {
@@ -4763,9 +4767,11 @@ void LdStCombine::createCombinedLoads(Function& F)
             {
                 n = LI_no;
                 anchorLoad = LI;
+                anchorOffset = (int)Loads[i].ByteOffset;
             }
             loadedValues.push_back(LI);
         }
+        const int anchorLoadNum = n;
 
         int eltBytes = bundle.bundle_eltBytes;
         int nelts = bundle.bundle_numElts;
@@ -4796,6 +4802,28 @@ void LdStCombine::createCombinedLoads(Function& F)
 
         IRBuilder<> irBuilder(anchorLoad);
         Value* Addr = leadLoad->getPointerOperand();
+        // If leadLoad is different from anchorLoad and leadLoad's addr is
+        // an instruction after anchorLoad, need to re-generate the address
+        // of LeadLoad at anchorLoad place.
+        if (anchorLoad != leadLoad && isa<Instruction>(Addr)) {
+            Instruction* aI = cast<Instruction>(Addr);
+            auto MI = m_instOrder.find(aI);
+            if (MI != m_instOrder.end() && MI->second > anchorLoadNum)
+            {
+                Value* anchorAddr = anchorLoad->getPointerOperand();
+                Type* bTy = Type::getInt8Ty(leadLoad->getContext());
+                Type* nTy = PointerType::get(bTy, leadLoad->getPointerAddressSpace());
+                Value* nAddr = irBuilder.CreateBitCast(anchorAddr, nTy);
+                Value* aIdx = irBuilder.getInt64(leadOffset - anchorOffset);
+                GEPOperator* aGEP = dyn_cast<GEPOperator>(anchorAddr);
+                if (aGEP && aGEP->isInBounds()) {
+                    Addr = irBuilder.CreateInBoundsGEP(bTy, nAddr, aIdx, "anchorLoad");
+                }
+                else {
+                    Addr = irBuilder.CreateGEP(bTy, nAddr, aIdx, "anchorLoad");
+                }
+            };
+        }
         PointerType* PTy = cast<PointerType>(Addr->getType());
         PointerType* nPTy = PointerType::get(VTy, PTy->getAddressSpace());
         Value* nAddr = irBuilder.CreateBitCast(Addr, nPTy);

IGC/Compiler/tests/LdStCombine/load_basic.ll

@@ -132,7 +132,6 @@ entry:
 ;
 ; CHECK-LABEL:  store <2 x i64>
 ; CHECK: load <4 x i32>
-; CHECK-LABEL: ret void
 ;
   %c5.baseidx = add i64 %conv.i.i, 512
   %c5.arrayidx = getelementptr inbounds i32, i32 addrspace(1)* %si, i64 %c5.baseidx
@@ -156,5 +155,30 @@ entry:
   %c5.addr = bitcast i32 addrspace(1)* %c5.arrayidx1 to <4 x i32> addrspace(1)*
   store <4 x i32> %c5.e0.3, <4 x i32> addrspace(1)* %c5.addr, align 4
 
+;
+; case 6: load i32 p+1; load i32 p -> load <2 x i32>
+;    This is to test that lead load is not the first and therefore, an address of
+;    of anchor load is used instead.
+;
+; CHECK-LABEL:  c6.baseidx
+; CHECK:        %c6.arrayidx = getelementptr inbounds i32, i32 addrspace(1)* %si, i64 %c6.baseidx
+; CHECK:        [[T6_0:%.*]] = bitcast i32 addrspace(1)* %c6.arrayidx to i8 addrspace(1)*
+; CHECK:        [[T6_1:%.*]] = getelementptr inbounds i8, i8 addrspace(1)* [[T6_0]], i64 -4
+; CHECK:        [[T6_2:%.*]] = bitcast i8 addrspace(1)* [[T6_1]] to <2 x i32> addrspace(1)*
+; CHECK:        {{.*}} = load <2 x i32>, <2 x i32> addrspace(1)* [[T6_2]], align 4
+; CHECK-LABEL: ret void
+;
+  %c6.baseidx = add i64 %conv.i.i, 577
+  %c6.arrayidx = getelementptr inbounds i32, i32 addrspace(1)* %si, i64 %c6.baseidx
+  %c6.0 = load i32, i32 addrspace(1)* %c6.arrayidx, align 4
+  %c6.baseidx.1 = add i64 %conv.i.i, 576
+  %c6.arrayidx.1 = getelementptr inbounds i32, i32 addrspace(1)* %si, i64 %c6.baseidx.1
+  %c6.1 = load i32, i32 addrspace(1)* %c6.arrayidx.1, align 4
+  %c6.v.0 = insertelement <2 x i32> undef,    i32 %c6.0, i64 0
+  %c6.v.1 = insertelement <2 x i32> %c6.v.0, i32 %c6.1, i64 1
+  %c6.arrayidx1 = getelementptr inbounds i32, i32 addrspace(1)* %d, i64 %c6.baseidx
+  %c6.addr = bitcast i32 addrspace(1)* %c6.arrayidx1 to <2 x i32> addrspace(1)*
+  store <2 x i32> %c6.v.1, <2 x i32> addrspace(1)* %c6.addr, align 4
+
   ret void
 }