PNaCl: Fix ExpandCtors to handle an empty list case

lib/Transforms/NaCl/ExpandCtors.cpp

 //===- ExpandCtors.cpp - Convert ctors/dtors to concrete arrays -----------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This pass converts LLVM's special symbols llvm.global_ctors and
@@ skipping 55 matching lines @@
 
 struct FuncArrayEntry {
   uint64_t priority;
   Constant *func;
 };
 
 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();
   }
 
   Type *FuncTy = FunctionType::get(Type::getVoidTy(M.getContext()), false);
   Type *FuncPtrTy = FuncTy->getPointerTo();
   ArrayType *ArrayTy = ArrayType::get(FuncPtrTy, Funcs.size());
   GlobalVariable *NewArray =
       new GlobalVariable(M, ArrayTy, /* isConstant= */ true,
@@ skipping 25 matching lines @@
   defineFuncArray(M, "llvm.global_ctors",
                   "__init_array_start", "__init_array_end");
   defineFuncArray(M, "llvm.global_dtors",
                   "__fini_array_start", "__fini_array_end");
   return true;
 }
 
 ModulePass *llvm::createExpandCtorsPass() {
   return new ExpandCtors();
 }