[GlobalOpt] Globals used only in "main" can more easily be localized

[vaivaswatha]

Summary

This change relaxes the condition for a global, that is only used in "main", to be localized. This relaxation partially undoes the change done in http://reviews.llvm.org/rL253168.

This is required because the condition that was added earlier, that a store to the global needs to dominate all other references to it in the function is not necessary if the only function that accesses the global is "main". So, similar to the condition prior to the above mentioned change, this change allows "main" as an exception.

[jmolloy]

Hi,

No, this is not correct. The behaviour was very deliberately changed in r253168. main() is not guaranteed to be non-recursive in C, D, Python, Ruby, Rust or any other language. The only language I know that gives that guarantee is C++, and there was a corresponding change in Clang to mark "main" as norecurse in C++ mode.

Yes, I'm aware this can pessimize some C programs (notably a popular embedded benchmark). However correctness must trump performance when there is no alternative!

James

lib/Transforms/IPO/GlobalOpt.cpp

bool GlobalOpt::processInternalGlobal(GlobalVariable *GV,
   //
   // If the global is in different address space, don't bring it to stack.
   if (!GS.HasMultipleAccessingFunctions &&
       GS.AccessingFunction &&
       GV->getType()->getElementType()->isSingleValueType() &&
       GV->getType()->getAddressSpace() == 0 &&
       !GV->isExternallyInitialized() &&
       allNonInstructionUsersCanBeMadeInstructions(GV) &&
-      GS.AccessingFunction->doesNotRecurse() &&
-      isPointerValueDeadOnEntryToFunction(GS.AccessingFunction, GV) ) {
+      ((GS.AccessingFunction->doesNotRecurse() &&
+        isPointerValueDeadOnEntryToFunction(GS.AccessingFunction, GV)) ||
+       (GS.AccessingFunction->getName() == "main"))) {
     DEBUG(dbgs() << "LOCALIZING GLOBAL: " << *GV << "\n");
     Instruction &FirstI = const_cast<Instruction&>(*GS.AccessingFunction
                                                    ->getEntryBlock().begin());
     Type *ElemTy = GV->getType()->getElementType();
     // FIXME: Pass Global's alignment when globals have alignment
     AllocaInst *Alloca = new AllocaInst(ElemTy, nullptr,
                                         GV->getName(), &FirstI);
     if (!isa<UndefValue>(GV->getInitializer()))

test/Transforms/GlobalOpt/load-store-global.ll

define void @qux() nounwind {
   store i64* inttoptr (i64 1 to i64*), i64** @a, align 8
   %l = load i64*, i64** @a, align 8
   ret void
 ; CHECK-LABEL: @qux(
 ; CHECK-NOT: store
 ; CHECK-NOT: load
 }
 
+; A global used only in "main" can always be localized.
+@b = internal global i64 13, align 8
+; CHECK-NOT: @b
+
+define i64 @main(i32 %argc, i8** %argv) norecurse {
+; CHECK: %b = alloca
+; CHECK store i64 13
+  %a = load i64, i64* @b
+; CHECK %a = load i64
+  store i64 27, i64* @b
+; CHECK store i64 27
+  ret i64 %a
+}