[IR] Don't allow values of opaque type (#137625)

Consider opaque types as non-first-class types, i.e. do not allow SSA
values to have opaque type.

Author: nikic

llvm/docs/LangRef.rst

@@ -4122,6 +4122,30 @@ except :ref:`label <t_label>` and :ref:`metadata <t_metadata>`.
 | ``{i32, i32} (i32)``            | A function taking an ``i32``, returning a :ref:`structure <t_struct>` containing two ``i32`` values                                                                 |
 +---------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 
+.. _t_opaque:
+
+Opaque Structure Types
+----------------------
+
+:Overview:
+
+Opaque structure types are used to represent structure types that
+do not have a body specified. This corresponds (for example) to the C
+notion of a forward declared structure. They can be named (``%X``) or
+unnamed (``%52``).
+
+It is not possible to create SSA values with an opaque structure type. In
+practice, this largely limits their use to the value type of external globals.
+
+:Syntax:
+
+::
+
+      %X = type opaque
+      %52 = type opaque
+
+      @g = external global %X
+
 .. _t_firstclass:
 
 First Class Types
@@ -4562,31 +4586,6 @@ opaqued and are never uniqued. Identified types must not be recursive.
 | ``<{ i8, i32 }>``            | A packed struct known to be 5 bytes in size.                                                                                                                                          |
 +------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
 
-.. _t_opaque:
-
-Opaque Structure Types
-""""""""""""""""""""""
-
-:Overview:
-
-Opaque structure types are used to represent structure types that
-do not have a body specified. This corresponds (for example) to the C
-notion of a forward declared structure. They can be named (``%X``) or
-unnamed (``%52``).
-
-:Syntax:
-
-::
-
-      %X = type opaque
-      %52 = type opaque
-
-:Examples:
-
-+--------------+-------------------+
-| ``opaque``   | An opaque type.   |
-+--------------+-------------------+
-
 .. _constants:
 
 Constants

llvm/include/llvm/IR/Type.h

@@ -286,9 +286,7 @@ class Type {
 
   /// Return true if the type is "first class", meaning it is a valid type for a
   /// Value.
-  bool isFirstClassType() const {
-    return getTypeID() != FunctionTyID && getTypeID() != VoidTyID;
-  }
+  bool isFirstClassType() const;
 
   /// Return true if the type is a valid type for a register in codegen. This
   /// includes all first-class types except struct and array types.

llvm/lib/IR/Type.cpp

@@ -247,6 +247,20 @@ int Type::getFPMantissaWidth() const {
   return -1;
 }
 
+bool Type::isFirstClassType() const {
+  switch (getTypeID()) {
+    default:
+      return true;
+    case FunctionTyID:
+    case VoidTyID:
+      return false;
+    case StructTyID: {
+      auto *ST = cast<StructType>(this);
+      return !ST->isOpaque();
+    }
+  }
+}
+
 bool Type::isSizedDerivedType(SmallPtrSetImpl<Type*> *Visited) const {
   if (auto *ATy = dyn_cast<ArrayType>(this))
     return ATy->getElementType()->isSized(Visited);

llvm/lib/Linker/IRMover.cpp

@@ -1640,6 +1640,8 @@ Error IRLinker::run() {
     if (GV.hasAppendingLinkage())
       continue;
     Value *NewValue = Mapper.mapValue(GV);
+    if (FoundError)
+      return std::move(*FoundError);
     if (NewValue) {
       auto *NewGV = dyn_cast<GlobalVariable>(NewValue->stripPointerCasts());
       if (NewGV) {

llvm/test/Assembler/2004-11-28-InvalidTypeCrash.ll

@@ -1,5 +1,5 @@
 ; Test for PR463.  This program is erroneous, but should not crash llvm-as.
 ; RUN: not llvm-as %s -o /dev/null 2>&1 | FileCheck %s
-; CHECK: use of undefined type named 'struct.none'
+; CHECK: invalid type for null constant
 
 @.FOO  = internal global %struct.none zeroinitializer

llvm/test/Assembler/2005-05-05-OpaqueUndefValues.ll

@@ -1,5 +1,6 @@
-; RUN: llvm-as < %s | llvm-dis | llvm-as > /dev/null
-; RUN: verify-uselistorder %s
+; RUN: not llvm-as < %s 2>&1 | FileCheck %s
+
+; CHECK: error: invalid type for undef constant
 
 %t = type opaque
 @x = global %t undef

llvm/test/Assembler/2007-01-02-Undefined-Arg-Type.ll

@@ -1,7 +1,7 @@
 ; The assembler should catch an undefined argument type .
 ; RUN: not llvm-as %s -o /dev/null 2>&1 | FileCheck %s
 
-; CHECK: use of undefined type named 'typedef.bc_struct'
+; CHECK: invalid type for function argument
 
 ; %typedef.bc_struct = type opaque
 

llvm/test/CodeGen/WebAssembly/externref-unsized-load.ll

@@ -7,4 +7,4 @@ define void @load_extern(%externref %ref) {
   ret void
 }
 
-; CHECK-ERROR: error: loading unsized types is not allowed
+; CHECK-ERROR: error: load operand must be a pointer to a first class type

llvm/test/CodeGen/WebAssembly/externref-unsized-store.ll

@@ -7,4 +7,4 @@ define void @store_extern(%externref %ref) {
   ret void
 }
 
-; CHECK-ERROR: error: storing unsized types is not allowed
+; CHECK-ERROR: error: invalid type for undef constant

llvm/test/CodeGen/X86/cfguard-x86-64-vectorcall.ll

@@ -3,6 +3,7 @@
 ; RUN: llc < %s -mtriple=x86_64-w64-windows-gnu | FileCheck %s -check-prefix=X64
 ; Control Flow Guard is currently only available on Windows
 
+%struct.HVA = type { double, double, double, double }
 
 ; Test that Control Flow Guard checks are correctly added for x86_64 vector calls.
 define void @func_cf_vector_x64(ptr %0, ptr %1) #0 {
@@ -37,8 +38,6 @@ entry:
 }
 attributes #0 = { "target-cpu"="x86-64" "target-features"="+cx8,+fxsr,+mmx,+sse,+sse2,+x87" }
 
-%struct.HVA = type { double, double, double, double }
-
 declare void @llvm.memcpy.p0.p0.i64(ptr nocapture writeonly, ptr nocapture readonly, i64, i1 immarg) #1
 attributes #1 = { argmemonly nounwind willreturn }