Fix constant folding of addrspacecast

[arsenm]

ping

[majnemer]

lib/Analysis/ConstantFolding.cpp

1232–1246

This is suspicious to me. It implies that performing a ConstantExpr::getCast(Instruction::AddrSpaceCast) on an IntToPtr does the wrong thing and suggests to me that the bug lies elsewhere.

[arsenm]

Add test that shows ConstantExpr::getAddrSpaceCast does the right thing

[majnemer]

Er, I'm still very confused here. Let's take your example @constant_fold_inttoptr.

trunk turns this into:

define void @constant_fold_inttoptr() {
  store i32 7, i32 addrspace(4)* addrspacecast (i32 addrspace(3)* inttoptr (i32 -1 to i32 addrspace(3)*) to i32 addrspace(4)*)
  ret void
}

I'm not seeing an argument as to why this is not desirable. The target should still have all the information it needs, the only difference I see is that contains an additional ConstantExpr instead of an additional Instruction.

[arsenm]

In D20144#436115, @majnemer wrote:

Er, I'm still very confused here. Let's take your example @constant_fold_inttoptr.

trunk turns this into:

define void @constant_fold_inttoptr() {
  store i32 7, i32 addrspace(4)* addrspacecast (i32 addrspace(3)* inttoptr (i32 -1 to i32 addrspace(3)*) to i32 addrspace(4)*)
  ret void
}

I'm not seeing an argument as to why this is not desirable. The target should still have all the information it needs, the only difference I see is that contains an additional ConstantExpr instead of an additional Instruction.

The constant value for a pointer in one address space may not match the value in another address space, so constant folding it to the same constant is incorrect

[arsenm]

Only need to handle null

[majnemer]

LGTM

[arsenm]

r270293

lib/Analysis/ConstantFolding.cpp

if (!all_of(I->operands(), [](Use &U) { return isa<Constant>(U); }))
     return nullptr;
 
   SmallVector<Constant *, 8> Ops;
   for (User::op_iterator i = I->op_begin(), e = I->op_end(); i != e; ++i) {
     Constant *Op = cast<Constant>(*i);
     // Fold the Instruction's operands.
     if (ConstantExpr *NewCE = dyn_cast<ConstantExpr>(Op))
       Op = ConstantFoldConstantExpression(NewCE, DL, TLI);
+    if (!Op)
+      return nullptr;
 
     Ops.push_back(Op);
   }
 
   if (const CmpInst *CI = dyn_cast<CmpInst>(I))
     return ConstantFoldCompareInstOperands(CI->getPredicate(), Ops[0], Ops[1],
                                            DL, TLI);
 
for (User::const_op_iterator i = CE->op_begin(), e = CE->op_end(); i != e;
        ++i) {
     Constant *NewC = cast<Constant>(*i);
     // Recursively fold the ConstantExpr's operands. If we have already folded
     // a ConstantExpr, we don't have to process it again.
     if (ConstantExpr *NewCE = dyn_cast<ConstantExpr>(NewC)) {
       if (FoldedOps.insert(NewCE).second)
         NewC = ConstantFoldConstantExpressionImpl(NewCE, DL, TLI, FoldedOps);
     }
+
+    if (!NewC)
+      return nullptr;
+
     Ops.push_back(NewC);
   }
 
   if (CE->isCompare())
     return ConstantFoldCompareInstOperands(CE->getPredicate(), Ops[0], Ops[1],
                                            DL, TLI);
 
   return ConstantFoldInstOperandsImpl(CE, CE->getType(), CE->getOpcode(), Ops,
Constant *llvm::ConstantFoldCastOperand(unsigned Opcode, Constant *C,
   case Instruction::ZExt:
   case Instruction::SExt:
   case Instruction::FPTrunc:
   case Instruction::FPExt:
   case Instruction::UIToFP:
   case Instruction::SIToFP:
   case Instruction::FPToUI:
   case Instruction::FPToSI:
-  case Instruction::AddrSpaceCast:
       return ConstantExpr::getCast(Opcode, C, DestTy);
+  case Instruction::AddrSpaceCast: {
+    if (isa<UndefValue>(C))
+      return UndefValue::get(DestTy);
+
+    // It is up to the target for how to constant fold immediates.
+    if (ConstantExpr *CE = dyn_cast<ConstantExpr>(C)) {
+      if (CE->getOpcode() == Instruction::IntToPtr)
+        return nullptr;
+
+      if (auto *NewCE = ConstantFoldConstantExpression(CE, DL, nullptr))
+        return ConstantExpr::getAddrSpaceCast(NewCE, DestTy);
+    }
+
+    return nullptr;
+  }
   case Instruction::BitCast:
     return FoldBitCast(C, DestTy, DL);
   }
 }
 
 Constant *llvm::ConstantFoldLoadThroughGEPConstantExpr(Constant *C,
                                                        ConstantExpr *CE) {
   if (!CE->getOperand(1)->isNullValue())

test/Transforms/InstCombine/addrspacecast.ll

loop.body:
   %i.inc = add i32 %i, 1
   %cmp = icmp ne i32 %i, 48
   br i1 %cmp, label %loop.body, label %end
 
 end:
   ret i32 %sum.inc
 }
 
+; CHECK-LABEL: @constant_fold_null(
+; CHECK: addrspacecast i32 addrspace(3)* null to i32 addrspace(4)*
+define void @constant_fold_null() #0 {
+  %cast = addrspacecast i32 addrspace(3)* null to i32 addrspace(4)*
+  store i32 7, i32 addrspace(4)* %cast
+  ret void
+}
+
+; CHECK-LABEL: @constant_fold_undef(
+; CHECK: ret i32 addrspace(4)* undef
+define i32 addrspace(4)* @constant_fold_undef() #0 {
+  %cast = addrspacecast i32 addrspace(3)* undef to i32 addrspace(4)*
+  ret i32 addrspace(4)* %cast
+}
+
+; CHECK-LABEL: @constant_fold_null_vector(
+ ; CHECK: addrspacecast <4 x i32 addrspace(3)*> zeroinitializer to <4 x i32 addrspace(4)*>
+define <4 x i32 addrspace(4)*> @constant_fold_null_vector() #0 {
+  %cast = addrspacecast <4 x i32 addrspace(3)*> zeroinitializer to <4 x i32 addrspace(4)*>
+  ret <4 x i32 addrspace(4)*> %cast
+}
+
+; CHECK-LABEL: @constant_fold_inttoptr(
+; CHECK: addrspacecast i32 addrspace(3)* inttoptr (i32 -1 to i32 addrspace(3)*) to i32 addrspace(4)*
+define void @constant_fold_inttoptr() #0 {
+  %cast = addrspacecast i32 addrspace(3)* inttoptr (i32 -1 to i32 addrspace(3)*) to i32 addrspace(4)*
+  store i32 7, i32 addrspace(4)* %cast
+  ret void
+}
+
+; CHECK-LABEL: @constant_fold_gep_inttoptr(
+; CHECK: addrspacecast i32 addrspace(3)* inttoptr (i64 1274 to i32 addrspace(3)*) to i32 addrspace(4)*
+define void @constant_fold_gep_inttoptr() #0 {
+  %k = inttoptr i32 1234 to i32 addrspace(3)*
+  %gep = getelementptr i32, i32 addrspace(3)* %k, i32 10
+  %cast = addrspacecast i32 addrspace(3)* %gep to i32 addrspace(4)*
+  store i32 7, i32 addrspace(4)* %cast
+  ret void
+}