[InferAddressSpaces] Enhance the handling of cosntexpr.

[hliao]

Summary

• Constant expressions may not be added in strict postorder as the forward instruction scan order. Thus, for a constant express (CE0), if its operand (CE1) is used in an previous instruction, they are not in postorder. However, different from cloneInstructionWithNewAddressSpace, cloneConstantExprWithNewAddressSpace doesn't bookkeep uninferred instructions for later resolving. That results in failure of inferring constant address.
• This patch adds the support to infer constant expression operand recursively, since there won't be loop, if that operand is another constant expression.

[arsenm]

LGTM, though I’m not sure I follow the part of the message where you conclude there can’t be a loop. You can have cycles in constant expressions, which I thought this already handles correctly

llvm/trunk/lib/Transforms/Scalar/InferAddressSpaces.cpp

for (unsigned Index = 0; Index < CE->getNumOperands(); ++Index) {
     // If the address space of `Operand` needs to be modified, the new operand
     // with the new address space should already be in ValueWithNewAddrSpace
     // because (1) the constant expressions we consider (i.e. addrspacecast,
     // bitcast, and getelementptr) do not incur cycles in the data flow graph
     // and (2) this function is called on constant expressions in postorder.
     if (Value *NewOperand = ValueWithNewAddrSpace.lookup(Operand)) {
       IsNew = true;
       NewOperands.push_back(cast<Constant>(NewOperand));
-    } else {
-      // Otherwise, reuses the old operand.
-      NewOperands.push_back(Operand);
-    }
-  }
+      continue;
+    }
+    if (auto CExpr = dyn_cast<ConstantExpr>(Operand))
+      if (Value *NewOperand = cloneConstantExprWithNewAddressSpace(
+              CExpr, NewAddrSpace, ValueWithNewAddrSpace)) {
+        IsNew = true;
+        NewOperands.push_back(cast<Constant>(NewOperand));
+        continue;
+      }
 
   // If !IsNew, we will replace the Value with itself. However, replaced values
   // are assumed to wrapped in a addrspace cast later so drop it now.
   if (!IsNew)
     return nullptr;
 
   if (CE->getOpcode() == Instruction::GetElementPtr) {
     // Needs to specify the source type while constructing a getelementptr

llvm/trunk/test/Transforms/InferAddressSpaces/AMDGPU/infer-getelementptr.ll

define void @repeated_constexpr_gep_addrspacecast(i64 %idx0, i64 %idx1) {
   store double 1.0, double addrspace(3)* %asc0, align 8
 
   %gep1 = getelementptr inbounds double, double* getelementptr ([648 x double], [648 x double]* addrspacecast ([648 x double] addrspace(3)* @lds to [648 x double]*), i64 0, i64 384), i64 %idx1
   %asc1 = addrspacecast double* %gep1 to double addrspace(3)*
   store double 1.0, double addrspace(3)* %asc1, align 8
 
   ret void
 }
+
+; CHECK-LABEL: @unorder_constexpr_gep_bitcast(
+; CHECK-NEXT: %x0 = load i32, i32 addrspace(3)* bitcast ([648 x double] addrspace(3)* @lds to i32 addrspace(3)*), align 4
+; CHECK-NEXT: %x1 = load i32, i32 addrspace(3)* getelementptr (i32, i32 addrspace(3)* bitcast ([648 x double] addrspace(3)* @lds to i32 addrspace(3)*), i32 1), align 4
+define void @unorder_constexpr_gep_bitcast() {
+  %x0 = load i32, i32* bitcast ([648 x double]* addrspacecast ([648 x double] addrspace(3)* @lds to [648 x double]*) to i32*), align 4
+  %x1 = load i32, i32* getelementptr (i32, i32* bitcast ([648 x double]* addrspacecast ([648 x double] addrspace(3)* @lds to [648 x double]*) to i32*), i32 1), align 4
+  call void @use(i32 %x0, i32 %x1)
+  ret void
+}
+
+declare void @use(i32, i32)

llvm/trunk/test/Transforms/InferAddressSpaces/NVPTX/clone_constexpr.ll

 ; RUN: opt -S -mtriple=nvptx64-nvidia-cuda -infer-address-spaces %s | FileCheck %s
 
 %struct.S = type { [5 x i32] }
 
 $g1 = comdat any
 
 @g1 = linkonce_odr addrspace(3) global %struct.S zeroinitializer, comdat, align 4
 
 ; CHECK-LABEL: @foo(
 ; CHECK:  %x0 = tail call i32 @llvm.nvvm.read.ptx.sreg.tid.x() #2
 ; CHECK:  %idxprom.i = zext i32 %x0 to i64
 ; CHECK:  %arrayidx.i = getelementptr %struct.S, %struct.S* addrspacecast (%struct.S addrspace(3)* @g1 to %struct.S*), i64 0, i32 0, i64 %idxprom.i
 ; CHECK:  tail call void @f1(i32* %arrayidx.i, i32 undef) #0
-; CHECK:  %x1 = load i32, i32* getelementptr (%struct.S, %struct.S* addrspacecast (%struct.S addrspace(3)* @g1 to %struct.S*), i64 0, i32 0, i64 0), align 4
+; CHECK:  %x1 = load i32, i32 addrspace(3)* getelementptr inbounds (%struct.S, %struct.S addrspace(3)* @g1, i64 0, i32 0, i64 0), align 4
 ; CHECK:  %L.sroa.0.0.insert.ext.i = zext i32 %x1 to i64
 ; CHECK:  tail call void @f2(i64* null, i64 %L.sroa.0.0.insert.ext.i) #0
 ; CHECK:  ret void
 define void @foo() local_unnamed_addr #0 {
 entry:
   %x0 = tail call i32 @llvm.nvvm.read.ptx.sreg.tid.x() #2
   %idxprom.i = zext i32 %x0 to i64
   %arrayidx.i = getelementptr %struct.S, %struct.S* addrspacecast (%struct.S addrspace(3)* @g1 to %struct.S*), i64 0, i32 0, i64 %idxprom.i