[IR] Disallow loading and storing unsized types

[sanjoy]

Summary

It isn't clear what is the operational meaning of loading or storing an
unsized types, since it cannot be lowered into something meaningful.
Since there does not seem to be any practical need for it either, make
such loads and stores illegal IR.

[majnemer]

What about atomicrmw and cmpxchg?

[sanjoy]

In D20846#445219, @majnemer wrote:

What about atomicrmw and cmpxchg?

It looks like both of them already require integer or pointer types.

[majnemer]

LGTM

[chandlerc]

LGTM too.

llvm/trunk/docs/LangRef.rst

 Overview:
 """""""""
 
 The '``load``' instruction is used to read from memory.
 
 Arguments:
 """"""""""
 
-The argument to the ``load`` instruction specifies the memory address
-from which to load. The type specified must be a :ref:`first
-class <t_firstclass>` type. If the ``load`` is marked as ``volatile``,
-then the optimizer is not allowed to modify the number or order of
-execution of this ``load`` with other :ref:`volatile
-operations <volatile>`.
+The argument to the ``load`` instruction specifies the memory address from which
+to load. The type specified must be a :ref:`first class <t_firstclass>` type of
+known size (i.e. not containing an :ref:`opaque structural type <t_opaque>`). If
+the ``load`` is marked as ``volatile``, then the optimizer is not allowed to
+modify the number or order of execution of this ``load`` with other
+:ref:`volatile operations <volatile>`.
 
 If the ``load`` is marked as ``atomic``, it takes an extra :ref:`ordering
 <ordering>` and optional ``singlethread`` argument. The ``release`` and
 ``acq_rel`` orderings are not valid on ``load`` instructions. Atomic loads
 produce :ref:`defined <memmodel>` results when they may see multiple atomic
 stores. The type of the pointee must be an integer, pointer, or floating-point
 type whose bit width is a power of two greater than or equal to eight and less
 than or equal to a target-specific size limit.  ``align`` must be explicitly

 Overview:
 """""""""
 
 The '``store``' instruction is used to write to memory.
 
 Arguments:
 """"""""""
 
-There are two arguments to the ``store`` instruction: a value to store
-and an address at which to store it. The type of the ``<pointer>``
-operand must be a pointer to the :ref:`first class <t_firstclass>` type of
-the ``<value>`` operand. If the ``store`` is marked as ``volatile``,
-then the optimizer is not allowed to modify the number or order of
-execution of this ``store`` with other :ref:`volatile
-operations <volatile>`.
+There are two arguments to the ``store`` instruction: a value to store and an
+address at which to store it. The type of the ``<pointer>`` operand must be a
+pointer to the :ref:`first class <t_firstclass>` type of the ``<value>``
+operand. If the ``store`` is marked as ``volatile``, then the optimizer is not
+allowed to modify the number or order of execution of this ``store`` with other
+:ref:`volatile operations <volatile>`.  Only values of :ref:`first class
+<t_firstclass>` types of known size (i.e. not containing an :ref:`opaque
+structural type <t_opaque>`) can be stored.
 
 If the ``store`` is marked as ``atomic``, it takes an extra :ref:`ordering
 <ordering>` and optional ``singlethread`` argument. The ``acquire`` and
 ``acq_rel`` orderings aren't valid on ``store`` instructions. Atomic loads
 produce :ref:`defined <memmodel>` results when they may see multiple atomic
 stores. The type of the pointee must be an integer, pointer, or floating-point
 type whose bit width is a power of two greater than or equal to eight and less
 than or equal to a target-specific size limit.  ``align`` must be explicitly

llvm/trunk/lib/IR/Verifier.cpp

 }
 
 void Verifier::visitLoadInst(LoadInst &LI) {
   PointerType *PTy = dyn_cast<PointerType>(LI.getOperand(0)->getType());
   Assert(PTy, "Load operand must be a pointer.", &LI);
   Type *ElTy = LI.getType();
   Assert(LI.getAlignment() <= Value::MaximumAlignment,
          "huge alignment values are unsupported", &LI);
+  Assert(ElTy->isSized(), "loading unsized types is not allowed", &LI);
   if (LI.isAtomic()) {
     Assert(LI.getOrdering() != AtomicOrdering::Release &&
                LI.getOrdering() != AtomicOrdering::AcquireRelease,
            "Load cannot have Release ordering", &LI);
     Assert(LI.getAlignment() != 0,
            "Atomic load must specify explicit alignment", &LI);
     Assert(ElTy->isIntegerTy() || ElTy->isPointerTy() ||
                ElTy->isFloatingPointTy(),

 void Verifier::visitStoreInst(StoreInst &SI) {
   PointerType *PTy = dyn_cast<PointerType>(SI.getOperand(1)->getType());
   Assert(PTy, "Store operand must be a pointer.", &SI);
   Type *ElTy = PTy->getElementType();
   Assert(ElTy == SI.getOperand(0)->getType(),
          "Stored value type does not match pointer operand type!", &SI, ElTy);
   Assert(SI.getAlignment() <= Value::MaximumAlignment,
          "huge alignment values are unsupported", &SI);
+  Assert(ElTy->isSized(), "storing unsized types is not allowed", &SI);
   if (SI.isAtomic()) {
     Assert(SI.getOrdering() != AtomicOrdering::Acquire &&
                SI.getOrdering() != AtomicOrdering::AcquireRelease,
            "Store cannot have Acquire ordering", &SI);
     Assert(SI.getAlignment() != 0,
            "Atomic store must specify explicit alignment", &SI);
     Assert(ElTy->isIntegerTy() || ElTy->isPointerTy() ||
                ElTy->isFloatingPointTy(),

llvm/trunk/test/Verifier/unsized-types.ll

+; RUN: not opt -verify < %s 2>&1 | FileCheck %s
+
+%X = type opaque
+
+define void @f_0(%X* %ptr) {
+  %t = load %X, %X* %ptr
+  ret void
+; CHECK: loading unsized types is not allowed
+; CHECK-NEXT:  %t = load %X, %X* %ptr
+}
+
+define void @f_1(%X %val, %X* %ptr) {
+  store %X %val, %X* %ptr
+  ret void
+; CHECK: storing unsized types is not allowed
+; CHECK-NEXT:  store %X %val, %X* %ptr
+}
+
+define void @f_2() {
+  %t = alloca %X
+  ret void
+; CHECK: Cannot allocate unsized type
+; CHECK-NEXT:  %t = alloca %X
+}