[CodeGen] Use the zero initializer instead of storing an all zero representation.

[mattd]

Summary

This change avoids the overhead of storing, and later crawling,
an initializer list of all zeros for arrays. When LLVM
visits this (llvm/IR/Constants.cpp) ConstantArray::getImpl()
it will scan the list looking for an array of all zero.

We can avoid the store, and short-cut the scan, by detecting
all zeros when clang builds-up the initialization representation.

This was brought to my attention when investigating PR36030

[mattd]

Ping :)

[rjmccall]

I'm somewhat surprised LLVM doesn't already canonicalize this, but ok.

Should we also do this when building a constant struct?

lib/CodeGen/CGExprConstant.cpp

873

Please short-circuit this if AllNullValues is already false.

[mattd]

Thanks for the look @rjmccall . I tossed in the shortcut as you suggested. I also had to fix the instruction numbering in the test case.

[rjmccall]

Oh. It's not a good idea to try to match exact local IR names like this for two reasons:

• First, many IR names are different in builds with and without assertions.
• Second, it's pretty susceptible to innocuous changes in output.

You should use FileCheck patterns ([[TEMP:%.*]] = bitcast [10 x i32]* ... to define the variable, [[TEMP]] to refer to it) instead.

Also, you really have 15 different tests here. Please split them up into different functions (in the same test file) with at least vaguely meaningful names (like testStaticNonZero or testVolatileAllZeros). And please match their definition lines with CHECK-LABEL instead of a simple CHECK; this allows FileCheck to do a better job reporting multiple failures in a single file.

Finally, I'm not sure why you've included the b, c, and d tests at all, since they have nothing to do with your patch. c4 and d4 don't even involve initialization code.

[mattd]

Thanks for the test tips. I realize the original was a bit carried away, my apologies for that. This updated test visits the same code path that we're trying to test, and is much more concise.

[rjmccall]

No worries. LGTM!

lib/CodeGen/CGExprConstant.cpp

if (!fillC)
       return nullptr;
 
     // Try to use a ConstantAggregateZero if we can.
     if (fillC->isNullValue() && !NumInitableElts)
       return llvm::ConstantAggregateZero::get(AType);
 
     // Copy initializer elements.
     SmallVector<llvm::Constant*, 16> Elts;
-    Elts.reserve(NumInitableElts + NumElements);
+    Elts.reserve(std::max(NumInitableElts, NumElements));
 
     bool RewriteType = false;
+    bool AllNullValues = true;
     for (unsigned i = 0; i < NumInitableElts; ++i) {
       Expr *Init = ILE->getInit(i);
       llvm::Constant *C = Emitter.tryEmitPrivateForMemory(Init, EltType);
       if (!C)
         return nullptr;
       RewriteType |= (C->getType() != ElemTy);
       Elts.push_back(C);
+      if (AllNullValues && !C->isNullValue())
+        AllNullValues = false;
     }
 
+    // If all initializer elements are "zero," then avoid storing NumElements
+    // instances of the zero representation.
+    if (AllNullValues)
+      return llvm::ConstantAggregateZero::get(AType);
+
     RewriteType |= (fillC->getType() != ElemTy);
     Elts.resize(NumElements, fillC);
 
     if (RewriteType) {
       // FIXME: Try to avoid packing the array
       std::vector<llvm::Type*> Types;
-      Types.reserve(NumInitableElts + NumElements);
+      Types.reserve(Elts.size());
       for (unsigned i = 0, e = Elts.size(); i < e; ++i)
         Types.push_back(Elts[i]->getType());
       llvm::StructType *SType = llvm::StructType::get(AType->getContext(),
                                                             Types, true);
       return llvm::ConstantStruct::get(SType, Elts);
     }
 
     return llvm::ConstantArray::get(AType, Elts);

test/CodeGen/array-init.c

+// RUN: %clang_cc1 %s -O0 -triple x86_64-unknown-linux-gnu -emit-llvm -o - | FileCheck %s
+
+// CHECK: @{{.*}}.a1 = internal constant [5 x i32] [i32 0, i32 1, i32 2, i32 0, i32 0]
+// CHECK: @{{.*}}.a2 = internal constant [5 x i32] zeroinitializer
+// CHECK: @{{.*}}.a3 = internal constant [5 x i32] zeroinitializer
+
+void testConstArrayInits(void)
+{
+  const int a1[5] = {0,1,2};
+  const int a2[5] = {0,0,0};
+  const int a3[5] = {0};
+}