diff --git a/src/cmd/compile/internal/ssa/llvmdata.go b/src/cmd/compile/internal/ssa/llvmdata.go index 04a7881e24ea3b..266a1562821e32 100644 --- a/src/cmd/compile/internal/ssa/llvmdata.go +++ b/src/cmd/compile/internal/ssa/llvmdata.go @@ -520,6 +520,24 @@ func setGoObjFunctionFlags(fn llvm.Value, s *obj.LSym) { })) } +// FuncIDWrapper is part of recover's semantic stack walk: a deferred-call +// wrapper must not count as an extra frame between gopanic and recover. Carry +// both FuncID and FuncFlag into LLVM so the GoObj writer can reproduce the +// native compiler's FuncInfo record. +func setGoObjFunctionInfo(fn llvm.Value, s *obj.LSym) { + info := s.Func() + if info == nil { + base.Fatalf("missing Go function info for %s", s.Name) + } + if info.FuncID == 0 && info.FuncFlag == 0 { + return + } + fn.SetGlobalMetadata(GlobalCtxt.MDKindID("goobj.func.info"), GlobalCtxt.MDNode([]llvm.Metadata{ + llvm.ConstInt(GlobalCtxt.Int8Type(), uint64(info.FuncID), false).ConstantAsMetadata(), + llvm.ConstInt(GlobalCtxt.Int8Type(), uint64(info.FuncFlag), false).ConstantAsMetadata(), + })) +} + // LLVM can express the address relationship but not GoObj's 32-bit section // offsets. Record the object-format-specific relocation type explicitly; // weakness remains orthogonal in !goobj.weak_relocs. diff --git a/src/cmd/compile/internal/ssa/ssa2llvm.go b/src/cmd/compile/internal/ssa/ssa2llvm.go index 3928455157f9b4..33705585d697e6 100644 --- a/src/cmd/compile/internal/ssa/ssa2llvm.go +++ b/src/cmd/compile/internal/ssa/ssa2llvm.go @@ -61,6 +61,7 @@ const goGCLeafFunctionAttr = "gc-leaf-function" const goStackGrowthStatepointAttr = "go-stack-growth-statepoint" const goAsyncUnsafeAttr = "go-async-unsafe" const goWriteBarrierIntrinsic = "llvm.go.gc.write.barrier" +const goDeferEdgeIntrinsic = "llvm.go.defer.edge" const goSourceAddressTakenMD = "goallc.source_addrtaken" const llvmFramePointerAttr = "frame-pointer" const llvmFramePointerNonLeaf = "non-leaf" @@ -262,6 +263,14 @@ func getOrInsertLLVMIntrinsic(name string, typ llvm.Type) llvm.Value { return fn } +func getLLVMIntrinsicDeclaration(name string) llvm.Value { + id := llvm.LookupIntrinsicID(name) + if id == 0 { + base.Fatalf("unknown LLVM intrinsic %s", name) + } + return llvm.GetIntrinsicDeclaration(CurrentModule, id, nil) +} + func (lfc *LLVMFuncContext) llvmLifetimeStart(slot llvmStackSlot) { sig := llvm.FunctionType( GlobalCtxt.VoidType(), @@ -1194,13 +1203,20 @@ func llvmStaticCallSignature(v *Value, aux *AuxCall, sig llvmFuncSignature) llvm return sig } wantArgs := int64(0) + pointerArgs := int64(0) switch aux.Fn { - case ir.Syms.Newproc: + case ir.Syms.Newproc, ir.Syms.Deferproc, ir.Syms.DeferprocStack: wantArgs = 1 + pointerArgs = 1 + case ir.Syms.Deferprocat: + wantArgs = 2 + pointerArgs = 1 case ir.Syms.WBZero: wantArgs = 2 + pointerArgs = wantArgs case ir.Syms.WBMove: wantArgs = 3 + pointerArgs = wantArgs default: return sig } @@ -1210,16 +1226,27 @@ func llvmStaticCallSignature(v *Value, aux *AuxCall, sig llvmFuncSignature) llvm if aux.NArgs() != wantArgs || aux.NResults() != 0 { v.Fatalf("%s has unexpected raw call signature: %d arguments, %d results", aux.Fn.Name, aux.NArgs(), aux.NResults()) } - if aux.Fn == ir.Syms.Newproc && (len(v.Args) != 2 || v.Args[0].Type == nil || !v.Args[0].Type.IsPtrShaped()) { - v.Fatalf("runtime.newproc argument is not pointer-shaped") - } - for i := int64(0); i < aux.NArgs(); i++ { + for i := int64(0); i < pointerArgs; i++ { + if int(i) >= len(v.Args)-1 || v.Args[i].Type == nil { + v.Fatalf("argument %d to %s is not pointer-shaped", i, aux.Fn.Name) + } + pointerShaped := v.Args[i].Type.IsPtrShaped() + // Write-barrier calls carry the type descriptor as Addr in + // Go SSA because AuxCall uses uintptr for its physical ABI assignment. + // OpAddr still lowers directly to an LLVM pointer, just like the + // pointer-shaped destination and source operands. + writeBarrierTypeAddr := i == 0 && + (aux.Fn == ir.Syms.WBZero || aux.Fn == ir.Syms.WBMove) && + v.Args[i].Op == OpAddr && v.Args[i].Type.IsUintptr() + if !pointerShaped && !writeBarrierTypeAddr { + v.Fatalf("argument %d to %s is not pointer-shaped", i, aux.Fn.Name) + } if typ := aux.TypeOfArg(i); typ == nil || !typ.IsUintptr() { v.Fatalf("argument %d to %s is not raw uintptr", i, aux.Fn.Name) } } params := append([]llvm.Type(nil), sig.Type.ParamTypes()...) - for i := range params { + for i := int64(0); i < pointerArgs; i++ { params[i] = GlobalCtxt.PointerType(0) } sig.Type = llvm.FunctionType(sig.ReturnType, params, false) @@ -2027,6 +2054,17 @@ func (lfc *LLVMFuncContext) CompileBlock(BB *Block, values []*Value) { case BlockIf: cond := lfc.llvmCondition(lfc.GenLV(BB.Controls[0]), BB.String()+".cond") lfc.b.CreateCondBr(cond, lfc.BBs[BB.Succs[0].Block().ID], lfc.BBs[BB.Succs[1].Block().ID]) + case BlockDefer: + if len(BB.Succs) != 2 || BB.NumControls() != 1 || !BB.Controls[0].Type.IsMemory() { + BB.Func.fe.Fatalf(BB.Pos, "invalid LLVM defer block %s", BB) + } + deferEdge := getLLVMIntrinsicDeclaration(goDeferEdgeIntrinsic) + lfc.b.CreateCallBr( + deferEdge.GlobalValueType(), deferEdge, nil, + lfc.BBs[BB.Succs[0].Block().ID], + []llvm.BasicBlock{lfc.BBs[BB.Succs[1].Block().ID]}, + "", + ) case BlockPlain: lfc.b.CreateBr(lfc.BBs[BB.Succs[0].Block().ID]) case BlockExit: @@ -2132,6 +2170,7 @@ func LLVMCompile(f *Func) { } FCtxt.LF.SetGC(goGCStrategy) setGoObjFunctionFlags(FCtxt.LF, f.OwnAux.Fn) + setGoObjFunctionInfo(FCtxt.LF, f.OwnAux.Fn) inParams := f.OwnAux.ABIInfo().InParams() if got, want := len(inParams), int(f.OwnAux.NArgs()); got != want { f.fe.Fatalf(f.Entry.Pos, "LLVM parameter metadata count %d does not match signature count %d for %s", got, want, f.Name) diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go index 7d523e56928d79..fc8567c4bfe856 100644 --- a/src/cmd/compile/internal/ssagen/ssa.go +++ b/src/cmd/compile/internal/ssagen/ssa.go @@ -395,6 +395,11 @@ func buildssa(fn *ir.Func, worker int, isPgoHot bool) *ssa.Func { s.hasOpenDefers = base.Flag.N == 0 && s.hasdefer && !s.curfn.OpenCodedDeferDisallowed() switch { + case base.Flag.EnableLLVM: + // The first LLVM defer implementation models the runtime registration + // calls and their recovery edges directly. Open-coded defers additionally + // require bitmap and FUNCDATA lowering, so keep them on the classic path. + s.hasOpenDefers = false case base.Debug.NoOpenDefer != 0: s.hasOpenDefers = false case s.hasOpenDefers && (base.Ctxt.Flag_shared || base.Ctxt.Flag_dynlink) && base.Ctxt.Arch.Name == "386": diff --git a/src/cmd/llvmplugin/CMakeLists.txt b/src/cmd/llvmplugin/CMakeLists.txt index 36e3f1efd64f11..fd7ffcbf568f3f 100644 --- a/src/cmd/llvmplugin/CMakeLists.txt +++ b/src/cmd/llvmplugin/CMakeLists.txt @@ -82,6 +82,34 @@ if(BUILD_TESTING) "slot.relocated" ) + add_test( + NAME GoALLCStatepoints.DeferEdge + COMMAND + "${GOALLC_LLC_EXECUTABLE}" + "-load-pass-plugin=$" + -goallc-pass-plugin-emit-ir + -filetype=null + -o - + "${CMAKE_CURRENT_SOURCE_DIR}/testdata/defer-edge.ll" + ) + set_tests_properties(GoALLCStatepoints.DeferEdge PROPERTIES + PASS_REGULAR_EXPRESSION + "callbr void @llvm.go.defer.edge" + FAIL_REGULAR_EXPRESSION + "GoALLC statepoints do not yet support invoke or callbr;call goabiinternal void @runtime.deferproc" + ) + + add_test( + NAME GoALLCStatepoints.DeferEdgeGoObj + COMMAND + "${GOALLC_LLC_EXECUTABLE}" + "-load-pass-plugin=$" + -verify-machineinstrs + -filetype=obj + -o "${CMAKE_CURRENT_BINARY_DIR}/defer-edge.goobj" + "${CMAKE_CURRENT_SOURCE_DIR}/testdata/defer-edge.ll" + ) + add_test( NAME GoALLCStatepoints.FrontendMarkersPreserved COMMAND @@ -282,6 +310,18 @@ if(BUILD_TESTING) "GOALLC_OBJVIEW_EXECUTABLE does not exist: " "${GOALLC_OBJVIEW_EXECUTABLE}") endif() + add_test( + NAME GoALLCStatepoints.DeferEdgeObjView + COMMAND + "${Python3_EXECUTABLE}" + "${CMAKE_CURRENT_SOURCE_DIR}/testdata/check-defer-edge.py" + --objview "${GOALLC_OBJVIEW_EXECUTABLE}" + --object "${CMAKE_CURRENT_BINARY_DIR}/defer-edge.goobj" + ) + set_tests_properties(GoALLCStatepoints.DeferEdgeObjView PROPERTIES + DEPENDS GoALLCStatepoints.DeferEdgeGoObj + ) + add_test( NAME GoALLCStatepoints.MultipleCallsObjView COMMAND diff --git a/src/cmd/llvmplugin/testdata/check-defer-edge.py b/src/cmd/llvmplugin/testdata/check-defer-edge.py new file mode 100644 index 00000000000000..2fb6c5444c2f22 --- /dev/null +++ b/src/cmd/llvmplugin/testdata/check-defer-edge.py @@ -0,0 +1,99 @@ +#!/usr/bin/env python3 + +import argparse +import json +import subprocess +import sys + + +FUNCTION = "defer_edge" +WRAPPER = "defer_wrapper" + + +def fail(message): + raise RuntimeError(message) + + +def only(items, predicate, description): + matches = [item for item in items if predicate(item)] + if len(matches) != 1: + fail(f"found {len(matches)} {description}, want 1") + return matches[0] + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--objview", required=True) + parser.add_argument("--object", required=True) + args = parser.parse_args() + + result = subprocess.run( + [args.objview, "-format=json", args.object], + check=True, + stdout=subprocess.PIPE, + text=True, + ) + document = json.loads(result.stdout) + objects = [ + member["go_object"] + for member in document["members"] + if member.get("go_object") is not None + ] + obj = only(objects, lambda item: True, "Go objects") + function = only( + obj["symbols"], + lambda item: item["name"] == FUNCTION, + f"{FUNCTION} symbols", + ) + metadata = function.get("function") + if metadata is None: + fail(f"{FUNCTION} has no function metadata") + + wrapper = only( + obj["symbols"], + lambda item: item["name"] == WRAPPER, + f"{WRAPPER} symbols", + ) + wrapper_metadata = wrapper.get("function") + if wrapper_metadata is None or wrapper_metadata.get("info") is None: + fail(f"{WRAPPER} has no function info") + wrapper_info = wrapper_metadata["info"] + if wrapper_info["func_id"] != 23 or wrapper_info["func_flags"] != 0: + fail(f"{WRAPPER} lost GoObj wrapper identity: {wrapper_info}") + + references = {item["index"]: item["name"] for item in obj["references"]} + + def target_name(relocation): + target = relocation["target"] + if "name" in target: + return target["name"] + return references.get(target["sym_index"]) + + deferreturn = only( + function["relocations"], + lambda item: item["type"] == "R_CALL" + and target_name(item) == "runtime.deferreturn", + "direct runtime.deferreturn relocations", + ) + query = only( + metadata["stack_map_queries"], + lambda item: item["call_offset"] == deferreturn["offset"], + "runtime.deferreturn stack-map queries", + ) + if query["relocation_type"] != "R_CALL": + fail(f"deferreturn is not represented as a direct call: {query}") + if query["stack_map_index"] < 0: + fail(f"deferreturn has no valid GC stack map: {query}") + + print( + f"{FUNCTION}: runtime.deferreturn R_CALL at {deferreturn['offset']}, " + f"stack map {query['stack_map_index']}; {WRAPPER}: FuncID 23, flags 0" + ) + + +if __name__ == "__main__": + try: + main() + except (KeyError, RuntimeError, subprocess.CalledProcessError, json.JSONDecodeError) as error: + print(f"check-defer-edge: {error}", file=sys.stderr) + sys.exit(1) diff --git a/src/cmd/llvmplugin/testdata/defer-edge.ll b/src/cmd/llvmplugin/testdata/defer-edge.ll new file mode 100644 index 00000000000000..2b2ab5e30d09ac --- /dev/null +++ b/src/cmd/llvmplugin/testdata/defer-edge.ll @@ -0,0 +1,27 @@ +target triple = "x86_64-unknown-linux-goobj" + +declare goabiinternal void @runtime.deferproc() +declare goabiinternal void @runtime.deferreturn() +declare void @llvm.go.defer.edge() + +define goabiinternal void @defer_edge() #0 gc "goallc" { +entry: + call goabiinternal void @runtime.deferproc() + callbr void @llvm.go.defer.edge() to label %normal [label %recover] + +normal: + ret void + +recover: + call goabiinternal void @runtime.deferreturn() + ret void +} + +define goabiinternal void @defer_wrapper() !goobj.func.info !0 { +entry: + ret void +} + +attributes #0 = { "go-stack-growth-statepoint" } + +!0 = !{i8 23, i8 0} diff --git a/src/cmd/vendor/github.com/goallc/go-llvm/ir.go b/src/cmd/vendor/github.com/goallc/go-llvm/ir.go index d9f786b290ab9a..be27442bbf2781 100644 --- a/src/cmd/vendor/github.com/goallc/go-llvm/ir.go +++ b/src/cmd/vendor/github.com/goallc/go-llvm/ir.go @@ -118,6 +118,24 @@ func llvmValueRefs(values []Value) (*C.LLVMValueRef, C.unsigned) { return pt, ptlen } +func llvmTypeRefs(types []Type) (*C.LLVMTypeRef, C.size_t) { + var pt *C.LLVMTypeRef + ptlen := C.size_t(len(types)) + if ptlen > 0 { + pt = llvmTypeRefPtr(&types[0]) + } + return pt, ptlen +} + +func llvmBasicBlockRefs(blocks []BasicBlock) (*C.LLVMBasicBlockRef, C.unsigned) { + var pt *C.LLVMBasicBlockRef + ptlen := C.unsigned(len(blocks)) + if ptlen > 0 { + pt = llvmBasicBlockRefPtr(&blocks[0]) + } + return pt, ptlen +} + func llvmMetadataRefs(mds []Metadata) (*C.LLVMMetadataRef, C.unsigned) { var pt *C.LLVMMetadataRef ptlen := C.unsigned(len(mds)) @@ -1075,6 +1093,19 @@ func NextFunction(v Value) (rv Value) { rv.C = C.LLVMGetNextFunction(v.C); func PrevFunction(v Value) (rv Value) { rv.C = C.LLVMGetPreviousFunction(v.C); return } func (v Value) EraseFromParentAsFunction() { C.LLVMDeleteFunction(v.C) } func (v Value) IntrinsicID() int { return int(C.LLVMGetIntrinsicID(v.C)) } + +func LookupIntrinsicID(name string) uint { + cname := C.CString(name) + defer C.free(unsafe.Pointer(cname)) + return uint(C.LLVMLookupIntrinsicID(cname, C.size_t(len(name)))) +} + +func GetIntrinsicDeclaration(m Module, id uint, overloadTypes []Type) (v Value) { + types, ntypes := llvmTypeRefs(overloadTypes) + v.C = C.LLVMGetIntrinsicDeclaration(m.C, C.unsigned(id), types, ntypes) + return +} + func (v Value) FunctionCallConv() CallConv { return CallConv(C.LLVMCallConv(C.LLVMGetFunctionCallConv(v.C))) } @@ -1371,6 +1402,15 @@ func (b Builder) CreateIndirectBr(addr Value, numDests int) (rv Value) { rv.C = C.LLVMBuildIndirectBr(b.C, addr.C, C.unsigned(numDests)) return } +func (b Builder) CreateCallBr(t Type, fn Value, args []Value, defaultDest BasicBlock, indirectDests []BasicBlock, name string) (rv Value) { + cname := C.CString(name) + defer C.free(unsafe.Pointer(cname)) + dests, ndests := llvmBasicBlockRefs(indirectDests) + callArgs, nargs := llvmValueRefs(args) + rv.C = C.LLVMBuildCallBr(b.C, t.C, fn.C, defaultDest.C, dests, ndests, + callArgs, nargs, nil, 0, cname) + return +} func (b Builder) CreateInvoke(t Type, fn Value, args []Value, then, catch BasicBlock, name string) (rv Value) { cname := C.CString(name) defer C.free(unsafe.Pointer(cname)) diff --git a/test/codegen/llvm_defer.go b/test/codegen/llvm_defer.go new file mode 100644 index 00000000000000..6a11cbcc4132f9 --- /dev/null +++ b/test/codegen/llvm_defer.go @@ -0,0 +1,64 @@ +// asmcheck + +// Copyright 2026 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package codegen + +var llvmDeferSink int + +// LLVM-LABEL: define goabiinternal i64 @codegen.llvmDeferStack(i64 %value) +// LLVM: call goabiinternal void @runtime.deferprocStack +// LLVM: callbr void @llvm.go.defer.edge() +// LLVM-NEXT: to label %[[STACK_NORMAL:.*]] [label %[[STACK_RECOVER:.*]]] +// LLVM: [[STACK_RECOVER]]: +// LLVM: call goabiinternal void @runtime.deferreturn() +// LLVM-NOT: load volatile +// LLVM-OPT-LABEL: define goabiinternal i64 @codegen.llvmDeferStack(i64 %value) +// LLVM-OPT: call goabiinternal void @runtime.deferprocStack +// LLVM-OPT: callbr void @llvm.go.defer.edge() +// LLVM-OPT-NEXT: to label %{{.*}} [label %[[STACK_OPT_RECOVER:.*]]] +// LLVM-OPT: [[STACK_OPT_RECOVER]]: +// LLVM-OPT: call goabiinternal void @runtime.deferreturn() +// LLVM-OPT: load i64 +// LLVM-OPT-NOT: load volatile + +// LLVM-LABEL: define goabiinternal void @codegen.llvmDeferHeap(i64 %count) +// LLVM: [[HEAP_NORMAL_RETURN:[A-Za-z0-9_.]+]]: +// LLVM: call goabiinternal void @runtime.deferreturn() +// LLVM: ret void +// LLVM: [[HEAP_RECOVER:[A-Za-z0-9_.]+]]: +// LLVM-NEXT: call goabiinternal void @runtime.deferreturn() +// LLVM: call goabiinternal void @runtime.deferproc( +// LLVM: callbr void @llvm.go.defer.edge() +// LLVM-NEXT: to label %{{.*}} [label %[[HEAP_RECOVER]]] +// LLVM: define goabiinternal void @codegen.llvmDeferHeap.deferwrap1({{.*}}) {{.*}}!goobj.func.info ![[WRAPPER_INFO:[0-9]+]] +// LLVM: ![[WRAPPER_INFO]] = !{i8 23, i8 0} +// LLVM-OPT-LABEL: define goabiinternal void @codegen.llvmDeferHeap(i64 %count) +// LLVM-OPT: [[HEAP_OPT_RECOVER:common.ret]]: +// LLVM-OPT-NEXT: call goabiinternal void @runtime.deferreturn() +// LLVM-OPT: call goabiinternal void @runtime.deferproc( +// LLVM-OPT: callbr void @llvm.go.defer.edge() +// LLVM-OPT-NEXT: to label %{{.*}} [label %[[HEAP_OPT_RECOVER]]] +// LLVM-OPT: define goabiinternal void @codegen.llvmDeferHeap.deferwrap1({{.*}}) {{.*}}!goobj.func.info ![[WRAPPER_OPT_INFO:[0-9]+]] +// LLVM-OPT: ![[WRAPPER_OPT_INFO]] = !{i8 23, i8 0} + +// A defer in a loop uses runtime.deferproc rather than deferprocStack. Keep this +// function before llvmDeferStack because the compiler emits bodies in reverse +// declaration order. +func llvmDeferHeap(count int) { + for i := 0; i < count; i++ { + defer func(value int) { + llvmDeferSink += value + }(i) + } +} + +func llvmDeferStack(value int) (result int) { + defer func() { + result += value + }() + result = 7 + return +} diff --git a/test/llvm_defer.go b/test/llvm_defer.go new file mode 100644 index 00000000000000..ce3d783989f8d4 --- /dev/null +++ b/test/llvm_defer.go @@ -0,0 +1,92 @@ +// run + +// Copyright 2026 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package main + +import "runtime" + +var deferTrace int + +//go:noinline +func normalDefers() (result int) { + defer func() { + deferTrace = deferTrace*10 + 1 + result += 10 + }() + defer func() { + deferTrace = deferTrace*10 + 2 + result += 2 + }() + result = 5 + return +} + +//go:noinline +func recoveredDefer() (result int) { + defer func() { + if recover() != nil { + result = 42 + } + }() + panic("defer recovery") +} + +//go:noinline +func recoverWithArguments(value int, result *int) { + if recover() != nil { + *result = value + } +} + +//go:noinline +func wrapperRecoveredDefer() (result int) { + // Passing arguments requires a generated defer wrapper. Its GoObj FuncID + // must be FuncIDWrapper so gorecover ignores that synthetic frame. + defer recoverWithArguments(64, &result) + panic("wrapper defer recovery") +} + +//go:noinline +func heapDefers(count int) (result int) { + for i := 0; i < count; i++ { + defer func(value int) { + result = result*10 + value + }(i) + } + return +} + +//go:noinline +func pointerDefer() (result int) { + pointer := new(int) + *pointer = 73 + captured := pointer + defer func() { + runtime.GC() + result = *captured + }() + pointer = nil + runtime.GC() + return +} + +func main() { + if got := normalDefers(); got != 17 || deferTrace != 21 { + panic("normal defer order or named result is incorrect") + } + if recoveredDefer() != 42 { + panic("panic recovery did not update named result") + } + if wrapperRecoveredDefer() != 64 { + panic("defer wrapper blocked panic recovery") + } + if heapDefers(3) != 210 { + panic("heap defer order is incorrect") + } + if pointerDefer() != 73 { + panic("defer lost a captured pointer across GC") + } +} diff --git a/test/llvm_tests.json b/test/llvm_tests.json index 9cfa44cbec9d90..b6fad16f2d5d64 100644 --- a/test/llvm_tests.json +++ b/test/llvm_tests.json @@ -34,6 +34,7 @@ "codegen/logic.go": "integer logic and conditional control flow", "codegen/llvm_argument_memory_home.go": "direct register arguments and local homes for memory-backed register aggregates", "codegen/llvm_data_sections.go": "preserve data, bss, noptrdata, and noptrbss identities in LLVM IR", + "codegen/llvm_defer.go": "classic stack and heap defer registration with explicit callbr recovery edges", "codegen/llvm_dereference.go": "address-taken named stack results loaded for return", "codegen/llvm_direct_iface.go": "whole direct-interface aggregates rebuilt before ordinary ABI calls", "codegen/llvm_generic_reshape.go": "named generic shape and concrete aggregate identity with explicit LLVM value reshaping", @@ -163,12 +164,10 @@ "llvm_interface_switch.go": "nil, concrete, multiple interface, and default type-switch cases with execution", "llvm_inittask.go": "main package init-task retention, linking, and execution", "llvm_args_pointer_maps_gc.go": "entry argument pointer maps across recursive stack growth, ordinary safepoints, and runtime.GC", - "llvm_alloca_statepoint_gc.go": "address-taken pointer-containing locals across callee mutation, branches, repeated GC, and stack growth", "abi/llvm_args_results.go": "systematic ABIInternal register and stack arguments, overflowing and aggregate results, GC, and stack growth", "llvm_aggregate_call_argument.go": "pointer-containing struct used only as a call argument, without caller gc-live or relocation", "llvm_memeq.go": "raw memory equality for true, false, different-length, and offset substring inputs", "llvm_move.go": "overlap-safe, aligned, and runtime-helper memory moves", - "llvm_newproc_gc.go": "pointer-typed runtime.newproc funcval across stack growth and repeated GC", "llvm_private_string.go": "frontend private string constant materialization, GoObj linking, and execution", "llvm_zero_sized_symbols.go": "zero-value strings and zero-sized interface data through GoObj linking and execution", "llvm_slicemask.go": "slice start, middle, and zero-capacity end boundary semantics", @@ -177,6 +176,7 @@ "llvm_zero.go": "small and aligned pointer-free zeroing", "llvm_closure.go": "escaping funcval allocation, hidden closure context, indirect call, capture access, and tuple return", "llvm_dereference.go": "address-taken named stack result return semantics", + "llvm_defer.go": "stack and heap defers, LIFO order, panic recovery through generated wrappers, named results, and captured pointers across GC", "llvm_float_intrinsics.go": "float intrinsics, rotate, bit length, conditional select, and atomic logical operation semantics", "llvm_statepoint_branch_gc.go": "pointer relocation across either arm of a two-safepoint branch", "llvm_statepoint_conditional_gc.go": "pointer relocation merged with the original value when a path skips runtime.GC", @@ -1039,14 +1039,240 @@ "typeparam/graph.go": "generic graph traversal repeatedly qualified through LLVM compile, GoObj link, and execution", "typeparam/issue51303.go": "generic interface method calls repeatedly qualified through LLVM compile, GoObj link, and execution", "typeparam/metrics.go": "generic metrics aggregation repeatedly qualified through LLVM compile, GoObj link, and execution", - "typeparam/stringer.go": "generic Stringer method calls repeatedly qualified through LLVM compile, GoObj link, and execution" + "typeparam/stringer.go": "generic Stringer method calls repeatedly qualified through LLVM compile, GoObj link, and execution", + "abi/defer_recover_results.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "abi/open_defer_1.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "chan/select3.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "chancap.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "closedchan.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "closure4.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "defer.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "defernil.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "divmod.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/bug113.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/bug148.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/bug266.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/bug272.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/bug273.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/bug364.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/bug444.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue10486.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue1304.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue14725.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue15252.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue15281.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue15975.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue16130.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue16249.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue16760.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue17381.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue19040.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue19113.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue19246.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue19359.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue19710.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue19799.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue22881.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue23017.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue23734.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue23837.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue24488.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue24491a.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue24491b.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue26094.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue27289.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue27518a.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue28748.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue28797.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue29190.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue30116.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue30116u.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue31419.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue32187.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue32477.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue37975.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue38496.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue40629.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue4066.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue4085b.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue4353.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue43835.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue43942.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue44823.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue46725.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue48898.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue52072.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue5963.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue6055.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue60601.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue63657.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue65417.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue65962.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue68816.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue71675.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue72844.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue72860.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue73748a.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue73748b.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue74379.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue74379b.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue74379c.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue75327.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue7550.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue76008.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue79197.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue79236.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue79236b.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue8047.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue8047b.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue8048.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue8132.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue8158.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue8336.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue8606.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/issue8613.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "fixedbugs/walk_bounded_overshift_empty_bound.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "interface/fail.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "interface/noeq.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "makeslice.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "method.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "method5.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "nil.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "print.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "range4.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "recover.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "recover1.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "recover2.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "recover3.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "recover4.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "typeparam/dottype.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "typeparam/issue50002.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "typeparam/issue51521.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "typeparam/issue58513.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "typeparam/mdempsky/16.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "typeparam/settable.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "unsafebuiltins.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution", + "zerodivide.go": "Darwin/arm64 blacklist probe qualified through LLVM compile, GoObj link, and execution" }, "blacklist": { "*": "LLVM lowering or runtime ABI support has not reached this test yet" }, "platform_blacklist": { "linux/amd64": { - "fixedbugs/issue68322.go": "GOAMD64=v1 guards OpTrunc with unsupported HasCPUFeature lowering" + "fixedbugs/issue68322.go": "GOAMD64=v1 guards OpTrunc with unsupported HasCPUFeature lowering", + "abi/defer_recover_results.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "abi/open_defer_1.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "chan/select3.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "chancap.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "closedchan.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "closure4.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "defer.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "defernil.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "divmod.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/bug113.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/bug148.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/bug266.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/bug272.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/bug273.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/bug364.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/bug444.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue10486.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue1304.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue14725.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue15252.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue15281.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue15975.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue16130.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue16249.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue16760.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue17381.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue19040.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue19113.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue19246.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue19359.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue19710.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue19799.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue22881.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue23017.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue23734.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue23837.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue24488.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue24491a.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue24491b.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue26094.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue27289.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue27518a.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue28748.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue28797.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue29190.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue30116.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue30116u.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue31419.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue32187.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue32477.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue37975.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue38496.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue40629.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue4066.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue4085b.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue4353.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue43835.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue43942.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue44823.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue46725.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue48898.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue52072.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue5963.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue6055.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue60601.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue63657.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue65417.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue65962.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue68816.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue71675.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue72844.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue72860.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue73748a.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue73748b.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue74379.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue74379b.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue74379c.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue75327.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue7550.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue76008.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue79197.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue79236.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue79236b.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue8047.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue8047b.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue8048.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue8132.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue8158.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue8336.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue8606.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/issue8613.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "fixedbugs/walk_bounded_overshift_empty_bound.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "interface/fail.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "interface/noeq.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "makeslice.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "method.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "method5.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "nil.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "print.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "range4.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "recover.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "recover1.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "recover2.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "recover3.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "recover4.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "typeparam/dottype.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "typeparam/issue50002.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "typeparam/issue51521.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "typeparam/issue58513.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "typeparam/mdempsky/16.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "typeparam/settable.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "unsafebuiltins.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified", + "zerodivide.go": "qualified on Darwin/arm64 only; Linux/amd64 runtime not yet verified" } } }