Add unwind rules for x0 (volatile) and x20 (non-voltile)

to trap() and break_to_debugger() for fun, and add
unwind instructions for the epilogue of trap().

When stopped in `break_to_debugger`,
```
  * frame #0: 0x00000001000003e8 a.out`break_to_debugger + 4
    frame swiftlang#1: 0x00000001000003d8 a.out`trap + 16
    frame swiftlang#2: 0x00000001000003c0 a.out`to_be_interrupted + 20
    frame swiftlang#3: 0x0000000100000398 a.out`main + 32
```

Normally we can't provide a volatile register (e.g. x0) up
the stack.  And we can provide a non-volatile register (e.g. x20)
up the stack.  I added an IsSame rule for trap() and break_to_debugger()
for x0, so it CAN be passed up the stack.  And I added an Undefined
rule for x20 to trap() so it CAN'T be provided up the stack.

If a user selects `to_be_interrupted` and does `register read`,
they'll get x0 and they won't get x20.  From `main`, they will not
get x0 or x20 (x0 because `to_be_interrupted` doesn't have an IsSame
rule).

Author: jasonmolenda

lldb/test/API/macosx/unwind-frameless-faulted/interrupt-and-trap-funcs.s

@@ -1,4 +1,6 @@
 #define DW_CFA_register 0x9
+#define ehframe_x0  0
+#define ehframe_x20  20
 #define ehframe_x22  22
 #define ehframe_x23  23
 #define ehframe_pc 32
@@ -7,9 +9,9 @@
 
 //--------------------------------------
 // to_be_interrupted() a frameless function that does a non-ABI
-// function call ("is interrupted/traps" simulated) to trap().
-// Before it branches to trap(), it puts its return address in
-// x23.  trap() knows to branch back to $x23 when it has finished.
+// function call to trap(), simulating an async signal/interrup/exception/fault.
+// Before it branches to trap(), put the return address in x23.
+// trap() knows to branch back to $x23 when it has finished.
 //--------------------------------------
   .globl  _to_be_interrupted
   .p2align  2
@@ -51,6 +53,15 @@ _trap:
   // The pc value when we were interrupted is in x23
   .cfi_escape DW_CFA_register, ehframe_pc, ehframe_x23
 
+  // For fun, mark x0 as unmodified so the caller can
+  // retrieve the value if it wants.
+  .cfi_same_value ehframe_x0
+
+  // Mark x20 as undefined.  This is a callee-preserved
+  // (non-volatile) register by the SysV AArch64 ABI, but
+  // it's be fun to see lldb not passing a value past this.
+  .cfi_undefined ehframe_x20
+
   // standard prologue save of fp & lr so we can call 
   // break_to_debugger()
   sub sp, sp, #32
@@ -63,7 +74,11 @@ _trap:
   bl _break_to_debugger
 
   ldp x29, x30, [sp, #16]
+  .cfi_same_value x29
+  .cfi_same_value x30
+  .cfi_def_cfa sp, 32
   add sp, sp, #32
+  .cfi_same_value sp
 
   // jump back to $x23 to resume execution of to_be_interrupted
   br x23
@@ -77,6 +92,10 @@ _trap:
 _break_to_debugger:                                  
   .cfi_startproc
 
+  // For fun, mark x0 as unmodified so the caller can
+  // retrieve the value if it wants.
+  .cfi_same_value ehframe_x0
+
   brk #0xf000   ;; __builtin_debugtrap aarch64 instruction
 
   ret