Fix bitcast to gep constant folding transform.

[deadalnix]

Summary

It is checking is the destination type is sized, when the source type is the one that shoul dbe checked. It cause assertion failure down the road is the source type is unsized but destination type is.

[majnemer]

Can you please provide a test-case to ensure we won't regress?

[deadalnix]

Add test

[majnemer]

LGTM

unittests/IR/ConstantsTest.cpp

387–398 ↗

(On Diff #42004)

This test doesn't seem related to the change in question. It worked before your change.

400–408 ↗

(On Diff #42004)

I'd move this test to test/Assembler/ConstantExprFoldCast.ll

The IR translation of this test would be something like:

%Unsized = type opaque
%S2 = type { i32, %Unsized }
@G2 = external global %S2
@G3 = global i32* bitcast (%S2* @G2 to i32*)

[deadalnix]

unittests/IR/ConstantsTest.cpp

387–398 ↗

(On Diff #42004)

It doesn't looks like it is well tested.

400–408 ↗

(On Diff #42004)

The file check that there is no cast. I can put the first part of the test in there, but it doesn't looks like it is adequate for checking that this doesn't assert fail.

[deadalnix]

Move the GEP test in test/Assembler/ConstantExprFoldCast.ll
The regression test cannot be moved there.

[deadalnix]

Fix rebase conflict and ping.

llvm/trunk/lib/IR/ConstantFold.cpp

static Constant *FoldBitCast(Constant *V, Type *DestTy) {
   if (SrcTy == DestTy)
     return V; // no-op cast
 
   // Check to see if we are casting a pointer to an aggregate to a pointer to
   // the first element.  If so, return the appropriate GEP instruction.
   if (PointerType *PTy = dyn_cast<PointerType>(V->getType()))
     if (PointerType *DPTy = dyn_cast<PointerType>(DestTy))
       if (PTy->getAddressSpace() == DPTy->getAddressSpace()
-          && DPTy->getElementType()->isSized()) {
+          && PTy->getElementType()->isSized()) {
         SmallVector<Value*, 8> IdxList;
         Value *Zero =
           Constant::getNullValue(Type::getInt32Ty(DPTy->getContext()));
         IdxList.push_back(Zero);
         Type *ElTy = PTy->getElementType();
         while (ElTy != DPTy->getElementType()) {
           if (StructType *STy = dyn_cast<StructType>(ElTy)) {
             if (STy->getNumElements() == 0) break;

llvm/trunk/test/Assembler/ConstantExprFoldCast.ll

 @E = global i32 ptrtoint(float* inttoptr (i8 5 to float*) to i32)  ; i32 -> ptr -> i32
 
 ; Test folding of binary instrs
 @F = global i32* inttoptr (i32 add (i32 5, i32 -5) to i32*)
 @G = global i32* inttoptr (i32 sub (i32 5, i32 5) to i32*)
 
 ; Address space cast AS0 null-> AS1 null
 @H = global i32 addrspace(1)* addrspacecast(i32* null to i32 addrspace(1)*)
+
+; Bitcast -> GEP
+@I = external global { i32 }
+@J = global i32* bitcast ({ i32 }* @I to i32*)

llvm/trunk/unittests/IR/ConstantsTest.cpp

for (Type *T : {Type::getHalfTy(Context), Type::getFloatTy(Context),
                   Type::getDoubleTy(Context)}) {
     Constant *Vals[] = {ConstantFP::get(T, 0), ConstantFP::get(T, 1)};
     Constant *CDV = ConstantVector::get(Vals);
     ASSERT_TRUE(dyn_cast<ConstantDataVector>(CDV) != nullptr)
         << " T = " << getNameOfType(T);
   }
 }
 
+TEST(ConstantsTest, BitcastToGEP) {
+  LLVMContext Context;
+  std::unique_ptr<Module> M(new Module("MyModule", Context));
+
+  auto *i32 = Type::getInt32Ty(Context);
+  auto *U = StructType::create(Context, "Unsized");
+  Type *EltTys[] = {i32, U};
+  auto *S = StructType::create(EltTys);
+
+  auto *G = new GlobalVariable(*M, S, false,
+                               GlobalValue::ExternalLinkage, nullptr);
+  auto *PtrTy = PointerType::get(i32, 0);
+  auto *C = ConstantExpr::getBitCast(G, PtrTy);
+  ASSERT_EQ(dyn_cast<ConstantExpr>(C)->getOpcode(),
+            Instruction::BitCast);
+}
+
 }  // end anonymous namespace
 }  // end namespace llvm