Arrays are permitted to be zero-length in some situations.

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@135036 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/lib/CodeGen/CGClass.cpp b/lib/CodeGen/CGClass.cpp
index 47d4fcbae304e7e93b1c5d91918e0f492359129b..7dbaaf85299f14a0122fdd89b89a22c0c9d5b509 100644 (file)
--- a/lib/CodeGen/CGClass.cpp
+++ b/lib/CodeGen/CGClass.cpp
@@ -1063,7 +1063,7 @@ CodeGenFunction::EmitCXXAggrConstructorCall(const CXXConstructorDecl *ctor,
 ///
 /// \param ctor the constructor to call for each element
 /// \param numElements the number of elements in the array;
-///   assumed to be non-zero
+///   may be zero
 /// \param argBegin,argEnd the arguments to evaluate and pass to the
 ///   constructor
 /// \param arrayBegin a T*, where T is the type constructed by ctor
@@ -1076,6 +1076,29 @@ CodeGenFunction::EmitCXXAggrConstructorCall(const CXXConstructorDecl *ctor,
                                          CallExpr::const_arg_iterator argBegin,
                                            CallExpr::const_arg_iterator argEnd,
                                             bool zeroInitialize) {
+
+  // It's legal for numElements to be zero.  This can happen both
+  // dynamically, because x can be zero in 'new A[x]', and statically,
+  // because of GCC extensions that permit zero-length arrays.  There
+  // are probably legitimate places where we could assume that this
+  // doesn't happen, but it's not clear that it's worth it.
+  llvm::BranchInst *zeroCheckBranch = 0;
+
+  // Optimize for a constant count.
+  llvm::ConstantInt *constantCount
+    = dyn_cast<llvm::ConstantInt>(numElements);
+  if (constantCount) {
+    // Just skip out if the constant count is zero.
+    if (constantCount->isZero()) return;
+
+  // Otherwise, emit the check.
+  } else {
+    llvm::BasicBlock *loopBB = createBasicBlock("new.ctorloop");
+    llvm::Value *iszero = Builder.CreateIsNull(numElements, "isempty");
+    zeroCheckBranch = Builder.CreateCondBr(iszero, loopBB, loopBB);
+    EmitBlock(loopBB);
+  }
+      
   // Find the end of the array.
   llvm::Value *arrayEnd = Builder.CreateInBoundsGEP(arrayBegin, numElements,
                                                     "arrayctor.end");
@@ -1130,6 +1153,9 @@ CodeGenFunction::EmitCXXAggrConstructorCall(const CXXConstructorDecl *ctor,
   llvm::BasicBlock *contBB = createBasicBlock("arrayctor.cont");
   Builder.CreateCondBr(done, contBB, loopBB);
 
+  // Patch the earlier check to skip over the loop.
+  if (zeroCheckBranch) zeroCheckBranch->setSuccessor(0, contBB);
+
   EmitBlock(contBB);
 }
 

diff --git a/lib/CodeGen/CGExprCXX.cpp b/lib/CodeGen/CGExprCXX.cpp
index 49aab66268c01112c446e64d124e2da5c41b14eb..e3c6a8f978997af72aaac6bf55b82593bd2000a0 100644 (file)
--- a/lib/CodeGen/CGExprCXX.cpp
+++ b/lib/CodeGen/CGExprCXX.cpp
@@ -798,36 +798,10 @@ static void EmitNewInitializer(CodeGenFunction &CGF, const CXXNewExpr *E,
         RequiresZeroInitialization = true;
       }
 
-      // It's legal for NumElements to be zero, but
-      // EmitCXXAggrConstructorCall doesn't handle that, so we need to.
-      llvm::BranchInst *br = 0;
-
-      // Optimize for a constant count.
-      llvm::ConstantInt *constantCount
-        = dyn_cast<llvm::ConstantInt>(NumElements);
-      if (constantCount) {
-        // Just skip out if the constant count is zero.
-        if (constantCount->isZero()) return;
-
-      // Otherwise, emit the check.
-      } else {
-        llvm::BasicBlock *loopBB = CGF.createBasicBlock("new.ctorloop");
-        llvm::Value *iszero = CGF.Builder.CreateIsNull(NumElements, "isempty");
-        br = CGF.Builder.CreateCondBr(iszero, loopBB, loopBB);
-        CGF.EmitBlock(loopBB);
-      }
-      
       CGF.EmitCXXAggrConstructorCall(Ctor, NumElements, NewPtr, 
                                      E->constructor_arg_begin(), 
                                      E->constructor_arg_end(),
                                      RequiresZeroInitialization);
-
-      // Patch the earlier check to skip over the loop.
-      if (br) {
-        assert(CGF.Builder.GetInsertBlock()->empty());
-        br->setSuccessor(0, CGF.Builder.GetInsertBlock());
-      }
-
       return;
     } else if (E->getNumConstructorArgs() == 1 &&
                isa<ImplicitValueInitExpr>(E->getConstructorArg(0))) {

diff --git a/test/CodeGenCXX/constructors.cpp b/test/CodeGenCXX/constructors.cpp
index 9e09099ba485203b2020bd9b8a822d6ab7d98d3e..ec7f06c868a9896a9c4cbddd11a4b744abb456cc 100644 (file)
--- a/test/CodeGenCXX/constructors.cpp
+++ b/test/CodeGenCXX/constructors.cpp
@@ -104,3 +104,14 @@ namespace test0 {
     C tmp = in;
   }
 }
+
+namespace test1 {
+  struct A { A(); void *ptr; };
+  struct B { B(); int x; A a[0]; };
+  B::B() {}
+  // CHECK:    define void @_ZN5test11BC2Ev(
+  // CHECK:      [[THIS:%.*]] = load [[B:%.*]]**
+  // CHECK-NEXT: [[A:%.*]] = getelementptr inbounds [[B:%.*]]* [[THIS]], i32 0, i32 1
+  // CHECK-NEXT: [[BEGIN:%.*]] = getelementptr inbounds [0 x {{%.*}}]* [[A]], i32 0, i32 0
+  // CHECK-NEXT: ret void
+}