avr: add support for recover()

compiler/defer.go

@@ -31,7 +31,7 @@ func (b *builder) supportsRecover() bool {
  // proposal of WebAssembly:
  // https://github.com/WebAssembly/exception-handling
  return false
- case "avr", "riscv64", "xtensa":
+ case "riscv64", "xtensa":
  // TODO: add support for these architectures
  return false
  default:
@@ -71,7 +71,7 @@ func (b *builder) deferInitFunc() {
  // possibly broken by the C alloca function).
  // The frame pointer is _not_ saved, because it is marked as clobbered
  // in the setjmp-like inline assembly.
- deferFrameType := b.getLLVMType(b.program.ImportedPackage("internal/task").Members["DeferFrame"].Type())
+ deferFrameType := b.getLLVMRuntimeType("deferFrame")
  b.deferFrame = b.CreateAlloca(deferFrameType, "deferframe.buf")
  stackPointer := b.readStackPointer()
  b.createRuntimeCall("setupDeferFrame", []llvm.Value{b.deferFrame, stackPointer}, "")
@@ -116,8 +116,8 @@ func (b *builder) createInvokeCheckpoint() {
  // * The return value (eax, rax, r0, etc) is set to zero in the inline
  // assembly but set to an unspecified non-zero value when jumping using
  // a longjmp.
- asmType := llvm.FunctionType(b.uintptrType, []llvm.Type{b.deferFrame.Type()}, false)
  var asmString, constraints string
+ resultType := b.uintptrType
  switch b.archFamily() {
  case "i386":
  asmString = `
@@ -163,6 +163,21 @@ mov x0, #0
 `
  constraints = "={x0},{x1},~{x1},~{x2},~{x3},~{x4},~{x5},~{x6},~{x7},~{x8},~{x9},~{x10},~{x11},~{x12},~{x13},~{x14},~{x15},~{x16},~{x17},~{x18},~{x19},~{x20},~{x21},~{x22},~{x23},~{x24},~{x25},~{x26},~{x27},~{x28},~{fp},~{lr},~{q0},~{q1},~{q2},~{q3},~{q4},~{q5},~{q6},~{q7},~{q8},~{q9},~{q10},~{q11},~{q12},~{q13},~{q14},~{q15},~{q16},~{q17},~{q18},~{q19},~{q20},~{q21},~{q22},~{q23},~{q24},~{q25},~{q26},~{q27},~{q28},~{q29},~{q30},~{nzcv},~{ffr},~{vg},~{memory}"
  // TODO: SVE registers, which we don't use in TinyGo at the moment.
+ case "avr":
+ // Note: the Y register (R28:R29) is a fixed register and therefore
+ // needs to be saved manually. TODO: do this only once per function with
+ // a defer frame, not for every call.
+ resultType = b.ctx.Int8Type()
+ asmString = `
+ldi r24, pm_lo8(1f)
+ldi r25, pm_hi8(1f)
+std z+2, r24
+std z+3, r25
+std z+4, r28
+std z+5, r29
+ldi r24, 0
+1:`
+ constraints = "={r24},z,~{r0},~{r2},~{r3},~{r4},~{r5},~{r6},~{r7},~{r8},~{r9},~{r10},~{r11},~{r12},~{r13},~{r14},~{r15},~{r16},~{r17},~{r18},~{r19},~{r20},~{r21},~{r22},~{r23},~{r25},~{r26},~{r27}"
  case "riscv32":
  asmString = `
 la a2, 1f
@@ -174,10 +189,11 @@ li a0, 0
  // This case should have been handled by b.supportsRecover().
  b.addError(b.fn.Pos(), "unknown architecture for defer: "+b.archFamily())
  }
+ asmType := llvm.FunctionType(resultType, []llvm.Type{b.deferFrame.Type()}, false)
  asm := llvm.InlineAsm(asmType, asmString, constraints, false, false, 0, false)
  result := b.CreateCall(asm, []llvm.Value{b.deferFrame}, "setjmp")
  result.AddCallSiteAttribute(-1, b.ctx.CreateEnumAttribute(llvm.AttributeKindID("returns_twice"), 0))
- isZero := b.CreateICmp(llvm.IntEQ, result, llvm.ConstInt(b.uintptrType, 0, false), "setjmp.result")
+ isZero := b.CreateICmp(llvm.IntEQ, result, llvm.ConstInt(resultType, 0, false), "setjmp.result")
  continueBB := b.insertBasicBlock("")
  b.CreateCondBr(isZero, continueBB, b.landingpad)
  b.SetInsertPointAtEnd(continueBB)

compiler/testdata/channel.ll

@@ -5,12 +5,10 @@ target triple = "wasm32-unknown-wasi"
 
 %runtime.channel = type { i32, i32, i8, %runtime.channelBlockedList*, i32, i32, i32, i8* }
 %runtime.channelBlockedList = type { %runtime.channelBlockedList*, %"internal/task.Task"*, %runtime.chanSelectState*, { %runtime.channelBlockedList*, i32, i32 } }
-%"internal/task.Task" = type { %"internal/task.Task"*, i8*, i64, %"internal/task.gcData", %"internal/task.state", %"internal/task.DeferFrame"* }
+%"internal/task.Task" = type { %"internal/task.Task"*, i8*, i64, %"internal/task.gcData", %"internal/task.state", i8* }
 %"internal/task.gcData" = type { i8* }
 %"internal/task.state" = type { i32, i8*, %"internal/task.stackState", i1 }
 %"internal/task.stackState" = type { i32, i32 }
-%"internal/task.DeferFrame" = type { i8*, i8*, %"internal/task.DeferFrame"*, i1, %runtime._interface }
-%runtime._interface = type { i32, i8* }
 %runtime.chanSelectState = type { %runtime.channel*, i8* }
 
 declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*)

compiler/testdata/defer-cortex-m-qemu.ll

@@ -4,7 +4,7 @@ target datalayout = "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64"
 target triple = "thumbv7m-unknown-unknown-eabi"
 
 %runtime._defer = type { i32, %runtime._defer* }
-%"internal/task.DeferFrame" = type { i8*, i8*, %"internal/task.DeferFrame"*, i1, %runtime._interface }
+%runtime.deferFrame = type { i8*, i8*, [0 x i8*], %runtime.deferFrame*, i1, %runtime._interface }
 %runtime._interface = type { i32, i8* }
 
 declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*) #0
@@ -23,16 +23,16 @@ entry:
  %defer.alloca = alloca { i32, %runtime._defer* }, align 4
  %deferPtr = alloca %runtime._defer*, align 4
  store %runtime._defer* null, %runtime._defer** %deferPtr, align 4
- %deferframe.buf = alloca %"internal/task.DeferFrame", align 4
+ %deferframe.buf = alloca %runtime.deferFrame, align 4
  %0 = call i8* @llvm.stacksave()
- call void @runtime.setupDeferFrame(%"internal/task.DeferFrame"* nonnull %deferframe.buf, i8* %0, i8* undef) #3
+ call void @runtime.setupDeferFrame(%runtime.deferFrame* nonnull %deferframe.buf, i8* %0, i8* undef) #3
  %defer.alloca.repack = getelementptr inbounds { i32, %runtime._defer* }, { i32, %runtime._defer* }* %defer.alloca, i32 0, i32 0
  store i32 0, i32* %defer.alloca.repack, align 4
  %defer.alloca.repack16 = getelementptr inbounds { i32, %runtime._defer* }, { i32, %runtime._defer* }* %defer.alloca, i32 0, i32 1
  store %runtime._defer* null, %runtime._defer** %defer.alloca.repack16, align 4
  %1 = bitcast %runtime._defer** %deferPtr to { i32, %runtime._defer* }**
  store { i32, %runtime._defer* }* %defer.alloca, { i32, %runtime._defer* }** %1, align 4
- %setjmp = call i32 asm "\0Amovs r0, #0\0Amov r2, pc\0Astr r2, [r1, #4]", "={r0},{r1},~{r1},~{r2},~{r3},~{r4},~{r5},~{r6},~{r7},~{r8},~{r9},~{r10},~{r11},~{r12},~{lr},~{q0},~{q1},~{q2},~{q3},~{q4},~{q5},~{q6},~{q7},~{q8},~{q9},~{q10},~{q11},~{q12},~{q13},~{q14},~{q15},~{cpsr},~{memory}"(%"internal/task.DeferFrame"* nonnull %deferframe.buf) #4
+ %setjmp = call i32 asm "\0Amovs r0, #0\0Amov r2, pc\0Astr r2, [r1, #4]", "={r0},{r1},~{r1},~{r2},~{r3},~{r4},~{r5},~{r6},~{r7},~{r8},~{r9},~{r10},~{r11},~{r12},~{lr},~{q0},~{q1},~{q2},~{q3},~{q4},~{q5},~{q6},~{q7},~{q8},~{q9},~{q10},~{q11},~{q12},~{q13},~{q14},~{q15},~{cpsr},~{memory}"(%runtime.deferFrame* nonnull %deferframe.buf) #4
  %setjmp.result = icmp eq i32 %setjmp, 0
  br i1 %setjmp.result, label %2, label %lpad
 
@@ -56,7 +56,7 @@ rundefers.loop: ; preds = %rundefers.loophead
  ]
 
 rundefers.callback0: ; preds = %rundefers.loop
- %setjmp1 = call i32 asm "\0Amovs r0, #0\0Amov r2, pc\0Astr r2, [r1, #4]", "={r0},{r1},~{r1},~{r2},~{r3},~{r4},~{r5},~{r6},~{r7},~{r8},~{r9},~{r10},~{r11},~{r12},~{lr},~{q0},~{q1},~{q2},~{q3},~{q4},~{q5},~{q6},~{q7},~{q8},~{q9},~{q10},~{q11},~{q12},~{q13},~{q14},~{q15},~{cpsr},~{memory}"(%"internal/task.DeferFrame"* nonnull %deferframe.buf) #4
+ %setjmp1 = call i32 asm "\0Amovs r0, #0\0Amov r2, pc\0Astr r2, [r1, #4]", "={r0},{r1},~{r1},~{r2},~{r3},~{r4},~{r5},~{r6},~{r7},~{r8},~{r9},~{r10},~{r11},~{r12},~{lr},~{q0},~{q1},~{q2},~{q3},~{q4},~{q5},~{q6},~{q7},~{q8},~{q9},~{q10},~{q11},~{q12},~{q13},~{q14},~{q15},~{cpsr},~{memory}"(%runtime.deferFrame* nonnull %deferframe.buf) #4
  %setjmp.result2 = icmp eq i32 %setjmp1, 0
  br i1 %setjmp.result2, label %4, label %lpad
 
@@ -68,11 +68,11 @@ rundefers.default: ; preds = %rundefers.loop
  unreachable
 
 rundefers.end: ; preds = %rundefers.loophead
- call void @runtime.destroyDeferFrame(%"internal/task.DeferFrame"* nonnull %deferframe.buf, i8* undef) #3
+ call void @runtime.destroyDeferFrame(%runtime.deferFrame* nonnull %deferframe.buf, i8* undef) #3
  ret void
 
 recover: ; preds = %rundefers.end3
- call void @runtime.destroyDeferFrame(%"internal/task.DeferFrame"* nonnull %deferframe.buf, i8* undef) #3
+ call void @runtime.destroyDeferFrame(%runtime.deferFrame* nonnull %deferframe.buf, i8* undef) #3
  ret void
 
 lpad: ; preds = %rundefers.callback012, %rundefers.callback0, %entry
@@ -94,7 +94,7 @@ rundefers.loop5: ; preds = %rundefers.loophead6
  ]
 
 rundefers.callback012: ; preds = %rundefers.loop5
- %setjmp14 = call i32 asm "\0Amovs r0, #0\0Amov r2, pc\0Astr r2, [r1, #4]", "={r0},{r1},~{r1},~{r2},~{r3},~{r4},~{r5},~{r6},~{r7},~{r8},~{r9},~{r10},~{r11},~{r12},~{lr},~{q0},~{q1},~{q2},~{q3},~{q4},~{q5},~{q6},~{q7},~{q8},~{q9},~{q10},~{q11},~{q12},~{q13},~{q14},~{q15},~{cpsr},~{memory}"(%"internal/task.DeferFrame"* nonnull %deferframe.buf) #4
+ %setjmp14 = call i32 asm "\0Amovs r0, #0\0Amov r2, pc\0Astr r2, [r1, #4]", "={r0},{r1},~{r1},~{r2},~{r3},~{r4},~{r5},~{r6},~{r7},~{r8},~{r9},~{r10},~{r11},~{r12},~{lr},~{q0},~{q1},~{q2},~{q3},~{q4},~{q5},~{q6},~{q7},~{q8},~{q9},~{q10},~{q11},~{q12},~{q13},~{q14},~{q15},~{cpsr},~{memory}"(%runtime.deferFrame* nonnull %deferframe.buf) #4
  %setjmp.result15 = icmp eq i32 %setjmp14, 0
  br i1 %setjmp.result15, label %6, label %lpad
 
@@ -112,7 +112,7 @@ rundefers.end3: ; preds = %rundefers.loophead6
 ; Function Attrs: nofree nosync nounwind willreturn
 declare i8* @llvm.stacksave() #2
 
-declare void @runtime.setupDeferFrame(%"internal/task.DeferFrame"* dereferenceable_or_null(24), i8*, i8*) #0
+declare void @runtime.setupDeferFrame(%runtime.deferFrame* dereferenceable_or_null(24), i8*, i8*) #0
 
 ; Function Attrs: nounwind
 define hidden void @"main.deferSimple$1"(i8* %context) unnamed_addr #1 {
@@ -121,7 +121,7 @@ entry:
  ret void
 }
 
-declare void @runtime.destroyDeferFrame(%"internal/task.DeferFrame"* dereferenceable_or_null(24), i8*) #0
+declare void @runtime.destroyDeferFrame(%runtime.deferFrame* dereferenceable_or_null(24), i8*) #0
 
 declare void @runtime.printint32(i32, i8*) #0
 
@@ -132,9 +132,9 @@ entry:
  %defer.alloca = alloca { i32, %runtime._defer* }, align 4
  %deferPtr = alloca %runtime._defer*, align 4
  store %runtime._defer* null, %runtime._defer** %deferPtr, align 4
- %deferframe.buf = alloca %"internal/task.DeferFrame", align 4
+ %deferframe.buf = alloca %runtime.deferFrame, align 4
  %0 = call i8* @llvm.stacksave()
- call void @runtime.setupDeferFrame(%"internal/task.DeferFrame"* nonnull %deferframe.buf, i8* %0, i8* undef) #3
+ call void @runtime.setupDeferFrame(%runtime.deferFrame* nonnull %deferframe.buf, i8* %0, i8* undef) #3
  %defer.alloca.repack = getelementptr inbounds { i32, %runtime._defer* }, { i32, %runtime._defer* }* %defer.alloca, i32 0, i32 0
  store i32 0, i32* %defer.alloca.repack, align 4
  %defer.alloca.repack26 = getelementptr inbounds { i32, %runtime._defer* }, { i32, %runtime._defer* }* %defer.alloca, i32 0, i32 1
@@ -148,7 +148,7 @@ entry:
  store { i32, %runtime._defer* }* %defer.alloca, { i32, %runtime._defer* }** %2, align 4
  %3 = bitcast %runtime._defer** %deferPtr to { i32, %runtime._defer* }**
  store { i32, %runtime._defer* }* %defer.alloca2, { i32, %runtime._defer* }** %3, align 4
- %setjmp = call i32 asm "\0Amovs r0, #0\0Amov r2, pc\0Astr r2, [r1, #4]", "={r0},{r1},~{r1},~{r2},~{r3},~{r4},~{r5},~{r6},~{r7},~{r8},~{r9},~{r10},~{r11},~{r12},~{lr},~{q0},~{q1},~{q2},~{q3},~{q4},~{q5},~{q6},~{q7},~{q8},~{q9},~{q10},~{q11},~{q12},~{q13},~{q14},~{q15},~{cpsr},~{memory}"(%"internal/task.DeferFrame"* nonnull %deferframe.buf) #4
+ %setjmp = call i32 asm "\0Amovs r0, #0\0Amov r2, pc\0Astr r2, [r1, #4]", "={r0},{r1},~{r1},~{r2},~{r3},~{r4},~{r5},~{r6},~{r7},~{r8},~{r9},~{r10},~{r11},~{r12},~{lr},~{q0},~{q1},~{q2},~{q3},~{q4},~{q5},~{q6},~{q7},~{q8},~{q9},~{q10},~{q11},~{q12},~{q13},~{q14},~{q15},~{cpsr},~{memory}"(%runtime.deferFrame* nonnull %deferframe.buf) #4
  %setjmp.result = icmp eq i32 %setjmp, 0
  br i1 %setjmp.result, label %4, label %lpad
 
@@ -173,7 +173,7 @@ rundefers.loop: ; preds = %rundefers.loophead
  ]
 
 rundefers.callback0: ; preds = %rundefers.loop
- %setjmp4 = call i32 asm "\0Amovs r0, #0\0Amov r2, pc\0Astr r2, [r1, #4]", "={r0},{r1},~{r1},~{r2},~{r3},~{r4},~{r5},~{r6},~{r7},~{r8},~{r9},~{r10},~{r11},~{r12},~{lr},~{q0},~{q1},~{q2},~{q3},~{q4},~{q5},~{q6},~{q7},~{q8},~{q9},~{q10},~{q11},~{q12},~{q13},~{q14},~{q15},~{cpsr},~{memory}"(%"internal/task.DeferFrame"* nonnull %deferframe.buf) #4
+ %setjmp4 = call i32 asm "\0Amovs r0, #0\0Amov r2, pc\0Astr r2, [r1, #4]", "={r0},{r1},~{r1},~{r2},~{r3},~{r4},~{r5},~{r6},~{r7},~{r8},~{r9},~{r10},~{r11},~{r12},~{lr},~{q0},~{q1},~{q2},~{q3},~{q4},~{q5},~{q6},~{q7},~{q8},~{q9},~{q10},~{q11},~{q12},~{q13},~{q14},~{q15},~{cpsr},~{memory}"(%runtime.deferFrame* nonnull %deferframe.buf) #4
  %setjmp.result5 = icmp eq i32 %setjmp4, 0
  br i1 %setjmp.result5, label %6, label %lpad
 
@@ -182,7 +182,7 @@ rundefers.callback0: ; preds = %rundefers.loop
  br label %rundefers.loophead
 
 rundefers.callback1: ; preds = %rundefers.loop
- %setjmp7 = call i32 asm "\0Amovs r0, #0\0Amov r2, pc\0Astr r2, [r1, #4]", "={r0},{r1},~{r1},~{r2},~{r3},~{r4},~{r5},~{r6},~{r7},~{r8},~{r9},~{r10},~{r11},~{r12},~{lr},~{q0},~{q1},~{q2},~{q3},~{q4},~{q5},~{q6},~{q7},~{q8},~{q9},~{q10},~{q11},~{q12},~{q13},~{q14},~{q15},~{cpsr},~{memory}"(%"internal/task.DeferFrame"* nonnull %deferframe.buf) #4
+ %setjmp7 = call i32 asm "\0Amovs r0, #0\0Amov r2, pc\0Astr r2, [r1, #4]", "={r0},{r1},~{r1},~{r2},~{r3},~{r4},~{r5},~{r6},~{r7},~{r8},~{r9},~{r10},~{r11},~{r12},~{lr},~{q0},~{q1},~{q2},~{q3},~{q4},~{q5},~{q6},~{q7},~{q8},~{q9},~{q10},~{q11},~{q12},~{q13},~{q14},~{q15},~{cpsr},~{memory}"(%runtime.deferFrame* nonnull %deferframe.buf) #4
  %setjmp.result8 = icmp eq i32 %setjmp7, 0
  br i1 %setjmp.result8, label %7, label %lpad
 
@@ -194,11 +194,11 @@ rundefers.default: ; preds = %rundefers.loop
  unreachable
 
 rundefers.end: ; preds = %rundefers.loophead
- call void @runtime.destroyDeferFrame(%"internal/task.DeferFrame"* nonnull %deferframe.buf, i8* undef) #3
+ call void @runtime.destroyDeferFrame(%runtime.deferFrame* nonnull %deferframe.buf, i8* undef) #3
  ret void
 
 recover: ; preds = %rundefers.end9
- call void @runtime.destroyDeferFrame(%"internal/task.DeferFrame"* nonnull %deferframe.buf, i8* undef) #3
+ call void @runtime.destroyDeferFrame(%runtime.deferFrame* nonnull %deferframe.buf, i8* undef) #3
  ret void
 
 lpad: ; preds = %rundefers.callback122, %rundefers.callback018, %rundefers.callback1, %rundefers.callback0, %entry
@@ -221,7 +221,7 @@ rundefers.loop11: ; preds = %rundefers.loophead1
  ]
 
 rundefers.callback018: ; preds = %rundefers.loop11
- %setjmp20 = call i32 asm "\0Amovs r0, #0\0Amov r2, pc\0Astr r2, [r1, #4]", "={r0},{r1},~{r1},~{r2},~{r3},~{r4},~{r5},~{r6},~{r7},~{r8},~{r9},~{r10},~{r11},~{r12},~{lr},~{q0},~{q1},~{q2},~{q3},~{q4},~{q5},~{q6},~{q7},~{q8},~{q9},~{q10},~{q11},~{q12},~{q13},~{q14},~{q15},~{cpsr},~{memory}"(%"internal/task.DeferFrame"* nonnull %deferframe.buf) #4
+ %setjmp20 = call i32 asm "\0Amovs r0, #0\0Amov r2, pc\0Astr r2, [r1, #4]", "={r0},{r1},~{r1},~{r2},~{r3},~{r4},~{r5},~{r6},~{r7},~{r8},~{r9},~{r10},~{r11},~{r12},~{lr},~{q0},~{q1},~{q2},~{q3},~{q4},~{q5},~{q6},~{q7},~{q8},~{q9},~{q10},~{q11},~{q12},~{q13},~{q14},~{q15},~{cpsr},~{memory}"(%runtime.deferFrame* nonnull %deferframe.buf) #4
  %setjmp.result21 = icmp eq i32 %setjmp20, 0
  br i1 %setjmp.result21, label %9, label %lpad
 
@@ -230,7 +230,7 @@ rundefers.callback018: ; preds = %rundefers.loop11
  br label %rundefers.loophead12
 
 rundefers.callback122: ; preds = %rundefers.loop11
- %setjmp24 = call i32 asm "\0Amovs r0, #0\0Amov r2, pc\0Astr r2, [r1, #4]", "={r0},{r1},~{r1},~{r2},~{r3},~{r4},~{r5},~{r6},~{r7},~{r8},~{r9},~{r10},~{r11},~{r12},~{lr},~{q0},~{q1},~{q2},~{q3},~{q4},~{q5},~{q6},~{q7},~{q8},~{q9},~{q10},~{q11},~{q12},~{q13},~{q14},~{q15},~{cpsr},~{memory}"(%"internal/task.DeferFrame"* nonnull %deferframe.buf) #4
+ %setjmp24 = call i32 asm "\0Amovs r0, #0\0Amov r2, pc\0Astr r2, [r1, #4]", "={r0},{r1},~{r1},~{r2},~{r3},~{r4},~{r5},~{r6},~{r7},~{r8},~{r9},~{r10},~{r11},~{r12},~{lr},~{q0},~{q1},~{q2},~{q3},~{q4},~{q5},~{q6},~{q7},~{q8},~{q9},~{q10},~{q11},~{q12},~{q13},~{q14},~{q15},~{cpsr},~{memory}"(%runtime.deferFrame* nonnull %deferframe.buf) #4
  %setjmp.result25 = icmp eq i32 %setjmp24, 0
  br i1 %setjmp.result25, label %10, label %lpad
 

compiler/testdata/goroutine-cortex-m-qemu-tasks.ll

@@ -5,11 +5,9 @@ target triple = "thumbv7m-unknown-unknown-eabi"
 
 %runtime.channel = type { i32, i32, i8, %runtime.channelBlockedList*, i32, i32, i32, i8* }
 %runtime.channelBlockedList = type { %runtime.channelBlockedList*, %"internal/task.Task"*, %runtime.chanSelectState*, { %runtime.channelBlockedList*, i32, i32 } }
-%"internal/task.Task" = type { %"internal/task.Task"*, i8*, i64, %"internal/task.gcData", %"internal/task.state", %"internal/task.DeferFrame"* }
+%"internal/task.Task" = type { %"internal/task.Task"*, i8*, i64, %"internal/task.gcData", %"internal/task.state", i8* }
 %"internal/task.gcData" = type {}
 %"internal/task.state" = type { i32, i32* }
-%"internal/task.DeferFrame" = type { i8*, i8*, %"internal/task.DeferFrame"*, i1, %runtime._interface }
-%runtime._interface = type { i32, i8* }
 %runtime.chanSelectState = type { %runtime.channel*, i8* }
 
 @"main$string" = internal unnamed_addr constant [4 x i8] c"test", align 1

compiler/testdata/goroutine-wasm-asyncify.ll

@@ -5,12 +5,10 @@ target triple = "wasm32-unknown-wasi"
 
 %runtime.channel = type { i32, i32, i8, %runtime.channelBlockedList*, i32, i32, i32, i8* }
 %runtime.channelBlockedList = type { %runtime.channelBlockedList*, %"internal/task.Task"*, %runtime.chanSelectState*, { %runtime.channelBlockedList*, i32, i32 } }
-%"internal/task.Task" = type { %"internal/task.Task"*, i8*, i64, %"internal/task.gcData", %"internal/task.state", %"internal/task.DeferFrame"* }
+%"internal/task.Task" = type { %"internal/task.Task"*, i8*, i64, %"internal/task.gcData", %"internal/task.state", i8* }
 %"internal/task.gcData" = type { i8* }
 %"internal/task.state" = type { i32, i8*, %"internal/task.stackState", i1 }
 %"internal/task.stackState" = type { i32, i32 }
-%"internal/task.DeferFrame" = type { i8*, i8*, %"internal/task.DeferFrame"*, i1, %runtime._interface }
-%runtime._interface = type { i32, i8* }
 %runtime.chanSelectState = type { %runtime.channel*, i8* }
 
 @"main$string" = internal unnamed_addr constant [4 x i8] c"test", align 1

main_test.go

@@ -349,6 +349,7 @@ func runTestWithConfig(name string, t *testing.T, options compileopts.Options, c
  actual = bytes.Replace(actual, []byte{0x1b, '[', '3', '2', 'm'}, nil, -1)
  actual = bytes.Replace(actual, []byte{0x1b, '[', '0', 'm'}, nil, -1)
  actual = bytes.Replace(actual, []byte{'.', '.', '\n'}, []byte{'\n'}, -1)
+ actual = bytes.Replace(actual, []byte{'\n', '.', '\n'}, []byte{'\n', '\n'}, -1)
  }
  if name == "testing.go" {
  // Strip actual time.

src/internal/task/task.go

@@ -23,19 +23,7 @@ type Task struct {
 
  // DeferFrame stores a pointer to the (stack allocated) defer frame of the
  // goroutine that is used for the recover builtin.
- DeferFrame *DeferFrame
-}
-
-// DeferFrame is a stack allocated object that stores information for the
-// current "defer frame", which is used in functions that use the `defer`
-// keyword.
-// The compiler knows the JumpPC struct offset.
-type DeferFrame struct {
- JumpSP unsafe.Pointer // stack pointer to return to
- JumpPC unsafe.Pointer // pc to return to
- Previous *DeferFrame // previous recover buffer pointer
- Panicking bool // true iff this defer frame is panicking
- PanicValue interface{} // panic value, might be nil for panic(nil) for example
+ DeferFrame unsafe.Pointer
 }
 
 // getGoroutineStackSize is a compiler intrinsic that returns the stack size for