What's Dead & Exploded in Swift's exception stack?

Question

In the exception stack for runtime crashes, Swift often says arguments are Dead or Exploded. What does it mean, and does it matter for debugging purposes?

For example:

-> 0x100209cf0 <function signature specialization <Arg[0] = Exploded, Arg[1] = Exploded, Arg[2] = Dead, Arg[3] = Dead> of Swift._fatalErrorMessage (Swift.StaticString, Swift.StaticString, Swift.StaticString, Swift.UInt) -> ()+44>: brk    #0x1

Thanks.

Answer 1

What does it mean?

The Swift compiler marks function arguments for a number of reasons, mostly related to internal optimizations. For your question, we'll focus on the mangler, as that's what's contributing to your pretty stack trace, and the Node Printer. As of the time of this post, the function specialization mangler has 6 marks it can apply to an argument:

• Dead

  The argument is unused in the function body and can be removed in a dead argument elimination pass.

• Closure

  The argument is a closure and may require further mangling/demangling.

• Constant

  The argument is a constant.

• Owned to Guaranteed

  A caller-owned argument transfers ownership to the callee. The argument thus has a strong reference associated with it [the caller] and is guaranteed to live through the call, so the compiler allows the caller to elide the transfer and instead aggregate retains itself.

• SROA

  A Scalar Replacement of Aggregates pass should optimize this argument.

• In Out To Value

  The parameter was marked inout but the callee doesn't actually mutate it.

The AST Node Printer adds one more mark

• Exploded

  The value comes with an explosion schema that has been realized when the call was made.

For all intents and purposes we only care about Dead, Owned to Guaranteed, and Exploded.

The only one that may still seem mystifying is Exploded. An Explosion is an optimization construct the Swift compiler uses to determine a strategy to unpack values from small structs and enums into registers. Thus, when the Node Printer says a value is Exploded, what it means it has already unpacked the value into registers before the call.

does it matter for debugging purposes?

Nope.

Answer 2

Dead usually means that the value is no longer in memory

Not sure how this is going to help you unless you are really going to dive into Assembly debugging.

You might want to check out some online resources, i.e., how to use the debugger in Xcode to troubleshoot issues with your code.

Answer 3

Based on what I was able to find on Apple's developer library, I believe that when Swift says the argument is exploded, it has been expanded to show the bug until it shows all layers and parts of the argument. Swift does this to make it easier to find bugs that are nested between layers of an argument. I am not sure what dead means. This may be completely off base, but I figure that since you haven't gotten an answer in 6 days, I might as well try and clarify you're problem.