[GlobalOpt] Simplify CleanupConstantGlobalUsers()

[nikic]

Summary

This bases the CleanupConstantGlobalUsers() implementation around the ConstantFoldLoadFromConst() API. The general approach is that we discover all users while looking through casts, and then constant fold loads and drop stores and memintrinsics.

This avoids special cases and limitations in the previous implementation, which is also incompatible with opaque pointers. The result is a bit more powerful than before, because we now use more general load folding logic which can for example look through pointer bitcasts between different sizes. This is where the test changes come from, as we now fold more loads and can thus remove more globals.

[aeubanks]

llvm/lib/Transforms/IPO/GlobalOpt.cpp

307

is this true for non-inbounds GEPs?

334

even though Changed should be true if this returns true, still seems good to Changed |= ... here to prevent potential future issues

[nikic]

Updated Changed with RecursivelyDeleteTriviallyDeadInstructions() call.

[nikic]

llvm/lib/Transforms/IPO/GlobalOpt.cpp

307

Yes, because the result is either zero or the load is UB. This is similar to the logic in https://github.com/llvm/llvm-project/blob/b1bc627e7e9965e6ec15e106ee4b2c21f6c36923/llvm/lib/Analysis/ConstantFolding.cpp#L704.

[aeubanks]

llvm/lib/Transforms/IPO/GlobalOpt.cpp

307

ah the langref clears that up, thanks

[uabelho]

It looks like the issue described in
https://bugs.llvm.org/show_bug.cgi?id=39751
stopped happening with this patch.

[nikic]

In D114889#3166119, @uabelho wrote:

It looks like the issue described in
https://bugs.llvm.org/show_bug.cgi?id=39751
stopped happening with this patch.

Thanks for the pointer. I committed the test case in https://github.com/llvm/llvm-project/commit/bc61e5e90b8db92aa5464d0565c8993b776df54d -- just need to remember that the issue can be closed once that's possible again :)

[uabelho]

In D114889#3166181, @nikic wrote:

In D114889#3166119, @uabelho wrote:

It looks like the issue described in
https://bugs.llvm.org/show_bug.cgi?id=39751
stopped happening with this patch.

Thanks for the pointer. I committed the test case in https://github.com/llvm/llvm-project/commit/bc61e5e90b8db92aa5464d0565c8993b776df54d -- just need to remember that the issue can be closed once that's possible again :)

Great, thanks!
Yes it's starting to pile up now. I have a list of things to do once it opens up somewhere, I can add PR39751 to my list and close it too.

[uabelho]

Btw, I've seen a crash starting to happen with this patch:

opt -S -o /dev/null -globalopt globalopt.ll

results in

