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

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

400–408

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

It doesn't looks like it is well tested.

400–408

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.

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;

unittests/IR/ConstantsTest.cpp

TEST(ConstantsTest, AliasCAPI) {
   Type *I16Ty = Type::getInt16Ty(Context);
   Type *I16PTy = PointerType::get(I16Ty, 0);
   Constant *Aliasee = ConstantExpr::getBitCast(G, I16PTy);
   LLVMValueRef AliasRef =
       LLVMAddAlias(wrap(M.get()), wrap(I16PTy), wrap(Aliasee), "a");
   ASSERT_EQ(unwrap<GlobalAlias>(AliasRef)->getAliasee(), Aliasee);
 }
 
+TEST(ConstantsTest, BitcastToGEP) {
+  LLVMContext Context;
+  std::unique_ptr<Module> M(new Module("MyModule", Context));
+
+  auto *i32 = Type::getInt32Ty(Context);
+  Type *S1Elts[] = {i32, i32};
+  auto *S1 = StructType::create(S1Elts);
+
+  auto *G1 = new GlobalVariable(*M, S1, false,
+                                GlobalValue::ExternalLinkage, nullptr);
+  auto *PtrTy = PointerType::get(i32, 0);
+  auto *C1 = ConstantExpr::getBitCast(G1, PtrTy);
+  ASSERT_EQ(dyn_cast<ConstantExpr>(C1)->getOpcode(),
+            Instruction::GetElementPtr);
+
+  auto *U = StructType::create(Context, "Unsized");
+  Type *S2Elts[] = {i32, U};
+  auto *S2 = StructType::create(S2Elts);
+
+  auto *G2 = new GlobalVariable(*M, S2, false,
+                                GlobalValue::ExternalLinkage, nullptr);
+  auto *C2 = ConstantExpr::getBitCast(G2, PtrTy);
+  ASSERT_EQ(dyn_cast<ConstantExpr>(C2)->getOpcode(),
+            Instruction::BitCast);
+}
+
 }  // end anonymous namespace
 }  // end namespace llvm