Check that TD isn't NULL before dereferencing it down this path.

[oota-llvm.git] / lib / Transforms / IPO / GlobalOpt.cpp

diff --git a/lib/Transforms/IPO/GlobalOpt.cpp b/lib/Transforms/IPO/GlobalOpt.cpp
index a4de71b3ae66ea7ed4b48b8a5062ba9e98d6c6fc..20af15ed0087119c37d0541b99bde1b8f7ba63d5 100644 (file)
--- a/lib/Transforms/IPO/GlobalOpt.cpp
+++ b/lib/Transforms/IPO/GlobalOpt.cpp
@@ -1940,9 +1940,8 @@ bool GlobalOpt::ProcessInternalGlobal(GlobalVariable *GV,
                                 const SmallPtrSet<const PHINode*, 16> &PHIUsers,
                                       const GlobalStatus &GS) {
   // If this is a first class global and has only one accessing function
-  // and this function is main (which we know is not recursive we can make
-  // this global a local variable) we replace the global with a local alloca
-  // in this function.
+  // and this function is main (which we know is not recursive), we replace
+  // the global with a local alloca in this function.
   //
   // NOTE: It doesn't make sense to promote non single-value types since we
   // are just replacing static memory to stack memory.
@@ -2784,7 +2783,7 @@ bool Evaluator::EvaluateBlock(BasicBlock::iterator CurInst,
           Value *Ptr = PtrArg->stripPointerCasts();
           if (GlobalVariable *GV = dyn_cast<GlobalVariable>(Ptr)) {
             Type *ElemTy = cast<PointerType>(GV->getType())->getElementType();
-            if (!Size->isAllOnesValue() &&
+            if (TD && !Size->isAllOnesValue() &&
                 Size->getValue().getLimitedValue() >=
                 TD->getTypeStoreSize(ElemTy)) {
               Invariants.insert(GV);
@@ -3041,10 +3040,10 @@ bool GlobalOpt::OptimizeGlobalCtorsList(GlobalVariable *&GCL) {
   return true;
 }
 
-/// \brief Given "llvm.used" or "llvm.compiler_used" as a global name, collect
+/// \brief Given "llvm.used" or "llvm.compiler.used" as a global name, collect
 /// the initializer elements of that global in Set and return the global itself.
 static GlobalVariable *
-collectUsedGlobalVariables(const Module &M, const char *Name,
+collectUsedGlobalVariables(Module &M, const char *Name,
                            SmallPtrSet<GlobalValue *, 8> &Set) {
   GlobalVariable *GV = M.getGlobalVariable(Name);
   if (!GV || !GV->hasInitializer())
@@ -3071,6 +3070,11 @@ static int compareNames(const void *A, const void *B) {
 
 static void setUsedInitializer(GlobalVariable &V,
                                SmallPtrSet<GlobalValue *, 8> Init) {
+  if (Init.empty()) {
+    V.eraseFromParent();
+    return;
+  }
+
   SmallVector<llvm::Constant *, 8> UsedArray;
   PointerType *Int8PtrTy = Type::getInt8PtrTy(V.getContext());
 
@@ -3094,7 +3098,7 @@ static void setUsedInitializer(GlobalVariable &V,
 }
 
 namespace {
-/// \brief An easy to access representation of llvm.used and llvm.compiler_used.
+/// \brief An easy to access representation of llvm.used and llvm.compiler.used.
 class LLVMUsed {
   SmallPtrSet<GlobalValue *, 8> Used;
   SmallPtrSet<GlobalValue *, 8> CompilerUsed;
@@ -3102,10 +3106,10 @@ class LLVMUsed {
   GlobalVariable *CompilerUsedV;
 
 public:
-  LLVMUsed(const Module &M) {
+  LLVMUsed(Module &M) {
     UsedV = collectUsedGlobalVariables(M, "llvm.used", Used);
     CompilerUsedV =
-        collectUsedGlobalVariables(M, "llvm.compiler_used", CompilerUsed);
+        collectUsedGlobalVariables(M, "llvm.compiler.used", CompilerUsed);
   }
   typedef SmallPtrSet<GlobalValue *, 8>::iterator iterator;
   iterator usedBegin() { return Used.begin(); }
@@ -3136,13 +3140,13 @@ static bool hasUseOtherThanLLVMUsed(GlobalAlias &GA, const LLVMUsed &U) {
 
   assert((!U.usedCount(&GA) || !U.compilerUsedCount(&GA)) &&
          "We should have removed the duplicated "
-         "element from llvm.compiler_used");
+         "element from llvm.compiler.used");
   if (!GA.hasOneUse())
     // Strictly more than one use. So at least one is not in llvm.used and
-    // llvm.compiler_used.
+    // llvm.compiler.used.
     return true;
 
-  // Exactly one use. Check if it is in llvm.used or llvm.compiler_used.
+  // Exactly one use. Check if it is in llvm.used or llvm.compiler.used.
   return !U.usedCount(&GA) && !U.compilerUsedCount(&GA);
 }
 
@@ -3151,7 +3155,7 @@ static bool hasMoreThanOneUseOtherThanLLVMUsed(GlobalValue &V,
   unsigned N = 2;
   assert((!U.usedCount(&V) || !U.compilerUsedCount(&V)) &&
          "We should have removed the duplicated "
-         "element from llvm.compiler_used");
+         "element from llvm.compiler.used");
   if (U.usedCount(&V) || U.compilerUsedCount(&V))
     ++N;
   return V.hasNUsesOrMore(N);