[IR] Add dead_on_unwind attribute

[nikic]

Summary

Add the dead_on_unwind attribute, which states that the caller will not read from this argument if the call unwinds. This allows eliding stores that could otherwise be visible on the unwind path, for example:

declare void @may_unwind()

define void @src(ptr noalias dead_on_unwind %out) {
    store i32 0, ptr %out
    call void @may_unwind()
    store i32 1, ptr %out
    ret void
}

define void @tgt(ptr noalias dead_on_unwind %out) {
    call void @may_unwind()
    store i32 1, ptr %out
    ret void
}

The optimization is not valid without dead_on_unwind, because the i32 0 value might be read if @may_unwind unwinds.

This attribute is primarily intended to be used on sret arguments. In fact, I previously wanted to change the semantics of sret to include this "no read after unwind" property (see D116998), but based on the feedback there it is better to keep these attributes orthogonal (sret is an ABI attribute, dead_on_unwind is an optimization attribute). This is a reboot of that change with a separate attribute.

[rnk]

This approach makes sense to me.

I reconfirmed for myself that this will work for C++ sret objects that need to be cleaned up: https://gcc.godbolt.org/z/hnddhTqWa It's the only way it could possibly work, but it took a minute to remind myself how it works.

Please add a test to llvm/test/Bitcode/attributes.ll for the new attribute.

cc some folks with an interest in IR: @asbirlea @jyknight @aeubanks

[nikic]

Add to llvm/test/Bitcode/attributes.ll, add verifier check for pointer type.

[aeubanks]

needs a verifier check that the attribute isn't a return value attribute

a follow up change will infer this for sret args in inferattrs?

is this intended to be derivable for args of internal/private functions or mostly just for sret/something the frontend can add?

what changes would need to be made to sink the store in https://gcc.godbolt.org/z/hnddhTqWa ?

[nikic]

In D157499#4577838, @aeubanks wrote:

needs a verifier check that the attribute isn't a return value attribute

