Verifier: Disallow uses of intrinsic global variables

[arsenm]

Summary

appendToGlobalCtors implicitly assumes this is the case, since it
deletes and recreates without trying to update any uses.

This ran into an interesting problem in a few linker tests. During the
link, ConstantExpr casts were speculatively created to replace any
uses that might need them for replacement. These unused ConstantExprs
would hang around and still appear on the use list. It seems like a
bug that those stick around, but I'm not sure where those are supposed
to be cleaned up. Avoid this by not creating the casts for appending
linkage.

Delete one of the casts entirely as it breaks no tests. The verifier
has enforced a specific type for these since 2011, so I don't see why
we would need to handle linking modules with a wrong types. One test
does fail without the second cast (Linker/appending-global-proto.ll,
added by D95126). This test looks contrived; it's using appending
linkage with a regular variable. The LangRef suggests this is illegal
(and suggests another missing verifier check).

[tra]

Verifier: Disallow uses of intrinsic global variables

Is this the correct description for this patch? The modified test itself does not seem to use any global variables. Perhaps I'm missing something.

llvm/test/CodeGen/AMDGPU/cgp-addressing-modes-flat.ll

31 ↗

(On Diff #478294)

I'm just curious whether it's expected that some address calculations were not sunk into a conditional branch as it's done on GFX9/10?
I would assume that such a generic optimization would be GPU-agnostic.

[arsenm]

Correct patch

[arsenm]

llvm/test/CodeGen/AMDGPU/cgp-addressing-modes-flat.ll

31 ↗

(On Diff #478294)

gfx7 and 8 didn't have flat offsets or any useful flat addressing modes

[nikic]

lld.ELF/lto::linkage.ll fails in pre-merge checks: LLVM ERROR: unknown special variable

[arsenm]

Opaque pointers fixes the lld test failure. If other pointer cast mismatches for appending variables is banned (D140485) we don't need to worry about the dangling constant expressions anymore

[arsenm]

ping

[nikic]

LGTM

[arsenm]

b67c16ff6af557174e498d6d82df9936e333f3d6

llvm/lib/IR/Verifier.cpp

if (GV.hasCommonLinkage()) {
       Check(!GV.hasComdat(), "'common' global may not be in a Comdat!", &GV);
     }
   }
 
   if (GV.hasName() && (GV.getName() == "llvm.global_ctors" ||
                        GV.getName() == "llvm.global_dtors")) {
     Check(!GV.hasInitializer() || GV.hasAppendingLinkage(),
           "invalid linkage for intrinsic global variable", &GV);
+    Check(GV.materialized_use_empty(),
+          "invalid uses of intrinsic global variable", &GV);
+
     // Don't worry about emitting an error for it not being an array,
     // visitGlobalValue will complain on appending non-array.
     if (ArrayType *ATy = dyn_cast<ArrayType>(GV.getValueType())) {
       StructType *STy = dyn_cast<StructType>(ATy->getElementType());
       PointerType *FuncPtrTy =
           FunctionType::get(Type::getVoidTy(Context), false)->
           getPointerTo(DL.getProgramAddressSpace());
       Check(STy && (STy->getNumElements() == 2 || STy->getNumElements() == 3) &&
if (ArrayType *ATy = dyn_cast<ArrayType>(GV.getValueType())) {
             "wrong type for intrinsic global variable", &GV);
     }
   }
 
   if (GV.hasName() && (GV.getName() == "llvm.used" ||
                        GV.getName() == "llvm.compiler.used")) {
     Check(!GV.hasInitializer() || GV.hasAppendingLinkage(),
           "invalid linkage for intrinsic global variable", &GV);
+    Check(GV.materialized_use_empty(),
+          "invalid uses of intrinsic global variable", &GV);
+
     Type *GVType = GV.getValueType();
     if (ArrayType *ATy = dyn_cast<ArrayType>(GVType)) {
       PointerType *PTy = dyn_cast<PointerType>(ATy->getElementType());
       Check(PTy, "wrong type for intrinsic global variable", &GV);
       if (GV.hasInitializer()) {
         const Constant *Init = GV.getInitializer();
         const ConstantArray *InitArray = dyn_cast<ConstantArray>(Init);
         Check(InitArray, "wrong initalizer for intrinsic global variable",

llvm/test/Linker/Inputs/funcimport_appending_global_used.ll

+@v = weak global i8 1
[e-mail] = appending global [2 x ptr] [ptr @foo, ptr @v]
+
+define void @foo() {
+  ret void
+}

llvm/test/Linker/funcimport_appending_global_used.ll

+; RUN: opt -module-summary %s -o %t.bc
+; RUN: opt -module-summary %p/Inputs/funcimport_appending_global_used.ll -o %t2.bc
+; RUN: llvm-lto -thinlto -o %t3 %t.bc %t2.bc
+
+; Do the import now
+; RUN: llvm-link %t.bc -summary-index=%t3.thinlto.bc -import=foo:%t2.bc -S | FileCheck %s
+
+; Test case where the verifier would fail if checking use_empty
+; instead of materialized_use_empty on llvm.used.
+
+; CHECK: @llvm.used = appending global [1 x ptr] [ptr @f]
+
+declare void @f()
[e-mail] = appending global [1 x ptr] [ptr @f]
+
+define i32 @main() {
+entry:
+  call void @foo()
+  ret i32 0
+}
+
+declare void @foo()

llvm/test/Verifier/global-ctors-dtors-uses.ll

+; RUN: not llvm-as %s -o /dev/null 2>&1 | FileCheck %s
+
+; CHECK: invalid uses of intrinsic global variable
+; CHECK-NEXT: ptr @llvm.global_ctors
[e-mail]_ctors = appending global [1 x { i32, ptr, ptr } ] [
+  { i32, ptr, ptr } { i32 65535, ptr null, ptr null }
+]
+
+; CHECK: invalid uses of intrinsic global variable
+; CHECK-NEXT: ptr @llvm.global_dtors
[e-mail]_dtors = appending global [1 x { i32, ptr, ptr } ] [
+  { i32, ptr, ptr } { i32 65535, ptr null, ptr null }
+]
+
+@ctor_user = global ptr @llvm.global_ctors
+@dtor_user = global ptr @llvm.global_dtors

llvm/test/Verifier/used-uses.ll

+; RUN: not llvm-as %s -o /dev/null 2>&1 | FileCheck %s
+
+; CHECK: invalid uses of intrinsic global variable
+; CHECK-NEXT: ptr @llvm.used
[e-mail] = appending global [1 x ptr] [ptr @foo]
+
+; CHECK: invalid uses of intrinsic global variable
+; CHECK-NEXT: ptr @llvm.compiler.used
[e-mail] = appending global [1 x ptr] [ptr @bar]
+
+define void @foo() {
+  ret void
+}
+
+define void @bar() {
+  ret void
+}
+
+@used_user = global ptr @llvm.used
+@compiler_used_user = global ptr @llvm.compiler.used