[Local] Consider atomic loads from constant global as dead

[nikic]

Summary

Per the guidance in https://llvm.org/docs/Atomics.html#atomics-and-ir-optimization, an atomic load from a constant global can be dropped, as it is not observable. Any write to the constant global would be UB.

IPSCCP will already drop such loads, but the main helper in Local doesn't recognize this currently. This is motivated by D118387.

[fhahn]

LGTM, thanks!

llvm/lib/Transforms/Utils/Local.cpp

503

nit: can be removed, unless they are volatile.?

[nikic]

Abandoning this in favor of D124247, which implements a more general version of this. The "from constant" bit was a red herring. Loading from a constant allows us to determine the result and remove uses, but we can remove any atomic load as long as it has no uses.

[nikic]

Reopening this, as it looks like D124247 is not correct in the general case.

[nikic]

Update PowerPC test to avoid optimizing away atomic load.

llvm/lib/Transforms/Utils/Local.cpp

bool llvm::wouldInstructionBeTriviallyDead(Instruction *I,
   if (CallInst *CI = isFreeCall(I, TLI))
     if (Constant *C = dyn_cast<Constant>(CI->getArgOperand(0)))
       return C->isNullValue() || isa<UndefValue>(C);
 
   if (auto *Call = dyn_cast<CallBase>(I))
     if (isMathLibCallNoop(Call, TLI))
       return true;
 
+  // Non-volatile atomic loads from constants can be removed.
+  if (auto *LI = dyn_cast<LoadInst>(I))
+    if (auto *GV = dyn_cast<GlobalVariable>(
+            LI->getPointerOperand()->stripPointerCasts()))
+      if (!LI->isVolatile() && GV->isConstant())
+        return true;
+
   return false;
 }
 
 /// RecursivelyDeleteTriviallyDeadInstructions - If the specified value is a
 /// trivially dead instruction, delete it.  If that makes any of its operands
 /// trivially dead, delete them too, recursively.  Return true if any
 /// instructions were deleted.
 bool llvm::RecursivelyDeleteTriviallyDeadInstructions(

llvm/test/CodeGen/PowerPC/atomics-constant.ll

 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
 ; RUN: llc < %s | FileCheck %s
 
 target triple = "powerpc64le-unknown-linux-gnu"
 
-@a = dso_local constant i64 zeroinitializer
+@a = dso_local global i64 zeroinitializer
 
 define i64 @foo() {
 ; CHECK-LABEL: foo:
 ; CHECK:       # %bb.0: # %entry
-; CHECK-NEXT:    li 4, 0
 ; CHECK-NEXT:    addis 3, 2, a@toc@ha
 ; CHECK-NEXT:    ld 3, a@toc@l(3)
-; CHECK-NEXT:    cmpd 7, 4, 4
-; CHECK-NEXT:    li 3, 0
+; CHECK-NEXT:    cmpd 7, 3, 3
 ; CHECK-NEXT:    bne- 7, .+4
 ; CHECK-NEXT:    isync
 ; CHECK-NEXT:    blr
 entry:
   %value = load atomic i64, i64* @a acquire, align 8
   ret i64 %value
 }

llvm/test/Transforms/InstCombine/atomic.ll

;
   ret void
 }
 
 @c = constant i32 42
 @g = global i32 42
 
 define i32 @atomic_load_from_constant_global() {
 ; CHECK-LABEL: @atomic_load_from_constant_global(
-; CHECK-NEXT:    [[V:%.*]] = load atomic i32, i32* @c seq_cst, align 4
 ; CHECK-NEXT:    ret i32 42
 ;
   %v = load atomic i32, i32* @c seq_cst, align 4
   ret i32 %v
 }
 
 define i8 @atomic_load_from_constant_global_bitcast() {
 ; CHECK-LABEL: @atomic_load_from_constant_global_bitcast(
-; CHECK-NEXT:    [[V:%.*]] = load atomic i8, i8* bitcast (i32* @c to i8*) seq_cst, align 1
 ; CHECK-NEXT:    ret i8 42
 ;
   %v = load atomic i8, i8* bitcast (i32* @c to i8*) seq_cst, align 1
   ret i8 %v
 }
 
 define void @atomic_load_from_non_constant_global() {
 ; CHECK-LABEL: @atomic_load_from_non_constant_global(