This is specified in Attributes.td and does not need to be separately verified (it's enforced by the IR / bitcode parser).

a follow up change will infer this for sret args in inferattrs?

No, this won't be inferred for sret and should be added by the frontend instead, similar to the other attributes that usually go with sret (noalias, dereferenceable, and for many languages also nocapture). The followup would be to emit it in clang.

is this intended to be derivable for args of internal/private functions or mostly just for sret/something the frontend can add?

The semantics allow deriving it (simplest case: All callers use "call" and pass an alloca to the argument) though I don't have immediate plans to implement this. We currently only perform RPO attribute inference in the late pipeline, at which point the attribute likely won't be useful anymore. If we have motivating cases for this, we could make it work though.

what changes would need to be made to sink the store in https://gcc.godbolt.org/z/hnddhTqWa ?

I don't think we have any store sinking support at all right now, so we'd need that first. This change is primarily aimed at call slot optimization and DSE.

[jdoerfert]

I get the motivation, though, I'm not happy as this is super specific "no-read" and "after-unwind".

I'm spitballing mostly:

What about "dead-after-unwind", or is it used but not read specifically?

Different thought: memory(after_unwind: none)?

Also, do we just concatenate words?

[nikic]

In D157499#4583878, @jdoerfert wrote:

I get the motivation, though, I'm not happy as this is super specific "no-read" and "after-unwind".

I'm spitballing mostly:

What about "dead-after-unwind", or is it used but not read specifically?

I think the thing we really want to convey is that "memory contents do not matter after unwind". There shouldn't be "real" reads or writes after unwind, but there may be a lifetime.end, which we'd usually consider a write.

Something I suggested in previous discussions was to make this "poison on unwind", which does give us the "memory contents do not matter" property without actually forbidding further reads or writes. I think this is what we want in terms of semantics, but I find the name quite intuitive (because it's phrased in terms of an additional virtual action performed on unwind that happens to imply a restriction). Maybe calling it "dead on unwind" with those poison semantics would be reasonable? After all, a write of poison is how we tend to model lifetime end.

Different thought: memory(after_unwind: none)?

This is just for a single argument, while memory() applies to the whole function.

Also, do we just concatenate words?

We have a mix of both, I wouldn't mind making this no_read_after_unwind instead.

[nikic]

Rename to dead_on_unwind, specify in terms of writing a poison value on unwind.

[jdoerfert]

LG from my end. Unsure if others want to chime in.

llvm/docs/LangRef.rst

1543

I think this sounds sensible.

[efriedma]

The "underlying object of a pointer argument" is not something that's defined in LangRef. And if you mean something like getUnderlyingObject(), that has weird consequences for the semantics of memory allocation.

Maybe what you actually want is "any values stored through this pointer will not be read by the caller if this call unwinds", or something like that?

I like the name dead_on_unwind, though; I think the name suggests roughly the correct semantics.

[nikic]

Replace "underlying object" with "allocated object".

[nikic]

In D157499#4586505, @efriedma wrote:

The "underlying object of a pointer argument" is not something that's defined in LangRef. And if you mean something like getUnderlyingObject(), that has weird consequences for the semantics of memory allocation.

I've replaced "underlying object" with "allocated object". I don't think we define that term either, but we do use it to specify various things, including GEP semantics.

The motivation for talking about objects here is to avoid the need to reason about extents. The semantics could be coupled to dereferenceable, but that would make require additional checks for every use of the attribute for no clear benefit.

Maybe what you actually want is "any values stored through this pointer will not be read by the caller if this call unwinds", or something like that?

That would work, with the caveat that "any values stored" needs to include stores that don't exist in the original program. For call slot optimization we may be introducing additional stores, not removing them.

[efriedma]

I'm mostly concerned that depending on the size of the allocation leads to weird results if, for example, the caller decides to merge two allocas. For example, you have a function f(ptr dead_on_unwind, ptr), and the caller passes each argument a pointer to an alloca i32. If the caller merge those two allocas into {i32, i32}, you'd expect the semantics to stay consistent... but if the whole allocation is "dead", then merging affects stores through the second pointer. So using the "allocation" as the boundary isn't really well-defined.

[jdoerfert]

Maybe dead was a bad idea after all (mea culpa).
invalidated_on_unwind(<size>), would allow to deal with the merge case and express the semantic even more clearly, I guess?

[nikic]

In D157499#4589106, @efriedma wrote:

I'm mostly concerned that depending on the size of the allocation leads to weird results if, for example, the caller decides to merge two allocas. For example, you have a function f(ptr dead_on_unwind, ptr), and the caller passes each argument a pointer to an alloca i32. If the caller merge those two allocas into {i32, i32}, you'd expect the semantics to stay consistent... but if the whole allocation is "dead", then merging affects stores through the second pointer. So using the "allocation" as the boundary isn't really well-defined.

Okay, I can see the concern. In that case, I would suggest the following wording:

At a high level, this attribute indicates that the pointer argument is dead if the call unwinds, in the sense that the caller will not depend on the contents of the memory. Stores that would only be visible on the unwind path can be elided.

More precisely, the behavior is as-if the memory within the dereferenceable region of the pointer argument (if any), as well as any memory written through the pointer during the execution of the function, is overwritten with a poison value on unwind. The caller is allowed to access the affected memory, but all loads that are not preceded by a store will return poison.

This attribute cannot be applied to return values.

This should allow all the motivating optimizations without additional checks, while still allowing things like alloca merging or alloca reuse.

Does that sound reasonable?

[efriedma]

That seems close. Not sure about the "dereferenceable region" bit; the concept makes sense, it's just not really compatible with the current meaning of "dereferenceable". "dereferenceable" doesn't currently imply it's legal to write to a region in memory, only to read from it. I think you need some other way to indicate it's safe to speculatively write to the memory.

[jdoerfert]

I would remove:

The caller is allowed to access the affected memory, but all loads that are not preceded by a store will return poison.

And

dereferenceable region of the pointer argument

is super unclear, especially after you apply @efriedma's alloca merge. A size/type would make this clearer, we would not need to talk about "deref" at all, just that the region [ptr, ptr + size) is overwritten by poison on unwind.

[nikic]

In D157499#4589610, @efriedma wrote:

That seems close. Not sure about the "dereferenceable region" bit; the concept makes sense, it's just not really compatible with the current meaning of "dereferenceable". "dereferenceable" doesn't currently imply it's legal to write to a region in memory, only to read from it. I think you need some other way to indicate it's safe to speculatively write to the memory.

Yeah, you're right. This is an existing issue in call slot optimization, and it probably makes sense to address this first: https://llvm.godbolt.org/z/xa5P7TEed As written this transform would only be valid if the call is also willreturn.

I think I'll propose a writable or so attribute first, and then return back to this.

[jdoerfert]

In D157499#4589702, @nikic wrote:

I think I'll propose a writable or so attribute first, and then return back to this.

We have deref and maybe we want to add modifiers instead. We "have"/"need" deref(globally) anyway, and we can do deref(write) as well.

[nikic]

Writable attribute is up at D158081.

[nikic]

Rebase and adjust LangRef wording again. We now say that any memory written in the function will be poisoned on unwind. The connection to the writable attribute here is that it implies a write on entry to the function.

@efriedma Does this address your concerns?

[aeubanks]

seems reasonable to me

[nikic]

ping (mainly for @efriedma)

[asbirlea]

lgtm, but leaving up to @efriedma to stamp.

llvm/test/Transforms/DeadStoreElimination/simple.ll

516–517

Update comment?

[nikic]

Update comment.

[nikic]

I've migrated this patch to GitHub because Phabricator stopped sending emails: https://github.com/llvm/llvm-project/pull/74289

llvm/docs/LangRef.rst

``writable``
     or another attribute that implies the first ``N`` bytes of the pointer
     argument are dereferenceable.
 
     In that case, the attribute indicates that the first ``N`` bytes will be
     (non-atomically) loaded and stored back on entry to the function.
 
     This implies that it's possible to introduce spurious stores on entry to
     the function without introducing traps or data races. This does not
     necessarily hold throughout the whole function, as the pointer may escape
     to a different thread during the execution of the function. See also the
     :ref:`atomic optimization guide <Optimization outside atomic>`
 
     The "other attributes" that imply dereferenceability are
     ``dereferenceable_or_null`` (if the pointer is non-null) and the
     ``sret``, ``byval``, ``byref``, ``inalloca``, ``preallocated`` family of
     attributes. Note that not all of these combinations are useful, e.g.
     ``byval`` arguments are known to be writable even without this attribute.
 
     The ``writable`` attribute cannot be combined with ``readnone``,
     ``readonly`` or a ``memory`` attribute that does not contain
     ``argmem: write``.
 
+``dead_on_unwind``
+    At a high level, this attribute indicates that the pointer argument is dead
+    if the call unwinds, in the sense that the caller will not depend on the
+    contents of the memory. Stores that would only be visible on the unwind
+    path can be elided.
+
+    More precisely, the behavior is as-if any memory written through the
+    pointer during the execution of the function is overwritten with a poison
+    value on unwind. This includes memory written by the implicit write implied
+    by the ``writable`` attribute. The caller is allowed to access the affected
+    memory, but all loads that are not preceded by a store will return poison.
+
+    This attribute cannot be applied to return values.
+
 .. _gc:
 
 Garbage Collector Strategy Names
 --------------------------------
 
 Each function may specify a garbage collector strategy name, which is simply a
 string:
 

llvm/include/llvm/Bitcode/LLVMBitCodes.h

enum AttributeKindCodes {
   ATTR_KIND_PRESPLIT_COROUTINE = 83,
   ATTR_KIND_FNRETTHUNK_EXTERN = 84,
   ATTR_KIND_SKIP_PROFILE = 85,
   ATTR_KIND_MEMORY = 86,
   ATTR_KIND_NOFPCLASS = 87,
   ATTR_KIND_OPTIMIZE_FOR_DEBUGGING = 88,
   ATTR_KIND_WRITABLE = 89,
   ATTR_KIND_CORO_ONLY_DESTROY_WHEN_COMPLETE = 90,
+  ATTR_KIND_DEAD_ON_UNWIND = 91,
 };
 
 enum ComdatSelectionKindCodes {
   COMDAT_SELECTION_KIND_ANY = 1,
   COMDAT_SELECTION_KIND_EXACT_MATCH = 2,
   COMDAT_SELECTION_KIND_LARGEST = 3,
   COMDAT_SELECTION_KIND_NO_DUPLICATES = 4,
   COMDAT_SELECTION_KIND_SAME_SIZE = 5,

llvm/include/llvm/IR/Attributes.td

 def NoCapture : EnumAttr<"nocapture", [ParamAttr]>;
 
 /// Call cannot be duplicated.
 def NoDuplicate : EnumAttr<"noduplicate", [FnAttr]>;
 
 /// Function does not deallocate memory.
 def NoFree : EnumAttr<"nofree", [FnAttr, ParamAttr]>;
 
+/// Argument is dead if the call unwinds.
+def DeadOnUnwind : EnumAttr<"dead_on_unwind", [ParamAttr]>;
+
 /// Disable implicit floating point insts.
 def NoImplicitFloat : EnumAttr<"noimplicitfloat", [FnAttr]>;
 
 /// inline=never.
 def NoInline : EnumAttr<"noinline", [FnAttr]>;
 
 /// Function is called early and/or often, so lazy binding isn't worthwhile.
 def NonLazyBind : EnumAttr<"nonlazybind", [FnAttr]>;

llvm/lib/Analysis/AliasAnalysis.cpp

bool llvm::isNotVisibleOnUnwind(const Value *Object,
   RequiresNoCaptureBeforeUnwind = false;
 
   // Alloca goes out of scope on unwind.
   if (isa<AllocaInst>(Object))
     return true;
 
   // Byval goes out of scope on unwind.
   if (auto *A = dyn_cast<Argument>(Object))
-    return A->hasByValAttr();
+    return A->hasByValAttr() || A->hasAttribute(Attribute::DeadOnUnwind);
 
   // A noalias return is not accessible from any other code. If the pointer
   // does not escape prior to the unwind, then the caller cannot access the
   // memory either.
   if (isNoAliasCall(Object)) {
     RequiresNoCaptureBeforeUnwind = true;
     return true;
   }

llvm/lib/Bitcode/Reader/BitcodeReader.cpp

static Attribute::AttrKind getAttrFromCode(uint64_t Code) {
   case bitc::ATTR_KIND_HOT:
     return Attribute::Hot;
   case bitc::ATTR_KIND_PRESPLIT_COROUTINE:
     return Attribute::PresplitCoroutine;
   case bitc::ATTR_KIND_WRITABLE:
     return Attribute::Writable;
   case bitc::ATTR_KIND_CORO_ONLY_DESTROY_WHEN_COMPLETE:
     return Attribute::CoroDestroyOnlyWhenComplete;
+  case bitc::ATTR_KIND_DEAD_ON_UNWIND:
+    return Attribute::DeadOnUnwind;
   }
 }
 
 Error BitcodeReader::parseAlignmentValue(uint64_t Exponent,
                                          MaybeAlign &Alignment) {
   // Note: Alignment in bitcode files is incremented by 1, so that zero
   // can be used for default alignment.
   if (Exponent > Value::MaxAlignmentExponent + 1)

llvm/lib/Bitcode/Writer/BitcodeWriter.cpp

static uint64_t getAttrKindEncoding(Attribute::AttrKind Kind) {
   case Attribute::MustProgress:
     return bitc::ATTR_KIND_MUSTPROGRESS;
   case Attribute::PresplitCoroutine:
     return bitc::ATTR_KIND_PRESPLIT_COROUTINE;
   case Attribute::Writable:
     return bitc::ATTR_KIND_WRITABLE;
   case Attribute::CoroDestroyOnlyWhenComplete:
     return bitc::ATTR_KIND_CORO_ONLY_DESTROY_WHEN_COMPLETE;
+  case Attribute::DeadOnUnwind:
+    return bitc::ATTR_KIND_DEAD_ON_UNWIND;
   case Attribute::EndAttrKinds:
     llvm_unreachable("Can not encode end-attribute kinds marker.");
   case Attribute::None:
     llvm_unreachable("Can not encode none-attribute.");
   case Attribute::EmptyKey:
   case Attribute::TombstoneKey:
     llvm_unreachable("Trying to encode EmptyKey/TombstoneKey");
   }

llvm/lib/IR/Attributes.cpp

if (!Ty->isPointerTy()) {
     if (ASK & ASK_SAFE_TO_DROP)
       Incompatible.addAttribute(Attribute::NoAlias)
           .addAttribute(Attribute::NoCapture)
           .addAttribute(Attribute::NonNull)
           .addAttribute(Attribute::ReadNone)
           .addAttribute(Attribute::ReadOnly)
           .addAttribute(Attribute::Dereferenceable)
           .addAttribute(Attribute::DereferenceableOrNull)
-          .addAttribute(Attribute::Writable);
+          .addAttribute(Attribute::Writable)
+          .addAttribute(Attribute::DeadOnUnwind);
     if (ASK & ASK_UNSAFE_TO_DROP)
       Incompatible.addAttribute(Attribute::Nest)
           .addAttribute(Attribute::SwiftError)
           .addAttribute(Attribute::Preallocated)
           .addAttribute(Attribute::InAlloca)
           .addAttribute(Attribute::ByVal)
           .addAttribute(Attribute::StructRet)
           .addAttribute(Attribute::ByRef)

llvm/lib/Transforms/Utils/CodeExtractor.cpp

if (Attr.isStringAttribute()) {
       case Attribute::SwiftError:
       case Attribute::SwiftSelf:
       case Attribute::SwiftAsync:
       case Attribute::ZExt:
       case Attribute::ImmArg:
       case Attribute::ByRef:
       case Attribute::WriteOnly:
       case Attribute::Writable:
+      case Attribute::DeadOnUnwind:
       //  These are not really attributes.
       case Attribute::None:
       case Attribute::EndAttrKinds:
       case Attribute::EmptyKey:
       case Attribute::TombstoneKey:
         llvm_unreachable("Not a function attribute");
       }
 

llvm/test/Bitcode/attributes.ll

define void @f89() optdebug {
         ret void;
 }
 
 ; CHECK: define void @f90(ptr writable %p)
 define void @f90(ptr writable %p) {
   ret void
 }
 
+; CHECK: define void @f91(ptr dead_on_unwind %p)
+define void @f91(ptr dead_on_unwind %p) {
+  ret void
+}
+
 ; CHECK: attributes #0 = { noreturn }
 ; CHECK: attributes #1 = { nounwind }
 ; CHECK: attributes #2 = { memory(none) }
 ; CHECK: attributes #3 = { memory(read) }
 ; CHECK: attributes #4 = { noinline }
 ; CHECK: attributes #5 = { alwaysinline }
 ; CHECK: attributes #6 = { optsize }
 ; CHECK: attributes #7 = { ssp }

llvm/test/Transforms/DeadStoreElimination/simple.ll

 ; CHECK-NEXT:    call void @unknown_func()
 ; CHECK-NEXT:    store i32 0, ptr [[P]], align 4
 ; CHECK-NEXT:    ret void
 ;
   store i32 1, ptr %p
   call void @unknown_func()
   store i32 0, ptr %p
   ret void
 }
-; Same as previous case, but with an sret argument.
-; TODO: The first store could be eliminated if sret is not visible on unwind.
-define void @test34_sret(ptr noalias sret(i32) %p) {
-; CHECK-LABEL: @test34_sret(
-; CHECK-NEXT:    store i32 1, ptr [[P:%.*]], align 4
+
+; Same as previous case, but with a dead_on_unwind argument.
+define void @test34_dead_on_unwind(ptr noalias dead_on_unwind %p) {
+; CHECK-LABEL: @test34_dead_on_unwind(
 ; CHECK-NEXT:    call void @unknown_func()
-; CHECK-NEXT:    store i32 0, ptr [[P]], align 4
+; CHECK-NEXT:    store i32 0, ptr [[P:%.*]], align 4
 ; CHECK-NEXT:    ret void
 ;
   store i32 1, ptr %p
   call void @unknown_func()
   store i32 0, ptr %p
   ret void
 }
 

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

for.inc:
   %inc = add nuw nsw i32 %i.03, 1
   %exitcond = icmp eq i32 %inc, 10000
   br i1 %exitcond, label %for.cond.cleanup, label %for.body
 
 for.cond.cleanup:
   ret void
 }
 
-; TODO: sret could be specified to not be accessed on unwind either.
-define void @test_sret(ptr noalias sret(i32) %a, i1 zeroext %y) uwtable {
-; CHECK-LABEL: @test_sret(
+define void @test_dead_on_unwind(ptr noalias dead_on_unwind %a, i1 zeroext %y) uwtable {
+; CHECK-LABEL: @test_dead_on_unwind(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[A_PROMOTED:%.*]] = load i32, ptr [[A:%.*]], align 4
 ; CHECK-NEXT:    br label [[FOR_BODY:%.*]]
 ; CHECK:       for.body:
 ; CHECK-NEXT:    [[ADD1:%.*]] = phi i32 [ [[A_PROMOTED]], [[ENTRY:%.*]] ], [ [[ADD:%.*]], [[FOR_INC:%.*]] ]
 ; CHECK-NEXT:    [[I_03:%.*]] = phi i32 [ 0, [[ENTRY]] ], [ [[INC:%.*]], [[FOR_INC]] ]
 ; CHECK-NEXT:    [[ADD]] = add nsw i32 [[ADD1]], 1
-; CHECK-NEXT:    store i32 [[ADD]], ptr [[A]], align 4
 ; CHECK-NEXT:    br i1 [[Y:%.*]], label [[IF_THEN:%.*]], label [[FOR_INC]]
 ; CHECK:       if.then:
 ; CHECK-NEXT:    tail call void @f()
 ; CHECK-NEXT:    br label [[FOR_INC]]
 ; CHECK:       for.inc:
 ; CHECK-NEXT:    [[INC]] = add nuw nsw i32 [[I_03]], 1
 ; CHECK-NEXT:    [[EXITCOND:%.*]] = icmp eq i32 [[INC]], 10000
 ; CHECK-NEXT:    br i1 [[EXITCOND]], label [[FOR_COND_CLEANUP:%.*]], label [[FOR_BODY]]
 ; CHECK:       for.cond.cleanup:
+; CHECK-NEXT:    [[ADD_LCSSA:%.*]] = phi i32 [ [[ADD]], [[FOR_INC]] ]
+; CHECK-NEXT:    store i32 [[ADD_LCSSA]], ptr [[A]], align 4
 ; CHECK-NEXT:    ret void
 ;
 entry:
   br label %for.body
 
 for.body:
   %i.03 = phi i32 [ 0, %entry ], [ %inc, %for.inc ]
   %0 = load i32, ptr %a, align 4

llvm/test/Transforms/MemCpyOpt/callslot_throw.ll

 entry:
   %t = alloca i32, align 4
   call void @may_throw(ptr nonnull %t)
   %load = load i32, ptr %t, align 4
   store i32 %load, ptr %x, align 4
   ret void
 }
 
-; TODO: With updated semantics, sret could also be invisible on unwind.
-define void @test_sret(ptr nocapture noalias dereferenceable(4) sret(i32) %x) {
-; CHECK-LABEL: @test_sret(
+define void @test_dead_on_unwind(ptr nocapture noalias writable dead_on_unwind dereferenceable(4) %x) {
+; CHECK-LABEL: @test_dead_on_unwind(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[T:%.*]] = alloca i32, align 4
+; CHECK-NEXT:    call void @may_throw(ptr nonnull [[X:%.*]])
+; CHECK-NEXT:    ret void
+;
+entry:
+  %t = alloca i32, align 4
+  call void @may_throw(ptr nonnull %t)
+  %load = load i32, ptr %t, align 4
+  store i32 %load, ptr %x, align 4
+  ret void
+}
+
+define void @test_dead_on_unwind_missing_writable(ptr nocapture noalias dead_on_unwind dereferenceable(4) %x) {
+; CHECK-LABEL: @test_dead_on_unwind_missing_writable(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[T:%.*]] = alloca i32, align 4
 ; CHECK-NEXT:    call void @may_throw(ptr nonnull [[T]])
 ; CHECK-NEXT:    [[LOAD:%.*]] = load i32, ptr [[T]], align 4
 ; CHECK-NEXT:    store i32 [[LOAD]], ptr [[X:%.*]], align 4
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %t = alloca i32, align 4
   call void @may_throw(ptr nonnull %t)
   %load = load i32, ptr %t, align 4
   store i32 %load, ptr %x, align 4
   ret void
 }

llvm/test/Verifier/dead-on-unwind.ll

+; RUN: not llvm-as -disable-output %s 2>&1 | FileCheck %s
+
+; CHECK: Attribute 'dead_on_unwind' applied to incompatible type!
+; CHECK-NEXT: ptr @not_pointer
+define void @not_pointer(i32 dead_on_unwind %arg) {
+  ret void
+}