[IR] Don't consider interposable globals to be dereferenceable

[nikic]

Summary

According to D78952, we should not be making assumption about the size (and thus dereferencability) of globals that don't have a definitive initializer.

This is a draft patch to make the implementation comply with the specification, though I haven't fixed all test failures yet:

Failed Tests (17):
  LLVM :: CodeGen/AArch64/GlobalISel/constant-dbg-loc.ll
  LLVM :: CodeGen/AArch64/GlobalISel/localizer-arm64-tti.ll
  LLVM :: CodeGen/AArch64/csr-split.ll
  LLVM :: CodeGen/AMDGPU/GlobalISel/irtranslator-invariant.ll
  LLVM :: CodeGen/PowerPC/GlobalISel/ppc-irtranslator-stackprotect.ll
  LLVM :: CodeGen/PowerPC/aix-cc-abi.ll
  LLVM :: CodeGen/PowerPC/aix-cc-byval.ll
  LLVM :: CodeGen/PowerPC/ctrloops-pseudo.ll
  LLVM :: CodeGen/PowerPC/lower-globaladdr32-aix.ll
  LLVM :: CodeGen/PowerPC/lower-globaladdr64-aix.ll
  LLVM :: CodeGen/PowerPC/out-of-range-dform.ll
  LLVM :: CodeGen/SystemZ/int-cmp-59.ll
  LLVM :: CodeGen/X86/fold-sext-trunc.ll
  LLVM :: CodeGen/X86/pr32610.ll
  LLVM :: CodeGen/X86/pr37916.ll
  LLVM :: CodeGen/X86/remat-constant.ll
  LLVM-Unit :: Analysis/./AnalysisTests/LoadsTest/CanReplacePointersIfEqual

Alternatively, we should change the spec to permit our current assumption of a minimum size

[arsenm]

I'd expect the minimum size behavior, otherwise what is even the point of having a size associated with the global declaration?

[efriedma]

At the C source level, we should be able to assume that if someone writes "extern int x;", that has 4 dereferenceable bytes. (From the standard: "All declarations that refer to the same object or function shall have compatible type; otherwise, the behavior is undefined.") If there's some incentive to change the way we express that, I'm open to proposals, but I don't think it makes sense to just drop that completely.

[nikic]

Okay, it sounds like the consensus if to change LangRef instead.

[nikic]

LangRef patch: D143057

llvm/lib/IR/Value.cpp

uint64_t Value::getPointerDereferenceableBytes(const DataLayout &DL,
   } else if (auto *AI = dyn_cast<AllocaInst>(this)) {
     if (!AI->isArrayAllocation()) {
       DerefBytes =
           DL.getTypeStoreSize(AI->getAllocatedType()).getKnownMinValue();
       CanBeNull = false;
       CanBeFreed = false;
     }
   } else if (auto *GV = dyn_cast<GlobalVariable>(this)) {
-    if (GV->getValueType()->isSized() && !GV->hasExternalWeakLinkage()) {
-      // TODO: Don't outright reject hasExternalWeakLinkage but set the
-      // CanBeNull flag.
+    if (GV->getValueType()->isSized() && GV->hasDefinitiveInitializer()) {
       DerefBytes = DL.getTypeStoreSize(GV->getValueType()).getFixedValue();
       CanBeNull = false;
       CanBeFreed = false;
     }
   }
   return DerefBytes;
 }
 

llvm/test/Analysis/ValueTracking/memory-dereferenceable.ll

 
 declare zeroext i1 @return_i1()
 
 declare ptr @foo()
 @globalstr = global [6 x i8] c"hello\00"
 @globali32ptr = external global ptr
 
 %struct.A = type { [8 x i8], [5 x i8] }
-@globalstruct = external global %struct.A
+@globalstruct = global %struct.A poison
 