opt: ../include/llvm/Support/Casting.h:262: typename cast_retty<X, Y>::ret_type llvm::cast(Y &) [X = llvm::Instruction, Y = llvm::WeakTrackingVH]: Assertion `isa<X>(Val) && "cast<Ty>() argument of incompatible type!"' failed.
PLEASE submit a bug report to https://bugs.llvm.org/ and include the crash backtrace.
Stack dump:
0.	Program arguments: build-all/bin/opt -S -o /dev/null -globalopt globalopt.ll
 #0 0x0000000002c0c193 llvm::sys::PrintStackTrace(llvm::raw_ostream&, int) (build-all/bin/opt+0x2c0c193)
 #1 0x0000000002c09e0e llvm::sys::RunSignalHandlers() (build-all/bin/opt+0x2c09e0e)
 #2 0x0000000002c0c516 SignalHandler(int) Signals.cpp:0:0
 #3 0x00007fcf42228630 __restore_rt sigaction.c:0:0
 #4 0x00007fcf3f95b387 raise (/lib64/libc.so.6+0x36387)
 #5 0x00007fcf3f95ca78 abort (/lib64/libc.so.6+0x37a78)
 #6 0x00007fcf3f9541a6 __assert_fail_base (/lib64/libc.so.6+0x2f1a6)
 #7 0x00007fcf3f954252 (/lib64/libc.so.6+0x2f252)
 #8 0x0000000002c9db46 llvm::RecursivelyDeleteTriviallyDeadInstructionsPermissive(llvm::SmallVectorImpl<llvm::WeakTrackingVH>&, llvm::TargetLibraryInfo const*, llvm::MemorySSAUpdater*, std::function<void (llvm::Value*)>) (build-all/bin/opt+0x2c9db46)
 #9 0x00000000024dedb3 CleanupConstantGlobalUsers(llvm::GlobalVariable*, llvm::DataLayout const&) GlobalOpt.cpp:0:0
#10 0x00000000024d98f1 processInternalGlobal(llvm::GlobalVariable*, llvm::GlobalStatus const&, llvm::function_ref<llvm::TargetTransformInfo& (llvm::Function&)>, llvm::function_ref<llvm::TargetLibraryInfo& (llvm::Function&)>, llvm::function_ref<llvm::DominatorTree& (llvm::Function&)>) GlobalOpt.cpp:0:0
#11 0x00000000024d9257 processGlobal(llvm::GlobalValue&, llvm::function_ref<llvm::TargetTransformInfo& (llvm::Function&)>, llvm::function_ref<llvm::TargetLibraryInfo& (llvm::Function&)>, llvm::function_ref<llvm::DominatorTree& (llvm::Function&)>) GlobalOpt.cpp:0:0
#12 0x00000000024d7258 optimizeGlobalsInModule(llvm::Module&, llvm::DataLayout const&, llvm::function_ref<llvm::TargetLibraryInfo& (llvm::Function&)>, llvm::function_ref<llvm::TargetTransformInfo& (llvm::Function&)>, llvm::function_ref<llvm::BlockFrequencyInfo& (llvm::Function&)>, llvm::function_ref<llvm::DominatorTree& (llvm::Function&)>) GlobalOpt.cpp:0:0
#13 0x00000000024d57ee llvm::GlobalOptPass::run(llvm::Module&, llvm::AnalysisManager<llvm::Module>&) (build-all/bin/opt+0x24d57ee)
#14 0x0000000002f0067d llvm::detail::PassModel<llvm::Module, llvm::GlobalOptPass, llvm::PreservedAnalyses, llvm::AnalysisManager<llvm::Module> >::run(llvm::Module&, llvm::AnalysisManager<llvm::Module>&) crtstuff.c:0:0
#15 0x0000000002395088 llvm::PassManager<llvm::Module, llvm::AnalysisManager<llvm::Module> >::run(llvm::Module&, llvm::AnalysisManager<llvm::Module>&) (build-all/bin/opt+0x2395088)
#16 0x000000000078d022 llvm::runPassPipeline(llvm::StringRef, llvm::Module&, llvm::TargetMachine*, llvm::TargetLibraryInfoImpl*, llvm::ToolOutputFile*, llvm::ToolOutputFile*, llvm::ToolOutputFile*, llvm::StringRef, llvm::ArrayRef<llvm::StringRef>, llvm::opt_tool::OutputKind, llvm::opt_tool::VerifierKind, bool, bool, bool, bool, bool) (build-all/bin/opt+0x78d022)
#17 0x000000000079fbad main (build-all/bin/opt+0x79fbad)
#18 0x00007fcf3f947555 __libc_start_main (/lib64/libc.so.6+0x22555)
#19 0x000000000078846c _start (build-all/bin/opt+0x78846c)
Abort

globalopt.ll378 BDownload

[nikic]

@uabelho Thanks for the report, this should be fixed by https://github.com/llvm/llvm-project/commit/a0ff26e08c0cca4917a08c8b8383b8338aa8e73e.

[uabelho]

In D114889#3166434, @nikic wrote:

@uabelho Thanks for the report, this should be fixed by https://github.com/llvm/llvm-project/commit/a0ff26e08c0cca4917a08c8b8383b8338aa8e73e.

Yep, thanks!

[ayrivera]

llvm/lib/Transforms/IPO/GlobalOpt.cpp

309

Hi,

I have a small test case that crashes in this line when it tries to create a null value for a x86_mmx load instruction:

test> opt -S -globalopt simple.ll
Cannot create a null constant of that type!  
UNREACHABLE executed at llvm/llvm/lib/IR/Constants.cpp:384!                                                          
PLEASE submit a bug report to https://bugs.llvm.org/ and include the crash backtrace.                                                               
Stack dump:                                                               
0.      Program arguments: opt -S -globalopt simple.ll                    
 #0 0x00000000038d2aed llvm::sys::PrintStackTrace(llvm::raw_ostream&, int) llvm/lib/Support/Unix/Signals.inc:565:0                                                                        
 #1 0x00000000038d2ba4 PrintStackTraceSignalHandler(void*) llvm/lib/Support/Unix/Signals.inc:632:0              
 #2 0x00000000038d0b69 llvm::sys::RunSignalHandlers() llvm/lib/Support/Signals.cpp:96:0                         
 #3 0x00000000038d2531 SignalHandler(int) llvm/lib/Support/Unix/Signals.inc:407:0                               
 #4 0x00007fbeb4870dd0 __restore_rt sigaction.c:0:0                       
 #5 0x00007fbeb336170f raise (/lib64/libc.so.6+0x3770f)                   
 #6 0x00007fbeb334bb25 abort (/lib64/libc.so.6+0x21b25)                   
 #7 0x000000000381316e bindingsErrorHandler(void*, char const*, bool) llvm/lib/Support/ErrorHandling.cpp:218:0  
 #8 0x0000000002ba65ab llvm::Constant::getNullValue(llvm::Type*) llvm/lib/IR/Constants.cpp:384:0                
 #9 0x0000000002f4c4cd CleanupConstantGlobalUsers(llvm::GlobalVariable*, llvm::DataLayout const&) llvm/lib/Transforms/IPO/GlobalOpt.cpp:309:0                                             
#10 0x0000000002f51b41 processInternalGlobal(llvm::GlobalVariable*, llvm::GlobalStatus const&, llvm::function_ref<llvm::TargetTransformInfo& (llvm::Function&)>, llvm::function_ref<llvm::TargetLibraryInfo& (llvm::Function&)>, llvm::function_ref<llvm::DominatorTree& (llvm::Function&)>) llvm/lib/Transforms/IPO/GlobalOpt.cpp:1556:0     
#11 0x0000000002f520f3 processGlobal(llvm::GlobalValue&, llvm::function_ref<llvm::TargetTransformInfo& (llvm::Function&)>, llvm::function_ref<llvm::TargetLibraryInfo& (llvm::Function&)>, llvm::function_ref<llvm::DominatorTree& (llvm::Function&)>) llvm/lib/Transforms/IPO/GlobalOpt.cpp:1670:0
#12 0x0000000002f53bf7 OptimizeGlobalVars(llvm::Module&, llvm::function_ref<llvm::TargetTransformInfo& (llvm::Function&)>, llvm::function_ref<llvm::TargetLibraryInfo& (llvm::Function&)>, llvm::function_ref<llvm::DominatorTree& (llvm::Function&)>, llvm::SmallPtrSetImpl<llvm::Comdat const*>&) llvm/lib/Transforms/IPO/GlobalOpt.cpp:2065:0
#13 0x0000000002f560e5 optimizeGlobalsInModule(llvm::Module&, llvm::DataLayout const&, llvm::function_ref<llvm::TargetLibraryInfo& (llvm::Function&)>, llvm::function_ref<llvm::TargetTransformInfo& (llvm::Function&)>, llvm::function_ref<llvm::BlockFrequencyInfo& (llvm::Function&)>, llvm::function_ref<llvm::DominatorTree& (llvm::Function&)>) llvm/lib/Transforms/IPO/GlobalOpt.cpp:2639:0
#14 0x0000000002f5632a llvm::GlobalOptPass::run(llvm::Module&, llvm::AnalysisManager<llvm::Module>&) llvm/lib/Transforms/IPO/GlobalOpt.cpp:2678:0
#15 0x0000000003cd2e24 llvm::detail::PassModel<llvm::Module, llvm::GlobalOptPass, llvm::PreservedAnalyses, llvm::AnalysisManager<llvm::Module> >::run(llvm::Module&, llvm::AnalysisManager<llvm::Module>&) llvm/include/llvm/IR/PassManagerInternal.h:89:0
#16 0x0000000002d7811d llvm::PassManager<llvm::Module, llvm::AnalysisManager<llvm::Module> >::run(llvm::Module&, llvm::AnalysisManager<llvm::Module>&) llvm/include/llvm/IR/PassManager.h:525:0
#17 0x00000000019c0c20 llvm::runPassPipeline(llvm::StringRef, llvm::Module&, llvm::TargetMachine*, llvm::TargetLibraryInfoImpl*, llvm::ToolOutputFile*, llvm::ToolOutputFile*, llvm::ToolOutputFile*, llvm::StringRef, llvm::ArrayRef<llvm::StringRef>, llvm::opt_tool::OutputKind, llvm::opt_tool::VerifierKind, bool, bool, bool, bool, bool) llvm/tools/opt/NewPMDriver.cpp:487:0
#18 0x00000000019f0e19 main llvm/tools/opt/opt.cpp:818:0
#19 0x00007fbeb334d6a3 __libc_start_main (/lib64/libc.so.6+0x236a3)
#20 0x00000000019ba76e _start (bin/opt+0x19ba76e)
Aborted (core dumped)

It seems that calling getNullValue for a X86_MMX type is not supported. From my understanding, this type doesn't supports LLVM::Constant (https://llvm.org/docs/LangRef.html#x86-mmx-type). I attached a simple test case that reproduce the issue with the following command:

opt -S -globalopt simple.ll

simple.ll311 BDownload

[nikic]

llvm/lib/Transforms/IPO/GlobalOpt.cpp

309

Thanks for the report! I submitted D115924 to fix this and related issues.

llvm/lib/Transforms/IPO/GlobalOpt.cpp

 #include "llvm/ADT/Statistic.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/Analysis/BlockFrequencyInfo.h"
 #include "llvm/Analysis/ConstantFolding.h"
 #include "llvm/Analysis/MemoryBuiltins.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/Analysis/TargetTransformInfo.h"
+#include "llvm/Analysis/ValueTracking.h"
 #include "llvm/BinaryFormat/Dwarf.h"
 #include "llvm/IR/Attributes.h"
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/CallingConv.h"
 #include "llvm/IR/Constant.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/DebugInfoMetadata.h"
CleanupPointerRootUsers(GlobalVariable *GV,
   }
 
   return Changed;
 }
 
 /// We just marked GV constant.  Loop over all users of the global, cleaning up
 /// the obvious ones.  This is largely just a quick scan over the use list to
 /// clean up the easy and obvious cruft.  This returns true if it made a change.
-static bool CleanupConstantGlobalUsers(
-    Value *V, Constant *Init, const DataLayout &DL,
-    function_ref<TargetLibraryInfo &(Function &)> GetTLI) {
+static bool CleanupConstantGlobalUsers(GlobalVariable *GV,
+                                       const DataLayout &DL) {
+  Constant *Init = GV->getInitializer();
+  SmallVector<User *, 8> WorkList(GV->users());
+  SmallPtrSet<User *, 8> Visited;
   bool Changed = false;
-  // Note that we need to use a weak value handle for the worklist items. When
-  // we delete a constant array, we may also be holding pointer to one of its
-  // elements (or an element of one of its elements if we're dealing with an
-  // array of arrays) in the worklist.
-  SmallVector<WeakTrackingVH, 8> WorkList(V->users());
+
+  SmallVector<WeakTrackingVH> MaybeDeadInsts;
+  auto EraseFromParent = [&](Instruction *I) {
+    for (Value *Op : I->operands())
+      if (auto *OpI = dyn_cast<Instruction>(Op))
+        MaybeDeadInsts.push_back(OpI);
+    I->eraseFromParent();
+    Changed = true;
+  };
   while (!WorkList.empty()) {
-    Value *UV = WorkList.pop_back_val();
-    if (!UV)
+    User *U = WorkList.pop_back_val();
+    if (!Visited.insert(U).second)
       continue;
 
-    User *U = cast<User>(UV);
+    if (auto *BO = dyn_cast<BitCastOperator>(U))
+      append_range(WorkList, BO->users());
+    if (auto *ASC = dyn_cast<AddrSpaceCastOperator>(U))
+      append_range(WorkList, ASC->users());
+    else if (auto *GEP = dyn_cast<GEPOperator>(U))
+      append_range(WorkList, GEP->users());
+    else if (auto *LI = dyn_cast<LoadInst>(U)) {
+      // A load from zeroinitializer is always zeroinitializer, regardless of
+      // any applied offset.
+      if (Init->isNullValue()) {
+        LI->replaceAllUsesWith(Constant::getNullValue(LI->getType()));
+        EraseFromParent(LI);
+        continue;
+      }
 
-    if (LoadInst *LI = dyn_cast<LoadInst>(U)) {
-      if (Init) {
-        if (auto *Casted =
-                ConstantFoldLoadThroughBitcast(Init, LI->getType(), DL)) {
-          // Replace the load with the initializer.
-          LI->replaceAllUsesWith(Casted);
-          LI->eraseFromParent();
-          Changed = true;
+      Value *PtrOp = LI->getPointerOperand();
+      APInt Offset(DL.getIndexTypeSizeInBits(PtrOp->getType()), 0);
+      PtrOp = PtrOp->stripAndAccumulateConstantOffsets(
+          DL, Offset, /* AllowNonInbounds */ true);
+      if (PtrOp == GV) {
+        if (auto *Value = ConstantFoldLoadFromConst(Init, LI->getType(),
+                                                    Offset, DL)) {
+          LI->replaceAllUsesWith(Value);
+          EraseFromParent(LI);
         }
       }
     } else if (StoreInst *SI = dyn_cast<StoreInst>(U)) {
       // Store must be unreachable or storing Init into the global.
-      SI->eraseFromParent();
-      Changed = true;
-    } else if (ConstantExpr *CE = dyn_cast<ConstantExpr>(U)) {
-      if (CE->getOpcode() == Instruction::GetElementPtr) {
-        Constant *SubInit = nullptr;
-        if (Init)
-          SubInit = ConstantFoldLoadThroughGEPConstantExpr(
-              Init, CE, V->getType()->getPointerElementType(), DL);
-        Changed |= CleanupConstantGlobalUsers(CE, SubInit, DL, GetTLI);
-      } else if ((CE->getOpcode() == Instruction::BitCast &&
-                  CE->getType()->isPointerTy()) ||
-                 CE->getOpcode() == Instruction::AddrSpaceCast) {
-        // Pointer cast, delete any stores and memsets to the global.
-        Changed |= CleanupConstantGlobalUsers(CE, nullptr, DL, GetTLI);
-      }
-
-      if (CE->use_empty()) {
-        CE->destroyConstant();
-        Changed = true;
-      }
-    } else if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(U)) {
-      // Do not transform "gepinst (gep constexpr (GV))" here, because forming
-      // "gepconstexpr (gep constexpr (GV))" will cause the two gep's to fold
-      // and will invalidate our notion of what Init is.
-      Constant *SubInit = nullptr;
-      if (!isa<ConstantExpr>(GEP->getOperand(0))) {
-        ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(
-            ConstantFoldInstruction(GEP, DL, &GetTLI(*GEP->getFunction())));
-        if (Init && CE && CE->getOpcode() == Instruction::GetElementPtr)
-          SubInit = ConstantFoldLoadThroughGEPConstantExpr(
-              Init, CE, V->getType()->getPointerElementType(), DL);
-
-        // If the initializer is an all-null value and we have an inbounds GEP,
-        // we already know what the result of any load from that GEP is.
-        // TODO: Handle splats.
-        if (Init && isa<ConstantAggregateZero>(Init) && GEP->isInBounds())
-          SubInit = Constant::getNullValue(GEP->getResultElementType());
-      }
-      Changed |= CleanupConstantGlobalUsers(GEP, SubInit, DL, GetTLI);
-
-      if (GEP->use_empty()) {
-        GEP->eraseFromParent();
-        Changed = true;
-      }
+      EraseFromParent(SI);
     } else if (MemIntrinsic *MI = dyn_cast<MemIntrinsic>(U)) { // memset/cpy/mv
-      if (MI->getRawDest() == V) {
-        MI->eraseFromParent();
-        Changed = true;
-      }
-
-    } else if (Constant *C = dyn_cast<Constant>(U)) {
-      // If we have a chain of dead constantexprs or other things dangling from
-      // us, and if they are all dead, nuke them without remorse.
-      if (isSafeToDestroyConstant(C)) {
-        C->destroyConstant();
-        CleanupConstantGlobalUsers(V, Init, DL, GetTLI);
-        return true;
-      }
+      if (getUnderlyingObject(MI->getRawDest()) == GV)
+        EraseFromParent(MI);
     }
   }
+
+  RecursivelyDeleteTriviallyDeadInstructionsPermissive(MaybeDeadInsts);
+  GV->removeDeadConstantUsers();
   return Changed;
 }
 
 static bool isSafeSROAElementUse(Value *V);
 
 /// Return true if the specified GEP is a safe user of a derived
 /// expression from a global that we want to SROA.
 static bool isSafeSROAGEP(User *U) {
static bool OptimizeAwayTrappingUsesOfLoads(
 
   // If we nuked all of the loads, then none of the stores are needed either,
   // nor is the global.
   if (AllNonStoreUsesGone) {
     if (isLeakCheckerRoot(GV)) {
       Changed |= CleanupPointerRootUsers(GV, GetTLI);
     } else {
       Changed = true;
-      CleanupConstantGlobalUsers(GV, nullptr, DL, GetTLI);
+      CleanupConstantGlobalUsers(GV, DL);
     }
     if (GV->use_empty()) {
       LLVM_DEBUG(dbgs() << "  *** GLOBAL NOW DEAD!\n");
       Changed = true;
       GV->eraseFromParent();
       ++NumDeleted;
     }
   }
if (!GS.IsLoaded) {
     LLVM_DEBUG(dbgs() << "GLOBAL NEVER LOADED: " << *GV << "\n");
 
     if (isLeakCheckerRoot(GV)) {
       // Delete any constant stores to the global.
       Changed = CleanupPointerRootUsers(GV, GetTLI);
     } else {
       // Delete any stores we can find to the global.  We may not be able to
       // make it completely dead though.
-      Changed =
-          CleanupConstantGlobalUsers(GV, GV->getInitializer(), DL, GetTLI);
+      Changed = CleanupConstantGlobalUsers(GV, DL);
     }
 
     // If the global is dead now, delete it.
     if (GV->use_empty()) {
       GV->eraseFromParent();
       ++NumDeleted;
       Changed = true;
     }
     return Changed;
 
   }
   if (GS.StoredType <= GlobalStatus::InitializerStored) {
     LLVM_DEBUG(dbgs() << "MARKING CONSTANT: " << *GV << "\n");
 
     // Don't actually mark a global constant if it's atomic because atomic loads
     // are implemented by a trivial cmpxchg in some edge-cases and that usually
     // requires write access to the variable even if it's not actually changed.
     if (GS.Ordering == AtomicOrdering::NotAtomic) {
       assert(!GV->isConstant() && "Expected a non-constant global");
       GV->setConstant(true);
       Changed = true;
     }
 
     // Clean up any obviously simplifiable users now.
-    Changed |= CleanupConstantGlobalUsers(GV, GV->getInitializer(), DL, GetTLI);
+    Changed |= CleanupConstantGlobalUsers(GV, DL);
 
     // If the global is dead now, just nuke it.
     if (GV->use_empty()) {
       LLVM_DEBUG(dbgs() << "   *** Marking constant allowed us to simplify "
                         << "all users and delete global!\n");
       GV->eraseFromParent();
       ++NumDeleted;
       return true;
if (GS.StoredType == GlobalStatus::StoredOnce && StoredOnceValue) {
     // shared memory (AS 3).
     if (SOVConstant && SOVConstant->getType() == GV->getValueType() &&
         isa<UndefValue>(GV->getInitializer()) &&
         CanHaveNonUndefGlobalInitializer) {
       // Change the initial value here.
       GV->setInitializer(SOVConstant);
 
       // Clean up any obviously simplifiable users now.
-      CleanupConstantGlobalUsers(GV, GV->getInitializer(), DL, GetTLI);
+      CleanupConstantGlobalUsers(GV, DL);
 
       if (GV->use_empty()) {
         LLVM_DEBUG(dbgs() << "   *** Substituting initializer allowed us to "
                           << "simplify all users and delete global!\n");
         GV->eraseFromParent();
         ++NumDeleted;
       }
       ++NumSubstitute;

llvm/test/Transforms/GlobalOpt/address_space_initializer.ll

 ; RUN: opt -passes=globalopt < %s -S | FileCheck %s
 ; RUN: opt -passes=globalopt --mtriple=nvptx64 < %s -S | FileCheck %s --check-prefix=GPU
 ; RUN: opt -passes=globalopt --mtriple=amdgcn < %s -S | FileCheck %s --check-prefix=GPU
 ; REQUIRES: amdgpu-registered-target, nvptx-registered-target
 
 ; Check that we don't try to set a global initializer for non AS(0) globals.
 
 @g0 = internal global i16 undef
 @g1 = internal addrspace(3) global i16 undef
 @g2 = internal addrspace(1) global i16 undef
-; CHECK: internal unnamed_addr constant i16 3
+; CHECK-NOT: @g0 =
 ; CHECK: internal unnamed_addr addrspace(3) global i16 undef
 ; CHECK: internal unnamed_addr addrspace(1) global i16 undef
-; GPU: internal unnamed_addr constant i16 3
+; GPU-NOT: @g0 =
 ; GPU: internal unnamed_addr addrspace(3) global i16 undef
-; GPU: internal unnamed_addr addrspace(1) constant i16 7
+; GPU-NOT: @g2 =
 
 define void @a() {
   store i16 3, i16* @g0, align 8
   store i16 5, i16* addrspacecast (i16 addrspace(3)* @g1 to i16*), align 8
   store i16 7, i16* addrspacecast (i16 addrspace(1)* @g2 to i16*), align 8
   ret void
 }
 

llvm/test/Transforms/GlobalOpt/atomic.ll

 ; RUN: opt -passes=globalopt < %s -S -o - | FileCheck %s
 
 @GV1 = internal global i64 1, align 8
 @GV2 = internal global i32 0, align 4
 
-; CHECK: @GV1 = internal unnamed_addr global i64 1, align 8
+; CHECK-NOT: @GV1 =
 ; CHECK: @GV2 = internal unnamed_addr global i32 0, align 4
 
 define void @test1() {
 entry:
   %0 = load atomic i8, i8* bitcast (i64* @GV1 to i8*) acquire, align 8
   ret void
 }
 

llvm/test/Transforms/GlobalOpt/const-return-status-atomic.ll

 ; RUN: opt -passes=globalopt < %s -S -o - | FileCheck %s
 
 ; When simplifying users of a global variable, the pass could incorrectly
 ; return false if there were still some uses left, and no further optimizations
 ; was done. This was caught by the pass return status check that is hidden
 ; under EXPENSIVE_CHECKS.
 
 @GV1 = internal unnamed_addr global i64 1, align 8
 
-; CHECK: @GV1 = internal unnamed_addr global i64 1, align 8
+; CHECK-NOT: @GV1 =
 
 define void @test1() local_unnamed_addr {
 ; CHECK-LABEL: @test1
-; CHECK-NEXT: %val = load atomic i8
 ; CHECK-NEXT: ret void
 
   %val = load atomic i8, i8* bitcast (i64* @GV1 to i8*) acquire, align 8
   ret void
 }
 
 define i64 @test2() local_unnamed_addr {
 ; CHECK-LABEL: @test2
 ; CHECK-NEXT: ret i64 1
 
   %val = load atomic i64, i64* @GV1 acquire, align 8
   ret i64 %val
 }