PNaCl: Fix ExpandCtors to handle an empty list case

While writing a test, I noticed that ExpandCtors crashes if given the
empty list "[]", because this gets converted into an UndefValue
ConstantExpr by the LLVM assembly reader.

Fix this by checking the array's size via its type.  This replaces the
isNullValue() check.

Make error handling cleaner by splitting out a separate function.

BUG=none
TEST=test/Transforms/NaCl/expand-ctors-emptylist.ll

Review URL: https://codereview.chromium.org/15659005

Author: Mark Seaborn

lib/Transforms/NaCl/ExpandCtors.cpp

@@ -73,31 +73,47 @@ static bool compareEntries(FuncArrayEntry Entry1, FuncArrayEntry Entry2) {
   return Entry1.priority < Entry2.priority;
 }
 
+static void readFuncList(GlobalVariable *Array, std::vector<Constant*> *Funcs) {
+  if (!Array->hasInitializer())
+    return;
+  Constant *Init = Array->getInitializer();
+  ArrayType *Ty = dyn_cast<ArrayType>(Init->getType());
+  if (!Ty) {
+    errs() << "Initializer: " << *Array->getInitializer() << "\n";
+    report_fatal_error("ExpandCtors: Initializer is not of array type");
+  }
+  if (Ty->getNumElements() == 0)
+    return;
+  ConstantArray *InitList = dyn_cast<ConstantArray>(Init);
+  if (!InitList) {
+    errs() << "Initializer: " << *Array->getInitializer() << "\n";
+    report_fatal_error("ExpandCtors: Unexpected initializer ConstantExpr");
+  }
+  std::vector<FuncArrayEntry> FuncsToSort;
+  for (unsigned Index = 0; Index < InitList->getNumOperands(); ++Index) {
+    ConstantStruct *CS = cast<ConstantStruct>(InitList->getOperand(Index));
+    FuncArrayEntry Entry;
+    Entry.priority = cast<ConstantInt>(CS->getOperand(0))->getZExtValue();
+    Entry.func = CS->getOperand(1);
+    FuncsToSort.push_back(Entry);
+  }
+
+  std::sort(FuncsToSort.begin(), FuncsToSort.end(), compareEntries);
+  for (std::vector<FuncArrayEntry>::iterator Iter = FuncsToSort.begin();
+       Iter != FuncsToSort.end();
+       ++Iter) {
+    Funcs->push_back(Iter->func);
+  }
+}
+
 static void defineFuncArray(Module &M, const char *LlvmArrayName,
                             const char *StartSymbol,
                             const char *EndSymbol) {
   std::vector<Constant*> Funcs;
 
   GlobalVariable *Array = M.getNamedGlobal(LlvmArrayName);
   if (Array) {
-    if (Array->hasInitializer() && !Array->getInitializer()->isNullValue()) {
-      ConstantArray *InitList = cast<ConstantArray>(Array->getInitializer());
-      std::vector<FuncArrayEntry> FuncsToSort;
-      for (unsigned Index = 0; Index < InitList->getNumOperands(); ++Index) {
-        ConstantStruct *CS = cast<ConstantStruct>(InitList->getOperand(Index));
-        FuncArrayEntry Entry;
-        Entry.priority = cast<ConstantInt>(CS->getOperand(0))->getZExtValue();
-        Entry.func = CS->getOperand(1);
-        FuncsToSort.push_back(Entry);
-      }
-
-      std::sort(FuncsToSort.begin(), FuncsToSort.end(), compareEntries);
-      for (std::vector<FuncArrayEntry>::iterator Iter = FuncsToSort.begin();
-           Iter != FuncsToSort.end();
-           ++Iter) {
-        Funcs.push_back(Iter->func);
-      }
-    }
+    readFuncList(Array, &Funcs);
     // No code should be referencing global_ctors/global_dtors,
     // because this symbol is internal to LLVM.
     Array->eraseFromParent();

test/Transforms/NaCl/expand-ctors-emptylist.ll

@@ -0,0 +1,13 @@
+; RUN: opt %s -nacl-expand-ctors -S | FileCheck %s -check-prefix=NO_CTORS
+; NO_CTORS-NOT: __init_array_end
+; NO_CTORS-NOT: __fini_array_end
+; NO_CTORS-NOT: llvm.global_ctors
+
+; RUN: opt %s -nacl-expand-ctors -S | FileCheck %s
+
+; Check that the pass works when the initializer is "[]", which gets
+; converted into "undef" by the reader.
+@llvm.global_ctors = appending global [0 x { i32, void ()* }] []
+
+; CHECK: @__init_array_start = internal constant [0 x void ()*] zeroinitializer
+; CHECK: @__fini_array_start = internal constant [0 x void ()*] zeroinitializer