[e-mail]1 = external global i8, align 1
[e-mail]16 = external global i8, align 16
[e-mail]1 = global i8 poison, align 1
[e-mail]16 = global i8 poison, align 16
+
[e-mail] = external global i8
 
 ; Loads from sret arguments
 ; CHECK-LABEL: 'test_sret'
 ; CHECK: %sret_gep{{.*}}(aligned)
 ; CHECK-NOT: %sret_gep_outside
 define void @test_sret(ptr sret(%struct.A) %result) {
   %sret_gep = getelementptr inbounds %struct.A, ptr %result, i64 0, i32 1, i64 2
   load i8, ptr %sret_gep
define void @alloca_perfalign() {
    %load28 = load i32, ptr %alloca.noalign, align 8
    ret void
 }
 
 ; CHECK-LABEL: 'global'
 ; CHECK: @globalptr.align1{{.*}}(unaligned)
 ; CHECK: @globalptr.align16{{.*}}(aligned)
 ; CHECK: @globalstr{{.*}}(aligned)
+; CHECK-NOT: @globalptr.extern
 define void @global() {
   %load13 = load i8, ptr @globalptr.align1, align 16
   %load14 = load i8, ptr @globalptr.align16, align 16
 
   %load1 = load i8, ptr @globalstr
+  %load2 = load i8, ptr @globalptr.extern
   ret void
 }
 
 ; It's OK to overrun static array size as long as we stay within underlying
 ; object size
 ; CHECK-LABEL: 'global_allocationsize'
 ; CHECK: %within_allocation{{.*}}(aligned)
 ; CHECK-NOT: %outside_allocation

llvm/test/Transforms/Attributor/ArgumentPromotion/naked_functions.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes --check-globals
 ; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal  -attributor-max-iterations-verify -attributor-annotate-decl-cs -attributor-max-iterations=1 -S < %s | FileCheck %s --check-prefixes=CHECK,TUNIT
 ; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal  -attributor-annotate-decl-cs -S < %s | FileCheck %s --check-prefixes=CHECK,CGSCC
 
 ; Don't promote paramaters of/arguments to naked functions
 
 @g = common global i32 0, align 4
 
 ;.
 ; CHECK: @[[G:[a-zA-Z0-9_$"\\.-]+]] = common global i32 0, align 4
 ;.
 define i32 @bar() {
 ; CHECK-LABEL: define {{[^@]+}}@bar() {
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[CALL:%.*]] = call i32 @foo(ptr noundef nonnull align 4 dereferenceable(4) @g)
+; CHECK-NEXT:    [[CALL:%.*]] = call i32 @foo(ptr noundef align 4 @g)
 ; CHECK-NEXT:    ret i32 [[CALL]]
 ;
 entry:
   %call = call i32 @foo(ptr @g)
   ret i32 %call
 }
 
 define internal i32 @foo(ptr) #0 {

llvm/test/Transforms/Attributor/IPConstantProp/pthreads.ll

 ;.
 define dso_local i32 @main() {
 ; TUNIT-LABEL: define {{[^@]+}}@main() {
 ; TUNIT-NEXT:  entry:
 ; TUNIT-NEXT:    [[ALLOC1:%.*]] = alloca i8, align 8
 ; TUNIT-NEXT:    [[ALLOC2:%.*]] = alloca i8, align 8
 ; TUNIT-NEXT:    [[THREAD:%.*]] = alloca i64, align 8
 ; TUNIT-NEXT:    [[CALL:%.*]] = call i32 @pthread_create(ptr noundef nonnull align 8 dereferenceable(8) [[THREAD]], ptr noalias nocapture noundef align 4294967296 null, ptr noundef nonnull @foo, ptr noalias nocapture nofree readnone align 4294967296 undef)
-; TUNIT-NEXT:    [[CALL1:%.*]] = call i32 @pthread_create(ptr noundef nonnull align 8 dereferenceable(8) [[THREAD]], ptr noalias nocapture noundef align 4294967296 null, ptr noundef nonnull @bar, ptr noalias nocapture nofree nonnull readnone align 8 dereferenceable(8) undef)
+; TUNIT-NEXT:    [[CALL1:%.*]] = call i32 @pthread_create(ptr noundef nonnull align 8 dereferenceable(8) [[THREAD]], ptr noalias nocapture noundef align 4294967296 null, ptr noundef nonnull @bar, ptr noalias nocapture nofree readnone align 8 undef)
 ; TUNIT-NEXT:    [[CALL2:%.*]] = call i32 @pthread_create(ptr noundef nonnull align 8 dereferenceable(8) [[THREAD]], ptr noalias nocapture noundef align 4294967296 null, ptr noundef nonnull @baz, ptr noalias nocapture nofree noundef nonnull readnone align 8 dereferenceable(1) [[ALLOC1]])
 ; TUNIT-NEXT:    [[CALL3:%.*]] = call i32 @pthread_create(ptr noundef nonnull align 8 dereferenceable(8) [[THREAD]], ptr noalias nocapture noundef align 4294967296 null, ptr noundef nonnull @buz, ptr noalias nofree noundef nonnull readnone align 8 dereferenceable(1) "no-capture-maybe-returned" [[ALLOC2]])
 ; TUNIT-NEXT:    ret i32 0
 ;
 ; CGSCC-LABEL: define {{[^@]+}}@main() {
 ; CGSCC-NEXT:  entry:
 ; CGSCC-NEXT:    [[ALLOC1:%.*]] = alloca i8, align 8
 ; CGSCC-NEXT:    [[ALLOC2:%.*]] = alloca i8, align 8
 ; CGSCC-NEXT:    [[THREAD:%.*]] = alloca i64, align 8
 ; CGSCC-NEXT:    [[CALL:%.*]] = call i32 @pthread_create(ptr noundef nonnull align 8 dereferenceable(8) [[THREAD]], ptr noalias nocapture noundef align 4294967296 null, ptr noundef nonnull @foo, ptr noalias nocapture nofree noundef readnone align 4294967296 null)
-; CGSCC-NEXT:    [[CALL1:%.*]] = call i32 @pthread_create(ptr noundef nonnull align 8 dereferenceable(8) [[THREAD]], ptr noalias nocapture noundef align 4294967296 null, ptr noundef nonnull @bar, ptr noalias nofree noundef nonnull readnone align 8 dereferenceable(8) @GlobalVPtr)
+; CGSCC-NEXT:    [[CALL1:%.*]] = call i32 @pthread_create(ptr noundef nonnull align 8 dereferenceable(8) [[THREAD]], ptr noalias nocapture noundef align 4294967296 null, ptr noundef nonnull @bar, ptr noalias nofree noundef readnone align 8 @GlobalVPtr)
 ; CGSCC-NEXT:    [[CALL2:%.*]] = call i32 @pthread_create(ptr noundef nonnull align 8 dereferenceable(8) [[THREAD]], ptr noalias nocapture noundef align 4294967296 null, ptr noundef nonnull @baz, ptr noalias nocapture nofree noundef nonnull readnone align 8 dereferenceable(1) [[ALLOC1]])
 ; CGSCC-NEXT:    [[CALL3:%.*]] = call i32 @pthread_create(ptr noundef nonnull align 8 dereferenceable(8) [[THREAD]], ptr noalias nocapture noundef align 4294967296 null, ptr noundef nonnull @buz, ptr noalias nofree noundef nonnull readnone align 8 dereferenceable(1) [[ALLOC2]])
 ; CGSCC-NEXT:    ret i32 0
 ;
 entry:
   %alloc1 = alloca i8, align 8
   %alloc2 = alloca i8, align 8
   %thread = alloca i64, align 8

 ;
 entry:
   ret ptr %arg
 }
 
 define internal ptr @bar(ptr %arg) {
 ; CHECK: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none)
 ; CHECK-LABEL: define {{[^@]+}}@bar
-; CHECK-SAME: (ptr noalias nocapture nofree nonnull readnone align 8 dereferenceable(8) [[ARG:%.*]]) #[[ATTR0]] {
+; CHECK-SAME: (ptr noalias nocapture nofree readnone align 8 [[ARG:%.*]]) #[[ATTR0]] {
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    ret ptr @GlobalVPtr
 ;
 entry:
   ret ptr %arg
 }
 
 define internal ptr @baz(ptr %arg) {

llvm/test/Transforms/Attributor/memory_locations.ll

 ;
   call void @write_global()
   ret void
 }
 define void @writeonly_global_via_arg() {
 ; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(write)
 ; TUNIT-LABEL: define {{[^@]+}}@writeonly_global_via_arg
 ; TUNIT-SAME: () #[[ATTR6]] {
-; TUNIT-NEXT:    call void @write_global_via_arg(ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) @G) #[[ATTR10]]
+; TUNIT-NEXT:    call void @write_global_via_arg(ptr nocapture nofree noundef writeonly align 4 @G) #[[ATTR10]]
 ; TUNIT-NEXT:    ret void
 ;
 ; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(write)
 ; CGSCC-LABEL: define {{[^@]+}}@writeonly_global_via_arg
 ; CGSCC-SAME: () #[[ATTR8]] {
 ; CGSCC-NEXT:    call void @write_global_via_arg(ptr nocapture nofree noundef nonnull writeonly align 4 dereferenceable(4) @G) #[[ATTR11]]
 ; CGSCC-NEXT:    ret void
 ;

llvm/test/Transforms/Attributor/noalias.ll

 ; TUNIT: Function Attrs: nofree norecurse nosync nounwind willreturn memory(none)
 ; TUNIT-LABEL: define {{[^@]+}}@calle1
 ; TUNIT-SAME: () #[[ATTR0]] {
 ; TUNIT-NEXT:    ret ptr @G
 ;
 ; CGSCC: Function Attrs: nofree nosync nounwind willreturn memory(none)
 ; CGSCC-LABEL: define {{[^@]+}}@calle1
 ; CGSCC-SAME: () #[[ATTR2:[0-9]+]] {
-; CGSCC-NEXT:    [[TMP1:%.*]] = call noundef nonnull align 8 dereferenceable(8) ptr @getter() #[[ATTR11:[0-9]+]]
+; CGSCC-NEXT:    [[TMP1:%.*]] = call noundef align 8 ptr @getter() #[[ATTR11:[0-9]+]]
 ; CGSCC-NEXT:    ret ptr [[TMP1]]
 ;
   %1 = call ptr @getter()
   ret ptr %1
 }
 
 ; TEST 6
 declare noalias ptr @strdup(ptr nocapture) nounwind

llvm/test/Transforms/Attributor/nosync.ll

 @a = common global i32 0, align 4
 
 ; TEST 18 - negative. Synchronizing intrinsic
 
 define void @i_totally_sync() {
 ; CHECK: Function Attrs: nounwind
 ; CHECK-LABEL: define {{[^@]+}}@i_totally_sync
 ; CHECK-SAME: () #[[ATTR14:[0-9]+]] {
-; CHECK-NEXT:    tail call void @llvm.x86.sse2.clflush(i8* noundef nonnull align 4 dereferenceable(4) bitcast (i32* @a to i8*))
+; CHECK-NEXT:    tail call void @llvm.x86.sse2.clflush(i8* noundef align 4 bitcast (i32* @a to i8*))
 ; CHECK-NEXT:    ret void
 ;
   tail call void @llvm.x86.sse2.clflush(i8* bitcast (i32* @a to i8*))
   ret void
 }
 
 declare float @llvm.cos(float %val) readnone
 

llvm/test/Transforms/Attributor/returned.ll

 ; TUNIT: Function Attrs: nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable
 ; TUNIT-LABEL: define {{[^@]+}}@use_const
 ; TUNIT-SAME: () #[[ATTR0]] {
 ; TUNIT-NEXT:    ret ptr @G
 ;
 ; CGSCC: Function Attrs: nofree noinline nosync nounwind willreturn memory(none) uwtable
 ; CGSCC-LABEL: define {{[^@]+}}@use_const
 ; CGSCC-SAME: () #[[ATTR3]] {
-; CGSCC-NEXT:    [[C:%.*]] = call noundef nonnull dereferenceable(1) ptr @ret_const() #[[ATTR9:[0-9]+]]
+; CGSCC-NEXT:    [[C:%.*]] = call noundef ptr @ret_const() #[[ATTR9:[0-9]+]]
 ; CGSCC-NEXT:    ret ptr [[C]]
 ;
   %c = call ptr @ret_const()
   ret ptr %c
 }
 define ptr @dont_use_const() #0 {
 ; TUNIT: Function Attrs: nofree noinline norecurse nosync nounwind willreturn memory(none) uwtable
 ; TUNIT-LABEL: define {{[^@]+}}@dont_use_const
 ; TUNIT-SAME: () #[[ATTR0]] {
 ; TUNIT-NEXT:    ret ptr @G
 ;
 ; CGSCC: Function Attrs: nofree noinline nosync nounwind willreturn memory(none) uwtable
 ; CGSCC-LABEL: define {{[^@]+}}@dont_use_const
 ; CGSCC-SAME: () #[[ATTR3]] {
-; CGSCC-NEXT:    [[C:%.*]] = musttail call noundef nonnull dereferenceable(1) ptr @ret_const() #[[ATTR9]]
+; CGSCC-NEXT:    [[C:%.*]] = musttail call noundef ptr @ret_const() #[[ATTR9]]
 ; CGSCC-NEXT:    ret ptr [[C]]
 ;
   %c = musttail call ptr @ret_const()
   ret ptr %c
 }
 
 ; UTC_ARGS: --disable
 ;

llvm/test/Transforms/InstCombine/atomic.ll

 ; CHECK-LABEL: @test14_no_null_opt(
 ; CHECK-NEXT:    store atomic i32 0, ptr null seq_cst, align 4294967296
 ; CHECK-NEXT:    ret i32 0
 ;
   store atomic i32 0, ptr null seq_cst, align 4
   ret i32 0
 }
 
-@a = external global i32
-@b = external global i32
+@a = global i32 0
+@b = global i32 0
 
 define i32 @test15(i1 %cnd) {
 ; CHECK-LABEL: @test15(
 ; CHECK-NEXT:    [[A_VAL:%.*]] = load atomic i32, ptr @a unordered, align 4
 ; CHECK-NEXT:    [[B_VAL:%.*]] = load atomic i32, ptr @b unordered, align 4
 ; CHECK-NEXT:    [[X:%.*]] = select i1 [[CND:%.*]], i32 [[A_VAL]], i32 [[B_VAL]]
 ; CHECK-NEXT:    ret i32 [[X]]
 ;

llvm/test/Transforms/LICM/2008-07-22-LoadGlobalConstant.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -passes=licm -S | FileCheck %s
 
 @a = external constant ptr
 
 define void @test(i32 %count) {
 ; CHECK-LABEL: @test(
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[TMP3:%.*]] = load ptr, ptr @a, align 8
 ; CHECK-NEXT:    br label [[FORCOND:%.*]]
 ; CHECK:       forcond:
 ; CHECK-NEXT:    [[I_0:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[INC:%.*]], [[FORBODY:%.*]] ]
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp ult i32 [[I_0]], [[COUNT:%.*]]
 ; CHECK-NEXT:    br i1 [[CMP]], label [[FORBODY]], label [[AFTERFOR:%.*]]
 ; CHECK:       forbody:
+; CHECK-NEXT:    [[TMP3:%.*]] = load ptr, ptr @a, align 8
 ; CHECK-NEXT:    [[ARRAYIDX:%.*]] = getelementptr float, ptr [[TMP3]], i32 [[I_0]]
 ; CHECK-NEXT:    [[TMP7:%.*]] = uitofp i32 [[I_0]] to float
 ; CHECK-NEXT:    store float [[TMP7]], ptr [[ARRAYIDX]], align 4
 ; CHECK-NEXT:    [[INC]] = add i32 [[I_0]], 1
 ; CHECK-NEXT:    br label [[FORCOND]]
 ; CHECK:       afterfor:
 ; CHECK-NEXT:    ret void
 ;

llvm/test/Transforms/LICM/lcssa-ssa-promoter.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -S -passes=licm < %s | FileCheck %s
 ; RUN: opt -aa-pipeline=basic-aa -passes='require<aa>,require<targetir>,require<scalar-evolution>,require<opt-remark-emit>,loop-mssa(licm)' -S %s| FileCheck %s
 ;
 ; Manually validate LCSSA form is preserved even after SSAUpdater is used to
 ; promote things in the loop bodies.
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
-@x = common global i32 0, align 4
-@y = common global i32 0, align 4
+@x = global i32 0, align 4
+@y = global i32 0, align 4
 
 define void @PR18688() {
 ; CHECK-LABEL: @PR18688(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br i1 undef, label [[RETURN:%.*]], label [[OUTER_PREHEADER:%.*]]
 ; CHECK:       outer.preheader:
 ; CHECK-NEXT:    [[Y_VAL:%.*]] = load i32, ptr @y, align 4
 ; CHECK-NEXT:    [[ICMP:%.*]] = icmp eq i32 [[Y_VAL]], 0

llvm/test/Transforms/LICM/promote-single-thread.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -S -passes=licm < %s | FileCheck %s --check-prefixes=CHECK,MT
 ; RUN: opt -S -passes=licm -licm-force-thread-model-single < %s | FileCheck %s --check-prefixes=CHECK,ST
 
-@g = external global i32
+@g = global i32 0
 @c = external constant i32
 
 declare void @capture(ptr)
 
 ; In single-thread mode both loads and stores can be promoted. In multi-thread
 ; mode only loads can be promoted, as a different thread might write to the
 ; global.
 define void @promote_global(i1 %c, i1 %c2) {
exit:
   ret void
 }
 
 ; The store can never be promoted here, because the global is constant, and
 ; the store could trap.
 define void @promote_constant_global(i1 %c, i1 %c2) {
 ; CHECK-LABEL: @promote_constant_global(
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[V:%.*]] = load i32, ptr @c, align 4
-; CHECK-NEXT:    [[V_INC:%.*]] = add i32 [[V]], 1
 ; CHECK-NEXT:    br label [[LOOP:%.*]]
 ; CHECK:       loop:
 ; CHECK-NEXT:    br i1 [[C:%.*]], label [[IF:%.*]], label [[LATCH:%.*]]
 ; CHECK:       if:
+; CHECK-NEXT:    [[V:%.*]] = load i32, ptr @c, align 4
+; CHECK-NEXT:    [[V_INC:%.*]] = add i32 [[V]], 1
 ; CHECK-NEXT:    store i32 [[V_INC]], ptr @c, align 4
 ; CHECK-NEXT:    br label [[LATCH]]
 ; CHECK:       latch:
 ; CHECK-NEXT:    br i1 [[C2:%.*]], label [[EXIT:%.*]], label [[LOOP]]
 ; CHECK:       exit:
 ; CHECK-NEXT:    ret void
 ;
 entry:

llvm/test/Transforms/LICM/scalar-promote-memmodel.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -passes=licm -S | FileCheck %s
 ; RUN: opt -aa-pipeline=tbaa,basic-aa -passes='require<aa>,require<targetir>,require<scalar-evolution>,require<opt-remark-emit>,loop-mssa(licm)' -S %s | FileCheck %s
 
 ; Make sure we don't hoist a conditionally-executed store out of the loop;
 ; it would violate the concurrency memory model
 
-@g = common global i32 0, align 4
+@g = global i32 0, align 4
 
 define void @bar(i32 %n, i32 %b) nounwind uwtable ssp {
 ; CHECK-LABEL: @bar(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[TOBOOL:%.*]] = icmp eq i32 [[B:%.*]], 0
 ; CHECK-NEXT:    [[G_PROMOTED:%.*]] = load i32, ptr @g, align 4
 ; CHECK-NEXT:    br label [[FOR_COND:%.*]]
 ; CHECK:       for.cond:

llvm/test/Transforms/LoopVectorize/single-value-blend-phis.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -passes=loop-vectorize -force-vector-width=2 -S %s | FileCheck %s
 
-@src = external global [32 x i16], align 1
-@dst = external global [32 x i16], align 1
+@src = global [32 x i16] poison, align 1
+@dst = global [32 x i16] poison, align 1
 
 ; The load in the loop does not need predication, because the accessed memory
 ; is de-referenceable for all loop iterations.
 define void @single_incoming_phi_no_blend_mask(i64 %a, i64 %b) {
 ; CHECK-LABEL: @single_incoming_phi_no_blend_mask(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br i1 false, label [[SCALAR_PH:%.*]], label [[VECTOR_PH:%.*]]
 ; CHECK:       vector.ph:

 ; CHECK:       loop.next:
 ; CHECK-NEXT:    br label [[LOOP_LATCH]]
 ; CHECK:       loop.latch:
 ; CHECK-NEXT:    [[RES:%.*]] = phi i16 [ [[LV]], [[LOOP_COND]] ], [ 1, [[LOOP_NEXT]] ]
 ; CHECK-NEXT:    [[DST_PTR:%.*]] = getelementptr inbounds [32 x i16], ptr @dst, i16 0, i64 [[IV]]
 ; CHECK-NEXT:    store i16 [[RES]], ptr [[DST_PTR]], align 2
 ; CHECK-NEXT:    [[IV_NEXT]] = add nuw nsw i64 [[IV]], 1
 ; CHECK-NEXT:    [[CMP439:%.*]] = icmp ult i64 [[IV]], 31
-; CHECK-NEXT:    br i1 [[CMP439]], label [[LOOP_HEADER]], label [[EXIT]], !llvm.loop [[LOOP2:![0-9]+]]
+; CHECK-NEXT:    br i1 [[CMP439]], label [[LOOP_HEADER]], label [[EXIT]], !llvm.loop [[LOOP3:![0-9]+]]
 ; CHECK:       exit:
 ; CHECK-NEXT:    ret void
 ;
 entry:
   br label %loop.header
 
 loop.header:
   %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop.latch ]

llvm/test/Transforms/SROA/phi-with-duplicate-pred.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -passes='sroa<preserve-cfg>' -S | FileCheck %s --check-prefixes=CHECK,CHECK-PRESERVE-CFG
 ; RUN: opt < %s -passes='sroa<modify-cfg>' -S | FileCheck %s --check-prefixes=CHECK,CHECK-MODIFY-CFG
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-n8:16:32:64"
 
-@a = external global i16, align 1
+@a = global i16 0, align 1
 
 declare void @maybe_writes()
 
 define void @f2(i1 %c1) {
 ; CHECK-LABEL: @f2(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br i1 [[C1:%.*]], label [[IF_THEN:%.*]], label [[IF_ELSE:%.*]]
 ; CHECK:       if.then:

llvm/test/Transforms/SimplifyCFG/X86/PR29163.ll

 ; RUN: opt -S -passes=simplifycfg -simplifycfg-require-and-preserve-domtree=1 < %s | FileCheck %s
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
-@GV = external constant ptr
+@GV = global ptr null
 
 define ptr @test1(i1 %cond, ptr %P) {
 entry:
   br i1 %cond, label %if, label %then
 
 then:
   br label %join
 

llvm/test/Transforms/SimplifyCFG/preserve-branchweights.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --check-globals
 ; RUN: opt -passes=simplifycfg -simplifycfg-require-and-preserve-domtree=1 -switch-range-to-icmp -S -o - < %s | FileCheck %s
 
 declare void @helper(i32)
 
 ;.
-; CHECK: @[[MAX_REGNO:[a-zA-Z0-9_$"\\.-]+]] = common global i32 0, align 4
+; CHECK: @[[MAX_REGNO:[a-zA-Z0-9_$"\\.-]+]] = global i32 0, align 4
 ;.
 define void @test1(i1 %a, i1 %b) {
 ; CHECK-LABEL: @test1(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[A_NOT:%.*]] = xor i1 [[A:%.*]], true
 ; CHECK-NEXT:    [[C:%.*]] = or i1 [[B:%.*]], false
 ; CHECK-NEXT:    [[OR_COND:%.*]] = select i1 [[A_NOT]], i1 [[C]], i1 false
 ; CHECK-NEXT:    br i1 [[OR_COND]], label [[Z:%.*]], label [[Y:%.*]], !prof [[PROF0:![0-9]+]]

 c:
   call void @helper(i32 2) nounwind
   ret void
 }
 
 ;; When folding branches to common destination, the updated branch weights
 ;; can exceed uint32 by more than factor of 2. We should keep halving the
 ;; weights until they can fit into uint32.
-@max_regno = common global i32 0, align 4
+@max_regno = global i32 0, align 4
 define void @test14(ptr %old, i32 %final) {
 ; CHECK-LABEL: @test14(
 ; CHECK-NEXT:  for.cond:
 ; CHECK-NEXT:    br label [[FOR_COND2:%.*]]
 ; CHECK:       for.cond2:
 ; CHECK-NEXT:    [[I_1:%.*]] = phi i32 [ [[INC19:%.*]], [[FOR_INC:%.*]] ], [ 0, [[FOR_COND:%.*]] ]
 ; CHECK-NEXT:    [[BIT_0:%.*]] = phi i32 [ [[SHL:%.*]], [[FOR_INC]] ], [ 1, [[FOR_COND]] ]
 ; CHECK-NEXT:    [[TOBOOL:%.*]] = icmp eq i32 [[BIT_0]], 0

llvm/test/Transforms/TailCallElim/reorder_load.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -passes=tailcallelim -verify-dom-info -S | FileCheck %s
 ; PR4323
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
 ; Several cases where tail call elimination should move the load above the call,
 ; then eliminate the tail recursion.
 
 
 
-@global = external global i32    ; <ptr> [#uses=1]
+@global = global i32 0
 @extern_weak_global = extern_weak global i32    ; <ptr> [#uses=1]
 
 
 ; This load can be moved above the call because the function won't write to it
 ; and the call has no side effects.
 define fastcc i32 @raise_load_1(ptr %a_arg, i32 %a_len_arg, i32 %start_arg) nounwind readonly willreturn {
 ; CHECK-LABEL: @raise_load_1(
 ; CHECK-NEXT:  entry: