From 069097646765ada39bdcec405451508e37b3ae2a Mon Sep 17 00:00:00 2001 From: Li Jie Date: Mon, 6 Jul 2026 14:03:07 +0800 Subject: [PATCH 01/21] ssa,runtime: tighten recover to direct deferred calls (Defer-node model) Re-expresses #1918 on the #2023 base (its remaining ~11k diff lines were the pre-#2012 funcinfo draft, superseded by the stage-5 chain): - recover() only succeeds when called directly by a deferred function (gc semantics): the panic node records the owning Defer frame at rethrow (panicKey/panicNode + GoDeferData), and Recover checks the caller is that frame's direct deferred call. Closure wraps carry StartRecoverFrameAlias/EndRecoverFrame so method-value and closure adapters stay transparent to the ownership check. - Rethrow keeps the #2023 PanicTraceback hook on the unrecovered path. - xfail: retire fixedbugs/issue4066 (2m-timeout entries; now runs in ~2.7s), fixedbugs/issue73916 and issue73916b (go1.26 recover semantics), validated on darwin/arm64 go1.26. Supersedes #1918. --- cl/_testgo/recoverthenpanic/in.go | 26 ++-- cl/cgo_test.go | 41 ++++++ cl/compile.go | 67 ++++++++- cl/instr.go | 55 ++++++-- cl/rewrite_internal_test.go | 6 +- runtime/internal/runtime/runtime2.go | 9 +- runtime/internal/runtime/z_baremetal.go | 4 + runtime/internal/runtime/z_default.go | 11 +- runtime/internal/runtime/z_rt.go | 71 ++++++++-- ssa/eh.go | 112 ++++++++++++--- ssa/expr.go | 29 ++++ ssa/recover_metadata_test.go | 98 +++++++++++++ test/go/recover_defer_fixedbugs_test.go | 180 ++++++++++++++++++++++++ test/goroot/xfail.yaml | 52 ------- 14 files changed, 642 insertions(+), 119 deletions(-) create mode 100644 ssa/recover_metadata_test.go create mode 100644 test/go/recover_defer_fixedbugs_test.go diff --git a/cl/_testgo/recoverthenpanic/in.go b/cl/_testgo/recoverthenpanic/in.go index 6d1364b14f..2e7958cf77 100644 --- a/cl/_testgo/recoverthenpanic/in.go +++ b/cl/_testgo/recoverthenpanic/in.go @@ -7,7 +7,7 @@ package main // CHECK-LABEL: define void @main.End(){{.*}} { // CHECK-NEXT: _llgo_0: -// CHECK-NEXT: %0 = call %"{{.*}}/runtime/internal/runtime.eface" @"{{.*}}/runtime/internal/runtime.Recover"() +// CHECK-NEXT: %0 = call %"{{.*}}/runtime/internal/runtime.eface" @"{{.*}}/runtime/internal/runtime.Recover"(ptr @main.End) // CHECK-NEXT: %1 = call i1 @"{{.*}}/runtime/internal/runtime.EfaceEqual"(%"{{.*}}/runtime/internal/runtime.eface" %0, %"{{.*}}/runtime/internal/runtime.eface" zeroinitializer) // CHECK-NEXT: %2 = xor i1 %1, true // CHECK-NEXT: %3 = call ptr @"{{.*}}/runtime/internal/runtime.GetThreadDefer"() @@ -161,26 +161,28 @@ func main() { // CHECK-NEXT: _llgo_2: ; preds = %_llgo_5 // CHECK-NEXT: store ptr blockaddress(@main.main, %_llgo_3), ptr %8, align 8 // CHECK-NEXT: %13 = load i64, ptr %7, align 8 +// CHECK-NEXT: %14 = call ptr @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr @main.End) // CHECK-NEXT: call void @main.End() -// CHECK-NEXT: %14 = load %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, align 8 -// CHECK-NEXT: %15 = extractvalue %"{{.*}}/runtime/internal/runtime.Defer" %14, 2 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.SetThreadDefer"(ptr %15) -// CHECK-NEXT: %16 = load ptr, ptr %9, align 8 -// CHECK-NEXT: indirectbr ptr %16, [label %_llgo_3] +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %14) +// CHECK-NEXT: %15 = load %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, align 8 +// CHECK-NEXT: %16 = extractvalue %"{{.*}}/runtime/internal/runtime.Defer" %15, 2 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.SetThreadDefer"(ptr %16) +// CHECK-NEXT: %17 = load ptr, ptr %9, align 8 +// CHECK-NEXT: indirectbr ptr %17, [label %_llgo_3] // CHECK-EMPTY: // CHECK-NEXT: _llgo_3: ; preds = %_llgo_5, %_llgo_2 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Rethrow"(ptr %0) // CHECK-NEXT: br label %_llgo_1 // CHECK-EMPTY: // CHECK-NEXT: _llgo_4: ; preds = %_llgo_0 -// CHECK-NEXT: %17 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @2, i64 13 }, ptr %17, align 8 -// CHECK-NEXT: %18 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %17, 1 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Panic"(%"{{.*}}/runtime/internal/runtime.eface" %18) +// CHECK-NEXT: %18 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @2, i64 13 }, ptr %18, align 8 +// CHECK-NEXT: %19 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %18, 1 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Panic"(%"{{.*}}/runtime/internal/runtime.eface" %19) // CHECK-NEXT: unreachable // CHECK-EMPTY: // CHECK-NEXT: _llgo_5: ; preds = %_llgo_0 // CHECK-NEXT: store ptr blockaddress(@main.main, %_llgo_3), ptr %9, align 8 -// CHECK-NEXT: %19 = load ptr, ptr %8, align 8 -// CHECK-NEXT: indirectbr ptr %19, [label %_llgo_3, label %_llgo_2] +// CHECK-NEXT: %20 = load ptr, ptr %8, align 8 +// CHECK-NEXT: indirectbr ptr %20, [label %_llgo_3, label %_llgo_2] // CHECK-NEXT: } diff --git a/cl/cgo_test.go b/cl/cgo_test.go index 8ba0838340..289b68a809 100644 --- a/cl/cgo_test.go +++ b/cl/cgo_test.go @@ -207,6 +207,47 @@ func findStaticCall(t *testing.T, fn *gossa.Function, name string) *gossa.Call { return nil } +func TestRecoverCallClassificationHelpers(t *testing.T) { + if functionUsesRecover(nil) { + t.Fatal("nil function should not report recover use") + } + + ssaPkg, _, _ := buildGoSSAPkg(t, ` +package foo + +func usesRecover() { + recover() +} + +func plain() {} +`) + usesRecover := ssaPkg.Members["usesRecover"].(*gossa.Function) + plain := ssaPkg.Members["plain"].(*gossa.Function) + ctx := &context{} + + if !functionUsesRecover(usesRecover) { + t.Fatal("usesRecover should report direct recover use") + } + if functionUsesRecover(plain) { + t.Fatal("plain should not report recover use") + } + if !ctx.callMayRecover(usesRecover) { + t.Fatal("function using recover should be recover-capable") + } + if ctx.callMayRecover(plain) { + t.Fatal("plain static function should not be recover-capable") + } + if !ctx.callMayRecover(&gossa.MakeClosure{}) { + t.Fatal("unknown closure target should conservatively be recover-capable") + } + if !ctx.callMayRecover(&gossa.Call{}) { + t.Fatal("function value returned by a call should conservatively be recover-capable") + } + if !ctx.callMayRecover(nil) { + t.Fatal("unknown call value should conservatively be recover-capable") + } +} + func TestCgoCgocall_InitArgsFromParams(t *testing.T) { ssaPkg, _, _ := buildGoSSAPkg(t, ` package foo diff --git a/cl/compile.go b/cl/compile.go index 909f89b939..9a43867e97 100644 --- a/cl/compile.go +++ b/cl/compile.go @@ -213,6 +213,7 @@ type context struct { pcLineSeq uint64 options Options optionsSet bool + recoverSlots map[*ssa.Alloc]none patches Patches blkInfos []blocks.Info @@ -658,12 +659,15 @@ func (p *context) compileFuncDecl(pkg llssa.Package, f *ssa.Function) (llssa.Fun noInlineDirective := hasNoInlineDirective(f) runtimeStackNoInline := needsRuntimeStackNoInline(pkgTypes, f) pcLineNoInline := p.needsPCLineNoInline(f) - if disableInline || noInlineDirective || runtimeStackNoInline || pcLineNoInline { + if disableInline || noInlineDirective || runtimeStackNoInline || pcLineNoInline || functionUsesRecover(f) { fn.Inline(llssa.NoInline) } if noInlineDirective || runtimeStackNoInline || pcLineNoInline { fn.DisableTailCalls() } + if functionUsesRecover(f) { + fn.Expr = fn.Expr.MarkMayRecover() + } p.funcs[f] = fn isCgo := isCgoExternSymbol(f) if nblk := len(f.Blocks); nblk > 0 { @@ -701,14 +705,21 @@ func (p *context) compileFuncDecl(pkg llssa.Package, f *ssa.Function) (llssa.Fun p.inits = append(p.inits, func() { oldFn, oldGoFn, oldMethodNilDerefChecks, oldCallerFrameMark := p.fn, p.goFn, p.methodNilDerefChecks, p.callerFrameMark oldLocalityFunction := p.locality.function + oldRecoverSlots := p.recoverSlots p.fn = fn p.goFn = f p.callerFrameMark = llssa.Nil p.locality.function = localityFunction{} p.state = state // restore pkgState when compiling funcBody + if f.Recover != nil { + p.recoverSlots = make(map[*ssa.Alloc]none) + } else { + p.recoverSlots = nil + } defer func() { p.fn, p.goFn, p.methodNilDerefChecks, p.callerFrameMark = oldFn, oldGoFn, oldMethodNilDerefChecks, oldCallerFrameMark p.locality.function = oldLocalityFunction + p.recoverSlots = oldRecoverSlots }() p.phis = nil if dbgSymsEnabled { @@ -1221,6 +1232,29 @@ func (p *context) syntheticMakeSliceCap(v *ssa.Slice) (llssa.Expr, bool) { return p.prog.IntVal(uint64(arr.Len()), p.prog.Int()), true } +func (p *context) markRecoverSlot(v *ssa.Alloc) { + if p.recoverSlots == nil || v.Heap { + return + } + p.recoverSlots[v] = none{} +} + +func (p *context) isRecoverSlotAddr(v ssa.Value) bool { + if p.recoverSlots == nil { + return false + } + switch v := v.(type) { + case *ssa.Alloc: + _, ok := p.recoverSlots[v] + return ok + case *ssa.FieldAddr: + return p.isRecoverSlotAddr(v.X) + case *ssa.IndexAddr: + return p.isRecoverSlotAddr(v.X) + } + return false +} + func isAllocVargs(ctx *context, v *ssa.Alloc) bool { refs, ok := nonDebugReferrers(v) if !ok || len(refs) == 0 { @@ -1410,6 +1444,9 @@ func (p *context) compileInstrOrValue(b llssa.Builder, iv instrOrValue, asValue } } ret = b.UnOp(v.Op, x) + if v.Op == token.MUL && p.isRecoverSlotAddr(v.X) { + ret = ret.SetVolatile(true) + } } case *ssa.ChangeType: t := v.Type() @@ -1445,6 +1482,10 @@ func (p *context) compileInstrOrValue(b llssa.Builder, iv instrOrValue, asValue elem := p.type_(t.Elem(), llssa.InGo) ret = b.Alloc(elem, v.Heap) p.debugAlloc(b, v, ret) + p.markRecoverSlot(v) + if p.isRecoverSlotAddr(v) { + b.Store(ret, p.prog.Zero(elem)).SetVolatile(true) + } case *ssa.IndexAddr: vx := v.X if _, ok := p.isVArgs(vx); ok { // varargs: this is a varargs index @@ -1801,7 +1842,10 @@ func (p *context) compileInstr(b llssa.Builder, instr ssa.Instruction) { } ptr := p.compileValue(b, va) val := p.compileValue(b, v.Val) - b.Store(ptr, val) + store := b.Store(ptr, val) + if p.isRecoverSlotAddr(va) { + store.SetVolatile(true) + } case *ssa.Jump: jmpb := p.jumpTo(v) b.Jump(jmpb) @@ -1898,6 +1942,25 @@ func (p *context) getLocalVariable(b llssa.Builder, fn *ssa.Function, v *types.V return div } +func functionUsesRecover(fn *ssa.Function) bool { + if fn == nil { + return false + } + for _, block := range fn.Blocks { + for _, instr := range block.Instrs { + call, ok := instr.(ssa.CallInstruction) + if !ok { + continue + } + builtin, ok := call.Common().Value.(*ssa.Builtin) + if ok && builtin.Name() == "recover" { + return true + } + } + } + return false +} + func (p *context) compileFunction(v *ssa.Function) (goFn llssa.Function, pyFn llssa.PyObjRef, kind int) { // TODO(xsw) v.Pkg == nil: means auto generated function? if v.Pkg == p.goPkg || v.Pkg == nil { diff --git a/cl/instr.go b/cl/instr.go index 818e89c322..6ff03078be 100644 --- a/cl/instr.go +++ b/cl/instr.go @@ -1805,12 +1805,36 @@ func (p *context) deferStackOwner(fn *ssa.Function) llssa.Function { return owner } -func (p *context) emitDo(b llssa.Builder, act llssa.DoAction, ds *explicitDeferStack, fn llssa.Expr, buildCall func(llssa.Builder, llssa.Expr, ...llssa.Expr) llssa.Expr, args ...llssa.Expr) llssa.Expr { +func (p *context) emitDo(b llssa.Builder, act llssa.DoAction, ds *explicitDeferStack, mayRecover bool, fn llssa.Expr, buildCall func(llssa.Builder, llssa.Expr, ...llssa.Expr) llssa.Expr, args ...llssa.Expr) llssa.Expr { if ds != nil { - b.DeferTo(ds.owner, ds.stack, fn, buildCall, args...) + b.DeferToRecover(ds.owner, ds.stack, mayRecover, fn, buildCall, args...) return llssa.Nil } - return b.Do(act, fn, buildCall, args...) + switch act { + case llssa.Call, llssa.Go: + return b.Do(act, fn, buildCall, args...) + default: + b.DeferRecover(act, mayRecover, fn, buildCall, args...) + return llssa.Nil + } +} + +func (p *context) callMayRecover(v ssa.Value) bool { + switch v := v.(type) { + case *ssa.Builtin: + return false + case *ssa.Function: + return functionUsesRecover(v) + case *ssa.MakeClosure: + if fn, ok := v.Fn.(*ssa.Function); ok { + return functionUsesRecover(fn) + } + return true + case *ssa.Call: + // The deferred callee is the call result, not the factory function. + return true + } + return true } func (p *context) staticArrayLenBuiltinArg(b llssa.Builder, arg ssa.Value) (llssa.Expr, bool) { @@ -1965,6 +1989,7 @@ func (p *context) callEx(b llssa.Builder, act llssa.DoAction, call *ssa.CallComm p.recordCallerLocationForCall(b, call) p.emitPCLineLabel(b, call.Pos()) cv := call.Value + mayRecover := p.callMayRecover(cv) if mthd := call.Method; mthd != nil { reflectCheck := p.reflectTypeMethodCheck(call, mthd) o := p.compileValue(b, cv) @@ -1974,7 +1999,7 @@ func (p *context) callEx(b llssa.Builder, act llssa.DoAction, call *ssa.CallComm hasVArg = fnHasVArg } args := p.compileValues(b, call.Args, hasVArg) - ret = p.emitDo(b, act, ds, fn, llssa.Builder.Call, args...) + ret = p.emitDo(b, act, ds, true, fn, llssa.Builder.Call, args...) if reflectCheck.Kind&llssa.ReflectTypeMethodByName != 0 && reflectCheck.Name == "" { b.MarkReflectTypeMethodByNameExpr(ret, 1) } @@ -2008,7 +2033,7 @@ func (p *context) callEx(b llssa.Builder, act llssa.DoAction, call *ssa.CallComm } } args := p.compileValues(b, args, kind) - ret = p.emitDo(b, act, ds, llssa.Builtin(fn), llssa.Builder.Call, args...) + ret = p.emitDo(b, act, ds, false, llssa.Builtin(fn), llssa.Builder.Call, args...) case *ssa.Function: aFn, pyFn, ftype := p.compileFunction(cv) // TODO(xsw): check ca != llssa.Call @@ -2017,13 +2042,13 @@ func (p *context) callEx(b llssa.Builder, act llssa.DoAction, call *ssa.CallComm p.inCFunc = true args := p.compileValues(b, args, kind) p.inCFunc = false - ret = p.emitDo(b, act, ds, aFn.Expr, llssa.Builder.Call, args...) + ret = p.emitDo(b, act, ds, mayRecover, aFn.Expr, llssa.Builder.Call, args...) case goFunc: args := p.compileValues(b, args, kind) - ret = p.emitDo(b, act, ds, aFn.Expr, llssa.Builder.Call, args...) + ret = p.emitDo(b, act, ds, mayRecover, aFn.Expr, llssa.Builder.Call, args...) case pyFunc: args := p.compileValues(b, args, kind) - ret = p.emitDo(b, act, ds, pyFn.Expr, llssa.Builder.Call, args...) + ret = p.emitDo(b, act, ds, mayRecover, pyFn.Expr, llssa.Builder.Call, args...) case llgoPyList: args := p.compileValues(b, args, fnHasVArg) ret = b.PyList(args...) @@ -2102,33 +2127,33 @@ func (p *context) callEx(b llssa.Builder, act llssa.DoAction, call *ssa.CallComm b.Unreachable() case llgoAtomicLoad: args := p.compileValues(b, args, kind) - ret = p.emitDo(b, act, ds, llssa.Nil, func(b llssa.Builder, _ llssa.Expr, args ...llssa.Expr) llssa.Expr { + ret = p.emitDo(b, act, ds, false, llssa.Nil, func(b llssa.Builder, _ llssa.Expr, args ...llssa.Expr) llssa.Expr { return p.atomicLoad(b, args) }, args...) case llgoAtomicStore: args := p.compileValues(b, args, kind) - p.emitDo(b, act, ds, llssa.Nil, func(b llssa.Builder, _ llssa.Expr, args ...llssa.Expr) llssa.Expr { + p.emitDo(b, act, ds, false, llssa.Nil, func(b llssa.Builder, _ llssa.Expr, args ...llssa.Expr) llssa.Expr { return p.atomicStore(b, args) }, args...) case llgoAtomicCmpXchg: args := p.compileValues(b, args, kind) - ret = p.emitDo(b, act, ds, llssa.Nil, func(b llssa.Builder, _ llssa.Expr, args ...llssa.Expr) llssa.Expr { + ret = p.emitDo(b, act, ds, false, llssa.Nil, func(b llssa.Builder, _ llssa.Expr, args ...llssa.Expr) llssa.Expr { return p.atomicCmpXchg(b, args) }, args...) case llgoAtomicCmpXchgOK: args := p.compileValues(b, args, kind) - ret = p.emitDo(b, act, ds, llssa.Nil, func(b llssa.Builder, _ llssa.Expr, args ...llssa.Expr) llssa.Expr { + ret = p.emitDo(b, act, ds, false, llssa.Nil, func(b llssa.Builder, _ llssa.Expr, args ...llssa.Expr) llssa.Expr { return p.atomicCmpXchgOK(b, args) }, args...) case llgoAtomicAddReturnNew: args := p.compileValues(b, args, kind) - ret = p.emitDo(b, act, ds, llssa.Nil, func(b llssa.Builder, _ llssa.Expr, args ...llssa.Expr) llssa.Expr { + ret = p.emitDo(b, act, ds, false, llssa.Nil, func(b llssa.Builder, _ llssa.Expr, args ...llssa.Expr) llssa.Expr { return b.BinOp(token.ADD, p.atomic(b, llssa.OpAdd, args), args[1]) }, args...) default: if ftype >= llgoAtomicOpBase && ftype <= llgoAtomicOpLast { args := p.compileValues(b, args, kind) - ret = p.emitDo(b, act, ds, llssa.Nil, func(b llssa.Builder, _ llssa.Expr, args ...llssa.Expr) llssa.Expr { + ret = p.emitDo(b, act, ds, false, llssa.Nil, func(b llssa.Builder, _ llssa.Expr, args ...llssa.Expr) llssa.Expr { return p.atomic(b, llssa.AtomicOp(ftype-llgoAtomicOpBase), args) }, args...) } else { @@ -2138,7 +2163,7 @@ func (p *context) callEx(b llssa.Builder, act llssa.DoAction, call *ssa.CallComm default: fn := p.compileValue(b, cv) args := p.compileDynamicCallValues(b, call, kind) - ret = p.emitDo(b, act, ds, fn, llssa.Builder.Call, args...) + ret = p.emitDo(b, act, ds, mayRecover, fn, llssa.Builder.Call, args...) } return } diff --git a/cl/rewrite_internal_test.go b/cl/rewrite_internal_test.go index c90cdcf01e..c93112c3c9 100644 --- a/cl/rewrite_internal_test.go +++ b/cl/rewrite_internal_test.go @@ -898,8 +898,8 @@ func TestEmitDoWithExplicitDeferStack(t *testing.T) { b.SetBlockEx(owner.Block(0), llssa.BeforeLast, true) ctx := &context{} - ctx.emitDo(b, llssa.DeferInLoop, &explicitDeferStack{stack: stack, owner: owner}, callee.Expr, llssa.Builder.Call) - ctx.emitDo(b, llssa.DeferAlways, nil, callee.Expr, llssa.Builder.Call) + ctx.emitDo(b, llssa.DeferInLoop, &explicitDeferStack{stack: stack, owner: owner}, false, callee.Expr, llssa.Builder.Call) + ctx.emitDo(b, llssa.DeferAlways, nil, false, callee.Expr, llssa.Builder.Call) b.DeferStackDrain() b.RunDefers() b.Return() @@ -1090,7 +1090,7 @@ func TestEmitDoWithoutExplicitDeferStack(t *testing.T) { b := fn.MakeBody(1) ctx := &context{} - got := ctx.emitDo(b, llssa.Call, nil, callee.Expr, llssa.Builder.Call) + got := ctx.emitDo(b, llssa.Call, nil, false, callee.Expr, llssa.Builder.Call) if got.IsNil() { t.Fatal("emitDo without explicit defer stack should return direct call result") } diff --git a/runtime/internal/runtime/runtime2.go b/runtime/internal/runtime/runtime2.go index 7787c8e225..ee18851f31 100644 --- a/runtime/internal/runtime/runtime2.go +++ b/runtime/internal/runtime/runtime2.go @@ -38,10 +38,11 @@ const ( // make sense once LLGo can suspend and resume a G (saved registers, wait state, // and stack roots) belong here when those facilities are added. type g struct { - defer_ *Defer - panic_ unsafe.Pointer - panicPCs panicPCStore - m *m + defer_ *Defer + panic_ unsafe.Pointer + panicPCs panicPCStore + recoverFrame unsafe.Pointer + m *m atomicstatus uint32 goid uint64 diff --git a/runtime/internal/runtime/z_baremetal.go b/runtime/internal/runtime/z_baremetal.go index a862225852..3669a6ffbc 100644 --- a/runtime/internal/runtime/z_baremetal.go +++ b/runtime/internal/runtime/z_baremetal.go @@ -21,6 +21,10 @@ func Rethrow(link *Defer) { c.Printf(c.Str("fatal error\n")) c.Exit(2) } else { + if ptr := getg().panic_; ptr != nil && link == GetThreadDefer() { + node := (*panicNode)(ptr) + node.moveToDefer(link) + } setjmp.Longjmp((*setjmp.JmpBuf)(link.Addr), 1) } } diff --git a/runtime/internal/runtime/z_default.go b/runtime/internal/runtime/z_default.go index e73aeff206..fc88e4bc38 100644 --- a/runtime/internal/runtime/z_default.go +++ b/runtime/internal/runtime/z_default.go @@ -3,6 +3,8 @@ package runtime import ( + "unsafe" + c "github.com/goplus/llgo/runtime/internal/clite" "github.com/goplus/llgo/runtime/internal/clite/debug" ) @@ -18,13 +20,18 @@ func Rethrow(link *Defer) { gp := getg() if ptr := gp.panic_; ptr != nil { if link == nil { - TracePanic(*(*any)(ptr)) + node := (*panicNode)(ptr) + TracePanic(node.arg) if PanicTraceback == nil || !PanicTraceback(2) { debug.PrintStack(2) } - c.Free(ptr) + c.Free(unsafe.Pointer(node)) c.Exit(2) } else { + node := (*panicNode)(ptr) + if link == gp.defer_ { + node.moveToDefer(link) + } c.Siglongjmp(link.Addr, 1) } } else if gp.goexit { diff --git a/runtime/internal/runtime/z_rt.go b/runtime/internal/runtime/z_rt.go index 915905e77a..ccbe1a1d07 100644 --- a/runtime/internal/runtime/z_rt.go +++ b/runtime/internal/runtime/z_rt.go @@ -35,14 +35,43 @@ type Defer struct { Args unsafe.Pointer // defer func and args links } +type panicNode struct { + prev unsafe.Pointer + arg any + defer_ *Defer +} + +// moveToDefer advances a panic to the next defer frame. A panic already +// unwinding that frame has been replaced by this newer panic and must not +// resume if the newer panic is recovered farther down the defer chain. +func (node *panicNode) moveToDefer(link *Defer) { + for node.prev != nil { + prev := (*panicNode)(node.prev) + if prev.defer_ != link { + break + } + node.prev = prev.prev + c.Free(unsafe.Pointer(prev)) + } + node.defer_ = link +} + // Recover recovers a panic. -func Recover() (ret any) { +func Recover(token unsafe.Pointer) (ret any) { gp := getg() + if token == nil || token != gp.recoverFrame { + return nil + } ptr := gp.panic_ if ptr != nil { - gp.panic_ = nil - ret = *(*any)(ptr) - c.Free(ptr) + node := (*panicNode)(ptr) + if node.defer_ != gp.defer_ { + return nil + } + gp.panic_ = node.prev + gp.recoverFrame = nil + ret = node.arg + c.Free(unsafe.Pointer(node)) if PanicRecovered != nil { PanicRecovered() } @@ -61,6 +90,31 @@ func Recover() (ret any) { return } +// StartRecoverFrame enables direct recover calls made by the deferred function +// currently being invoked from frame. +func StartRecoverFrame(frame unsafe.Pointer) unsafe.Pointer { + gp := getg() + old := gp.recoverFrame + gp.recoverFrame = frame + return old +} + +// EndRecoverFrame restores direct recover permission after a deferred call. +func EndRecoverFrame(frame unsafe.Pointer) { + getg().recoverFrame = frame +} + +// StartRecoverFrameAlias maps a direct deferred closure wrapper to the wrapped +// function while the wrapper calls into it. +func StartRecoverFrameAlias(from, to unsafe.Pointer) unsafe.Pointer { + gp := getg() + old := gp.recoverFrame + if old == from { + gp.recoverFrame = to + } + return old +} + // RecoverMark, set by the public runtime package, records the recovering // frame for panic-snapshot splicing. var RecoverMark func() @@ -80,14 +134,15 @@ func Panic(v any) { v = &PanicNilError{} } SavePanicCallerFrames() - ptr := c.Malloc(unsafe.Sizeof(v)) - *(*any)(ptr) = v gp := getg() - gp.panic_ = ptr + ptr := (*panicNode)(c.Malloc(unsafe.Sizeof(panicNode{}))) + ptr.prev = gp.panic_ + ptr.arg = v + ptr.defer_ = gp.defer_ + gp.panic_ = unsafe.Pointer(ptr) Rethrow(gp.defer_) } - func Goexit() { gp := getg() gp.goexit = true diff --git a/ssa/eh.go b/ssa/eh.go index 782ffbb337..872d173f77 100644 --- a/ssa/eh.go +++ b/ssa/eh.go @@ -179,11 +179,12 @@ type deferTarget struct { // The id uniquely identifies the defer call site for dispatch during drain. // typ is the node struct type needed to decode the linked-list node. type loopDeferCase struct { - id Expr - typ Type - fn Expr - args []Expr - buildCall func(Builder, Expr, ...Expr) Expr + id Expr + typ Type + mayRecover bool + fn Expr + args []Expr + buildCall func(Builder, Expr, ...Expr) Expr } const ( @@ -339,6 +340,11 @@ func (b Builder) DeferStackDrain() { // Defer emits a defer instruction. func (b Builder) Defer(kind DoAction, fn Expr, buildCall func(Builder, Expr, ...Expr) Expr, args ...Expr) { + b.DeferRecover(kind, deferMayRecover(fn), fn, buildCall, args...) +} + +// DeferRecover emits a defer instruction with explicit recover capability. +func (b Builder) DeferRecover(kind DoAction, mayRecover bool, fn Expr, buildCall func(Builder, Expr, ...Expr) Expr, args ...Expr) { dbgInstrCall("Defer", fn, args) var prog Program var nextbit Expr @@ -366,14 +372,20 @@ func (b Builder) Defer(kind DoAction, fn Expr, buildCall func(Builder, Expr, ... } typ := b.saveDeferArgs(self, kind, id, fn, args) if kind == DeferInLoop { - loopCase := loopDeferCase{id: id, typ: typ, fn: fn, args: args, buildCall: buildCall} + loopCase := loopDeferCase{id: id, typ: typ, mayRecover: mayRecover, fn: fn, args: args, buildCall: buildCall} self.loopCases = append(self.loopCases, loopCase) } - b.appendDeferStmt(self, kind, typ, buildCall, fn, args, nextbit) + b.appendDeferStmt(self, kind, typ, mayRecover, buildCall, fn, args, nextbit) } // DeferTo emits a defer instruction into an explicit runtime defer stack. func (b Builder) DeferTo(owner Function, stack Expr, fn Expr, buildCall func(Builder, Expr, ...Expr) Expr, args ...Expr) { + b.DeferToRecover(owner, stack, deferMayRecover(fn), fn, buildCall, args...) +} + +// DeferToRecover emits a defer instruction into an explicit runtime defer +// stack with explicit recover capability. +func (b Builder) DeferToRecover(owner Function, stack Expr, mayRecover bool, fn Expr, buildCall func(Builder, Expr, ...Expr) Expr, args ...Expr) { if debugInstr { logCall("DeferTo", fn, args) } @@ -387,11 +399,12 @@ func (b Builder) DeferTo(owner Function, stack Expr, fn Expr, buildCall func(Bui argsPtr := b.PtrCast(b.Prog.Pointer(b.Prog.VoidPtr()), stack) typ := b.saveDeferArgsTo(argsPtr, DeferInLoop, id, fn, args) loopCase := loopDeferCase{ - id: id, - typ: typ, - fn: fn, - args: args, - buildCall: buildCall, + id: id, + typ: typ, + mayRecover: mayRecover, + fn: fn, + args: args, + buildCall: buildCall, } if self == nil { owner.pendingLoopCases = append(owner.pendingLoopCases, loopCase) @@ -400,7 +413,7 @@ func (b Builder) DeferTo(owner Function, stack Expr, fn Expr, buildCall func(Bui self.loopCases = append(self.loopCases, loopCase) } -func (b Builder) appendDeferStmt(self *aDefer, kind DoAction, typ Type, buildCall func(Builder, Expr, ...Expr) Expr, fn Expr, args []Expr, nextbit Expr) { +func (b Builder) appendDeferStmt(self *aDefer, kind DoAction, typ Type, mayRecover bool, buildCall func(Builder, Expr, ...Expr) Expr, fn Expr, args []Expr, nextbit Expr) { self.stmts = append(self.stmts, func(bits Expr, resume deferTarget) { switch kind { case DeferInCond: @@ -411,13 +424,13 @@ func (b Builder) appendDeferStmt(self *aDefer, kind DoAction, typ Type, buildCal zero := prog.Val(uintptr(0)) has := b.BinOp(token.NEQ, b.BinOp(token.AND, bits, nextbit), zero) b.IfThen(has, func() { - b.callDefer(self, typ, buildCall, fn, args) + b.callDefer(self, typ, mayRecover, buildCall, fn, args) }) case DeferAlways: // Leaving a run of loop defers; allow the next loop-defer statement // (earlier in source order) to generate its own drainer. self.loopDrainerGenerated = false - b.callDefer(self, typ, buildCall, fn, args) + b.callDefer(self, typ, mayRecover, buildCall, fn, args) case DeferInLoop: b.loopDeferDrainer(self, resume) } @@ -474,7 +487,7 @@ func (b Builder) loopDeferDrainer(self *aDefer, resume deferTarget) { b.SetBlockEx(caseBlks[i], AtEnd, true) b.storeDeferTarget(self.rethPtr, resume) - b.callDefer(self, c.typ, c.buildCall, c.fn, c.args) + b.callDefer(self, c.typ, c.mayRecover, c.buildCall, c.fn, c.args) b.Jump(condBlk) } @@ -530,9 +543,11 @@ func (b Builder) saveDeferArgsTo(argsPtr Expr, kind DoAction, id Expr, fn Expr, return typ } -func (b Builder) callDefer(self *aDefer, typ Type, buildCall func(Builder, Expr, ...Expr) Expr, fn Expr, args []Expr) { +func (b Builder) callDefer(self *aDefer, typ Type, mayRecover bool, buildCall func(Builder, Expr, ...Expr) Expr, fn Expr, args []Expr) { if typ == nil { - buildCall(b, fn, args...) + b.callRecoverScopedDefer(fn, mayRecover, func() { + buildCall(b, fn, args...) + }) return } prog := b.Prog @@ -563,10 +578,66 @@ func (b Builder) callDefer(self *aDefer, typ Type, buildCall func(Builder, Expr, args[i] = b.getField(data, i+offset) } b.Call(b.Pkg.rtFunc("FreeDeferNode"), ptr) - buildCall(b, fn, args...) + b.callRecoverScopedDefer(fn, mayRecover, func() { + buildCall(b, fn, args...) + }) }) } +func (b Builder) callRecoverScopedDefer(fn Expr, mayRecover bool, call func()) { + if fn.IsNil() || fn.impl.IsNil() || isRecoverBuiltin(fn) { + call() + return + } + token := b.recoverDeferToken(fn, mayRecover) + if token.IsNil() { + call() + return + } + prev := b.Call(b.Pkg.rtFunc("StartRecoverFrame"), token) + call() + b.Call(b.Pkg.rtFunc("EndRecoverFrame"), prev) +} + +func (b Builder) recoverDeferToken(fn Expr, mayRecover bool) Expr { + switch fn.kind { + case vkClosure, vkIfaceMethod: + if !mayRecover { + return Nil + } + return b.PtrCast(b.Prog.VoidPtr(), b.Field(fn, 0)) + case vkFuncDecl: + if !mayRecover { + return Nil + } + return b.PtrCast(b.Prog.VoidPtr(), fn) + case vkFuncPtr: + return b.PtrCast(b.Prog.VoidPtr(), fn) + } + return Nil +} + +func deferMayRecover(fn Expr) bool { + if fn.IsNil() || fn.Type == nil { + return false + } + switch fn.kind { + case vkClosure, vkFuncDecl: + return fn.mayRecover() + case vkIfaceMethod, vkFuncPtr: + return true + } + return false +} + +func isRecoverBuiltin(fn Expr) bool { + if fn.IsNil() || fn.kind != vkBuiltin { + return false + } + bi, ok := fn.raw.Type.(*builtinTy) + return ok && bi.name == "recover" +} + // RunDefers emits instructions to run deferred instructions. func (b Builder) RunDefers() { self := b.getDefer(DeferInCond) @@ -683,8 +754,7 @@ func (b Builder) Unreachable() { // Recover emits a recover instruction. func (b Builder) Recover() Expr { dbgInstrln("Recover") - // TODO(xsw): recover can't be a function call in Go - return b.Call(b.Pkg.rtFunc("Recover")) + return b.Call(b.Pkg.rtFunc("Recover"), b.PtrCast(b.Prog.VoidPtr(), b.Func.Expr)) } // Panic emits a panic instruction. diff --git a/ssa/expr.go b/ssa/expr.go index dce7fb24c6..97d91cd852 100644 --- a/ssa/expr.go +++ b/ssa/expr.go @@ -48,6 +48,8 @@ type Expr struct { var Nil Expr // Zero value is a nil Expr +const mayRecoverAttr = "llgo.may-recover" + // IsNil checks if the expression is nil or not. func (v Expr) IsNil() bool { return v.Type == nil @@ -59,6 +61,33 @@ func (v Expr) SetOrdering(ordering AtomicOrdering) Expr { return v } +// SetVolatile marks a load or store as volatile. +func (v Expr) SetVolatile(volatile bool) Expr { + v.impl.SetVolatile(volatile) + return v +} + +// MarkMayRecover marks a function or closure that may call recover directly. +func (v Expr) MarkMayRecover() Expr { + if v.Type == nil || v.impl.IsNil() { + return v + } + fn := v.impl.IsAFunction() + if !fn.IsNil() && fn.GetStringAttributeAtIndex(-1, mayRecoverAttr).IsNil() { + ctx := fn.GlobalParent().Context() + fn.AddFunctionAttr(ctx.CreateStringAttribute(mayRecoverAttr, "true")) + } + return v +} + +func (v Expr) mayRecover() bool { + if v.Type == nil || v.impl.IsNil() { + return false + } + fn := v.impl.IsAFunction() + return !fn.IsNil() && !fn.GetStringAttributeAtIndex(-1, mayRecoverAttr).IsNil() +} + func (v Expr) SetName(alias string) Expr { v.impl.SetName(alias) return v diff --git a/ssa/recover_metadata_test.go b/ssa/recover_metadata_test.go new file mode 100644 index 0000000000..a744765e44 --- /dev/null +++ b/ssa/recover_metadata_test.go @@ -0,0 +1,98 @@ +//go:build !llgo + +package ssa + +import ( + "go/types" + "testing" +) + +func TestRecoverMetadataHandlesNonFunctions(t *testing.T) { + prog := NewProgram(nil) + values := []Expr{ + Nil, + {Type: prog.Int()}, + prog.Val(1), + } + for i, value := range values { + if got := value.MarkMayRecover(); got.Type != value.Type { + t.Fatalf("value %d: MarkMayRecover changed the expression type", i) + } + if value.mayRecover() { + t.Fatalf("value %d: non-function marked as recover-capable", i) + } + } + + pkg := prog.NewPackage("p", "example.com/p") + fn := pkg.NewFunc("recovering", NoArgsNoRet, InGo) + if fn.Expr.mayRecover() { + t.Fatal("new function unexpectedly marked as recover-capable") + } + fn.Expr.MarkMayRecover() + if !fn.Expr.mayRecover() { + t.Fatal("marked function is not recover-capable") + } + // Marking a function twice must preserve the existing attribute. + fn.Expr.MarkMayRecover() + if !fn.Expr.mayRecover() { + t.Fatal("re-marked function lost recover capability") + } +} + +func TestRecoverDeferClassificationFallbacks(t *testing.T) { + prog := NewProgram(nil) + pkg := prog.NewPackage("p", "example.com/p") + callee := pkg.NewFunc("callee", NoArgsNoRet, InGo) + caller := pkg.NewFunc("caller", NoArgsNoRet, InGo) + b := caller.MakeBody(1) + + fnPtr := b.ChangeType(prog.rawType(NoArgsNoRet), callee.Expr) + ifaceMethod := Expr{Type: &aType{kind: vkIfaceMethod}} + ordinary := prog.Val(1) + + for _, test := range []struct { + name string + fn Expr + want bool + }{ + {name: "nil", fn: Nil, want: false}, + {name: "ordinary", fn: ordinary, want: false}, + {name: "function declaration", fn: callee.Expr, want: false}, + {name: "function pointer", fn: fnPtr, want: true}, + {name: "interface method", fn: ifaceMethod, want: true}, + } { + t.Run(test.name, func(t *testing.T) { + if got := deferMayRecover(test.fn); got != test.want { + t.Fatalf("deferMayRecover() = %v, want %v", got, test.want) + } + }) + } + + callee.Expr.MarkMayRecover() + if !deferMayRecover(callee.Expr) { + t.Fatal("marked function declaration is not recover-capable") + } + if token := b.recoverDeferToken(fnPtr, false); token.IsNil() { + t.Fatal("function pointer did not produce a recover token") + } + if token := b.recoverDeferToken(ordinary, true); !token.IsNil() { + t.Fatal("ordinary value unexpectedly produced a recover token") + } + + if !isRecoverBuiltin(Builtin("recover")) { + t.Fatal("recover builtin not recognized") + } + for _, value := range []Expr{ + Nil, + ordinary, + Builtin("panic"), + {Type: &aType{raw: rawType{Type: types.Typ[types.Int]}, kind: vkBuiltin}}, + } { + if isRecoverBuiltin(value) { + t.Fatalf("%v unexpectedly recognized as the recover builtin", value.Type) + } + } + + b.Return() + b.EndBuild() +} diff --git a/test/go/recover_defer_fixedbugs_test.go b/test/go/recover_defer_fixedbugs_test.go new file mode 100644 index 0000000000..376dc860bf --- /dev/null +++ b/test/go/recover_defer_fixedbugs_test.go @@ -0,0 +1,180 @@ +package gotest + +import ( + "runtime" + "strings" + "testing" +) + +type fixedbug4066Panic struct{} + +func fixedbug4066NamedReturn() (val int) { + val = 0 + defer func() { + if x := recover(); x != nil { + _ = x.(fixedbug4066Panic) + } + }() + for { + val = 2 + fixedbug4066Throw() + } +} + +func fixedbug4066Throw() { + panic(fixedbug4066Panic{}) +} + +func TestRecoverFixedbug4066NamedReturn(t *testing.T) { + if got := fixedbug4066NamedReturn(); got != 2 { + t.Fatalf("named return after recover = %d, want 2", got) + } +} + +func TestRecoverFixedbugDirectDeferredFuncValue(t *testing.T) { + recovered := false + func() { + f := func() { + if recover() != nil { + recovered = true + } + } + defer f() + panic("direct deferred func value") + }() + if !recovered { + t.Fatal("direct deferred func value did not recover") + } +} + +func TestRecoverFixedbugNestedDeferInDeferredFuncDoesNotRecover(t *testing.T) { + nested := any("unset") + func() { + defer func() { + if r := recover(); r != "outer" { + t.Fatalf("outer recover = %v, want outer", r) + } + }() + defer func() { + defer func() { + nested = recover() + }() + }() + panic("outer") + }() + if nested != nil { + t.Fatalf("nested recover = %v, want nil", nested) + } +} + +var fixedbugReturnedRecover any + +func fixedbugReturnedRecoverFunc() func() { + return func() { + fixedbugReturnedRecover = recover() + } +} + +func TestRecoverFixedbugReturnedDeferredFuncValue(t *testing.T) { + fixedbugReturnedRecover = nil + func() { + defer fixedbugReturnedRecoverFunc()() + panic("returned deferred func value") + }() + if fixedbugReturnedRecover != "returned deferred func value" { + t.Fatalf("returned deferred recover = %v, want panic value", fixedbugReturnedRecover) + } +} + +func fixedbug8047bNilDeferredCall() { + var fn func() + defer fn() + panic(1) +} + +func TestRecoverFixedbug8047bNilDeferredCallReplacesPanic(t *testing.T) { + var got any + func() { + defer func() { + got = recover() + }() + fixedbug8047bNilDeferredCall() + }() + if got == nil { + t.Fatal("nil deferred call did not panic") + } + if got == 1 { + t.Fatal("recover observed the original panic after the nil deferred call replaced it") + } +} + +var fixedbug73916Recovered bool + +func fixedbug73916CallRecover() { + if recover() != nil { + fixedbug73916Recovered = true + } +} + +func fixedbug73916Deferred(int) { + fixedbug73916CallRecover() +} + +func fixedbug73916MustPanic(t *testing.T, fn func()) any { + t.Helper() + defer func() { + if r := recover(); r == nil { + t.Fatal("deferred indirect recover swallowed panic") + } + }() + fn() + return nil +} + +func TestRecoverFixedbug73916IndirectRecoverDoesNotRecover(t *testing.T) { + skipBeforeGo126(t) + fixedbug73916Recovered = false + fixedbug73916MustPanic(t, func() { + defer fixedbug73916Deferred(1) + panic("fixedbug73916") + }) + if fixedbug73916Recovered { + t.Fatal("indirect recover returned non-nil") + } +} + +var fixedbug73916bRecovered bool + +func fixedbug73916bCallRecover() { + func() { + if recover() != nil { + fixedbug73916bRecovered = true + } + }() +} + +func fixedbug73916bDeferred() int { + fixedbug73916bCallRecover() + return 0 +} + +func TestRecoverFixedbug73916NestedRecoverDoesNotRecover(t *testing.T) { + skipBeforeGo126(t) + fixedbug73916bRecovered = false + fixedbug73916MustPanic(t, func() { + defer fixedbug73916bDeferred() + panic("fixedbug73916b") + }) + if fixedbug73916bRecovered { + t.Fatal("nested recover returned non-nil") + } +} + +func skipBeforeGo126(t *testing.T) { + t.Helper() + version := runtime.Version() + if strings.HasPrefix(version, "go1.26") || strings.HasPrefix(version, "devel") { + return + } + t.Skip("requires Go 1.26 recover semantics") +} diff --git a/test/goroot/xfail.yaml b/test/goroot/xfail.yaml index 3bfa465b68..02ceb84a6d 100644 --- a/test/goroot/xfail.yaml +++ b/test/goroot/xfail.yaml @@ -546,12 +546,6 @@ timeouts: case: fixedbugs/issue40367.go timeout: 2m reason: issue40367 run exceeds the default timeout on darwin/arm64 - - version: go1.24 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue4066.go - timeout: 2m - reason: issue4066 run exceeds the default timeout on darwin/arm64 - version: go1.24 platform: darwin/arm64 directive: run @@ -900,12 +894,6 @@ timeouts: case: fixedbugs/issue40367.go timeout: 2m reason: issue40367 run exceeds the default timeout on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue4066.go - timeout: 2m - reason: issue4066 run exceeds the default timeout on darwin/arm64 - version: go1.26 platform: darwin/arm64 directive: run @@ -1385,16 +1373,6 @@ xfails: directive: runoutput case: rangegen.go reason: current main goroot runoutput failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue73916.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue73916b.go - reason: go1.26 goroot run failure on darwin/arm64 - platform: darwin/arm64 directive: run case: typeparam/mdempsky/16.go @@ -1409,16 +1387,6 @@ xfails: directive: run case: typeparam/mdempsky/16.go reason: nil-interface assertion panic implements runtime.Error but the message lacks the source interface type and prints the command-line-arguments package path on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue73916.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue73916b.go - reason: go1.26 goroot run failure on linux/amd64 - version: go1.24 platform: linux/amd64 directive: runoutput @@ -1586,16 +1554,6 @@ xfails: directive: run case: fixedbugs/issue27518b.go reason: go1.24 goroot run failure on linux/amd64 - - version: go1.24 - platform: linux/amd64 - directive: run - case: fixedbugs/issue4066.go - reason: go1.24 goroot run failure on linux/amd64 - - version: go1.24 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue4066.go - reason: go1.24 goroot run failure on darwin/arm64 - version: go1.24 platform: linux/amd64 directive: run @@ -1651,16 +1609,6 @@ xfails: directive: run case: fixedbugs/issue27518b.go reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue4066.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue4066.go - reason: go1.26 goroot run failure on darwin/arm64 - version: go1.26 platform: linux/amd64 directive: run From f7fa18b0a4c5fbdd7f318ea0b0958abdabf40f51 Mon Sep 17 00:00:00 2001 From: Li Jie Date: Mon, 10 Aug 2026 09:05:41 +0800 Subject: [PATCH 02/21] ssa,runtime: key recover permission by activation --- cl/compile.go | 5 ++- cl/recover_activation_test.go | 51 +++++++++++++++++++++++++ runtime/internal/runtime/z_rt.go | 10 +++++ ssa/decl.go | 1 + ssa/eh.go | 23 ++++++++++- test/go/recover_defer_fixedbugs_test.go | 28 ++++++++++++++ 6 files changed, 116 insertions(+), 2 deletions(-) create mode 100644 cl/recover_activation_test.go diff --git a/cl/compile.go b/cl/compile.go index 9a43867e97..f2d8cba453 100644 --- a/cl/compile.go +++ b/cl/compile.go @@ -662,7 +662,7 @@ func (p *context) compileFuncDecl(pkg llssa.Package, f *ssa.Function) (llssa.Fun if disableInline || noInlineDirective || runtimeStackNoInline || pcLineNoInline || functionUsesRecover(f) { fn.Inline(llssa.NoInline) } - if noInlineDirective || runtimeStackNoInline || pcLineNoInline { + if noInlineDirective || runtimeStackNoInline || pcLineNoInline || functionUsesRecover(f) { fn.DisableTailCalls() } if functionUsesRecover(f) { @@ -950,6 +950,9 @@ func (p *context) compileBlock(b llssa.Builder, block *ssa.BasicBlock, n int, do var instrs = block.Instrs[n:] var ret = fn.Block(block.Index) b.SetBlock(ret) + if block.Index == 0 && functionUsesRecover(block.Parent()) { + b.BindRecoverFrame() + } if block.Index == 0 { p.enterExportedLocalContext(b) } diff --git a/cl/recover_activation_test.go b/cl/recover_activation_test.go new file mode 100644 index 0000000000..3a67030c51 --- /dev/null +++ b/cl/recover_activation_test.go @@ -0,0 +1,51 @@ +//go:build !llgo + +/* + * Copyright (c) 2026 The XGo Authors (xgo.dev). All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package cl_test + +import ( + "regexp" + "strings" + "testing" + + "github.com/goplus/llgo/cl/cltest" +) + +func TestRecoverUsesActivationToken(t *testing.T) { + const src = `package foo + +func recursive(depth int) any { + if depth > 0 { + return recursive(depth - 1) + } + return recover() +} +` + ir := cltest.CompileIREx(t, src, "foo.go", false, nil) + + bind := regexp.MustCompile(`BindRecoverFrame"\(ptr @foo\.recursive, ptr (%[0-9]+)\)`).FindStringSubmatch(ir) + if bind == nil { + t.Fatalf("recover function does not bind an activation token:\n%s", ir) + } + if want := `Recover"(ptr ` + bind[1] + `)`; !strings.Contains(ir, want) { + t.Fatalf("recover does not use bound activation token %s:\n%s", bind[1], ir) + } + if !strings.Contains(ir, `noinline`) || !strings.Contains(ir, `"disable-tail-calls"="true"`) { + t.Fatalf("recover function must preserve its activation frame:\n%s", ir) + } +} diff --git a/runtime/internal/runtime/z_rt.go b/runtime/internal/runtime/z_rt.go index ccbe1a1d07..bc7cf9ae84 100644 --- a/runtime/internal/runtime/z_rt.go +++ b/runtime/internal/runtime/z_rt.go @@ -104,6 +104,16 @@ func EndRecoverFrame(frame unsafe.Pointer) { getg().recoverFrame = frame } +// BindRecoverFrame replaces a deferred function's code token with the unique +// stack token for this invocation. A recursive invocation of the same function +// sees the already-bound outer token and is therefore not allowed to recover. +func BindRecoverFrame(function, activation unsafe.Pointer) { + gp := getg() + if gp.recoverFrame == function { + gp.recoverFrame = activation + } +} + // StartRecoverFrameAlias maps a direct deferred closure wrapper to the wrapped // function while the wrapper calls into it. func StartRecoverFrameAlias(from, to unsafe.Pointer) unsafe.Pointer { diff --git a/ssa/decl.go b/ssa/decl.go index 68087f4380..43d1a87afc 100644 --- a/ssa/decl.go +++ b/ssa/decl.go @@ -242,6 +242,7 @@ type aFunction struct { blks []BasicBlock defer_ *aDefer + recoverToken Expr pendingLoopCases []loopDeferCase nextDeferID uintptr recov BasicBlock diff --git a/ssa/eh.go b/ssa/eh.go index 872d173f77..2122c5124a 100644 --- a/ssa/eh.go +++ b/ssa/eh.go @@ -751,10 +751,31 @@ func (b Builder) Unreachable() { b.impl.CreateUnreachable() } +// BindRecoverFrame gives this invocation a stack-local identity. The runtime +// replaces a pending deferred-function token with this activation token only +// when this invocation is the direct deferred call. Recursive calls to the +// same function therefore cannot recover the caller's panic. +func (b Builder) BindRecoverFrame() { + token := b.AllocaT(b.Prog.Byte()) + token = b.PtrCast(b.Prog.VoidPtr(), token) + b.Func.recoverToken = token + b.Call( + b.Pkg.rtFunc("BindRecoverFrame"), + b.PtrCast(b.Prog.VoidPtr(), b.Func.Expr), + token, + ) +} + // Recover emits a recover instruction. func (b Builder) Recover() Expr { dbgInstrln("Recover") - return b.Call(b.Pkg.rtFunc("Recover"), b.PtrCast(b.Prog.VoidPtr(), b.Func.Expr)) + token := b.Func.recoverToken + if token.IsNil() { + // Keep the lower-level Builder API usable for callers that emit recover + // without the Go frontend's function-entry binding. + token = b.PtrCast(b.Prog.VoidPtr(), b.Func.Expr) + } + return b.Call(b.Pkg.rtFunc("Recover"), token) } // Panic emits a panic instruction. diff --git a/test/go/recover_defer_fixedbugs_test.go b/test/go/recover_defer_fixedbugs_test.go index 376dc860bf..db96fca4d8 100644 --- a/test/go/recover_defer_fixedbugs_test.go +++ b/test/go/recover_defer_fixedbugs_test.go @@ -86,6 +86,34 @@ func TestRecoverFixedbugReturnedDeferredFuncValue(t *testing.T) { } } +var fixedbugRecursiveRecover any + +func fixedbugRecursiveDeferredRecover(depth int) { + if depth > 0 { + fixedbugRecursiveDeferredRecover(depth - 1) + return + } + fixedbugRecursiveRecover = recover() +} + +func TestRecoverRecursiveDeferredActivationDoesNotRecover(t *testing.T) { + fixedbugRecursiveRecover = "unset" + var outer any + func() { + defer func() { + outer = recover() + }() + defer fixedbugRecursiveDeferredRecover(1) + panic("recursive deferred activation") + }() + if fixedbugRecursiveRecover != nil { + t.Fatalf("recursive recover = %v, want nil", fixedbugRecursiveRecover) + } + if outer != "recursive deferred activation" { + t.Fatalf("outer recover = %v, want panic value", outer) + } +} + func fixedbug8047bNilDeferredCall() { var fn func() defer fn() From ec1678eddd5a973759675cb7e53d442f441e9ac1 Mon Sep 17 00:00:00 2001 From: Li Jie Date: Mon, 10 Aug 2026 10:01:08 +0800 Subject: [PATCH 03/21] ssa,cl: preserve recover through method wrappers --- cl/compile.go | 50 ++++++++++++++++++++-- cl/instr.go | 18 ++++++-- cl/recover_activation_test.go | 57 +++++++++++++++++++++++++ ssa/eh.go | 17 ++++++++ ssa/interface.go | 21 ++++++++- test/go/recover_defer_fixedbugs_test.go | 48 +++++++++++++++++++++ 6 files changed, 203 insertions(+), 8 deletions(-) diff --git a/cl/compile.go b/cl/compile.go index f2d8cba453..43c9cf94e6 100644 --- a/cl/compile.go +++ b/cl/compile.go @@ -659,13 +659,14 @@ func (p *context) compileFuncDecl(pkg llssa.Package, f *ssa.Function) (llssa.Fun noInlineDirective := hasNoInlineDirective(f) runtimeStackNoInline := needsRuntimeStackNoInline(pkgTypes, f) pcLineNoInline := p.needsPCLineNoInline(f) - if disableInline || noInlineDirective || runtimeStackNoInline || pcLineNoInline || functionUsesRecover(f) { + usesRecover := functionUsesRecover(f) + if disableInline || noInlineDirective || runtimeStackNoInline || pcLineNoInline || usesRecover { fn.Inline(llssa.NoInline) } - if noInlineDirective || runtimeStackNoInline || pcLineNoInline || functionUsesRecover(f) { + if noInlineDirective || runtimeStackNoInline || pcLineNoInline || usesRecover { fn.DisableTailCalls() } - if functionUsesRecover(f) { + if functionMayRecover(f) { fn.Expr = fn.Expr.MarkMayRecover() } p.funcs[f] = fn @@ -1964,6 +1965,49 @@ func functionUsesRecover(fn *ssa.Function) bool { return false } +func isRecoverTransparentWrapper(fn *ssa.Function) bool { + if fn == nil { + return false + } + return strings.HasPrefix(fn.Synthetic, "wrapper for ") || + strings.HasPrefix(fn.Synthetic, "thunk for ") || + strings.HasPrefix(fn.Synthetic, "bound method wrapper for ") +} + +func functionMayRecover(fn *ssa.Function) bool { + return functionMayRecoverSeen(fn, make(map[*ssa.Function]bool)) +} + +func functionMayRecoverSeen(fn *ssa.Function, seen map[*ssa.Function]bool) bool { + if fn == nil || seen[fn] { + return false + } + seen[fn] = true + if functionUsesRecover(fn) { + return true + } + if !isRecoverTransparentWrapper(fn) { + return false + } + for _, block := range fn.Blocks { + for _, instr := range block.Instrs { + call, ok := instr.(ssa.CallInstruction) + if !ok { + continue + } + common := call.Common() + if common.Method != nil { + // An interface wrapper can dispatch to a recover-capable method. + return true + } + if functionMayRecoverSeen(common.StaticCallee(), seen) { + return true + } + } + } + return false +} + func (p *context) compileFunction(v *ssa.Function) (goFn llssa.Function, pyFn llssa.PyObjRef, kind int) { // TODO(xsw) v.Pkg == nil: means auto generated function? if v.Pkg == p.goPkg || v.Pkg == nil { diff --git a/cl/instr.go b/cl/instr.go index 6ff03078be..24f8b11cc1 100644 --- a/cl/instr.go +++ b/cl/instr.go @@ -1812,6 +1812,9 @@ func (p *context) emitDo(b llssa.Builder, act llssa.DoAction, ds *explicitDeferS } switch act { case llssa.Call, llssa.Go: + if act == llssa.Call && isRecoverTransparentWrapper(p.goFn) { + return b.CallRecoverAlias(p.fn.Expr, mayRecover, fn, buildCall, args...) + } return b.Do(act, fn, buildCall, args...) default: b.DeferRecover(act, mayRecover, fn, buildCall, args...) @@ -1824,10 +1827,10 @@ func (p *context) callMayRecover(v ssa.Value) bool { case *ssa.Builtin: return false case *ssa.Function: - return functionUsesRecover(v) + return functionMayRecover(v) case *ssa.MakeClosure: if fn, ok := v.Fn.(*ssa.Function); ok { - return functionUsesRecover(fn) + return functionMayRecover(fn) } return true case *ssa.Call: @@ -1993,7 +1996,16 @@ func (p *context) callEx(b llssa.Builder, act llssa.DoAction, call *ssa.CallComm if mthd := call.Method; mthd != nil { reflectCheck := p.reflectTypeMethodCheck(call, mthd) o := p.compileValue(b, cv) - fn := b.Imethod(o, mthd) + var fn llssa.Expr + needsRecoverToken := act != llssa.Call && act != llssa.Go + if act == llssa.Call && isRecoverTransparentWrapper(p.goFn) { + needsRecoverToken = true + } + if needsRecoverToken { + fn = b.ImethodWithRecoverToken(o, mthd) + } else { + fn = b.Imethod(o, mthd) + } hasVArg := fnNormal if llssa.HasNameValist(call.Signature()) { hasVArg = fnHasVArg diff --git a/cl/recover_activation_test.go b/cl/recover_activation_test.go index 3a67030c51..dbf099b088 100644 --- a/cl/recover_activation_test.go +++ b/cl/recover_activation_test.go @@ -24,6 +24,7 @@ import ( "testing" "github.com/goplus/llgo/cl/cltest" + llssa "github.com/goplus/llgo/ssa" ) func TestRecoverUsesActivationToken(t *testing.T) { @@ -49,3 +50,59 @@ func recursive(depth int) any { t.Fatalf("recover function must preserve its activation frame:\n%s", ir) } } + +func TestRecoverInterfaceMethodIR(t *testing.T) { + const src = `package foo + +type I interface { recoverValue() } +type T int +func (T) recoverValue() { recover() } + func call(v I) { defer v.recoverValue() } +` + ir := cltest.CompileIREx(t, src, "foo.go", false, nil) + for _, want := range []string{ + `BindRecoverFrame"(ptr @foo.T.recoverValue`, + `StartRecoverFrameAlias"(ptr @"foo.(*T).recoverValue", ptr @foo.T.recoverValue)`, + `StartRecoverFrame"(ptr %`, + } { + if !strings.Contains(ir, want) { + t.Fatalf("missing recover wrapper handoff %q:\n%s", want, ir) + } + } +} + +func TestRecoverInterfaceMethodGlobalDCEIR(t *testing.T) { + const src = `package foo + +import "reflect" + +func call(method func(reflect.Type, int) reflect.Method, typ reflect.Type) reflect.Method { + return method(typ, 0) +} + +func use(typ reflect.Type) { + method := reflect.Type.Method + _ = call(method, typ) +} +` + ir := cltest.CompileIREx(t, src, "foo.go", false, func(prog llssa.Program) { + prog.EnableGoGlobalDCE(true) + }) + start := strings.Index(ir, `define %reflect.Method @"foo.Type.Method$thunk"`) + if start < 0 { + t.Fatalf("missing reflect.Type.Method thunk:\n%s", ir) + } + end := strings.Index(ir[start:], "\n}\n") + if end < 0 { + t.Fatalf("unterminated reflect.Type.Method thunk:\n%s", ir[start:]) + } + thunk := ir[start : start+end] + rawLoad := strings.Index(thunk, "load ptr, ptr") + checkedLoad := strings.Index(thunk, `metadata !"go.method.Method:func(int) reflect.Method"`) + alias := strings.Index(thunk, "StartRecoverFrameAlias") + resultCheck := strings.Index(thunk, `metadata !"go.method.type.reflect"`) + if rawLoad < 0 || checkedLoad < 0 || alias < 0 || resultCheck < 0 || + rawLoad > checkedLoad || checkedLoad > alias || alias > resultCheck { + t.Fatalf("recover-aware method thunk lost raw token or GlobalDCE checks:\n%s", thunk) + } +} diff --git a/ssa/eh.go b/ssa/eh.go index 2122c5124a..5ef41a36af 100644 --- a/ssa/eh.go +++ b/ssa/eh.go @@ -599,6 +599,23 @@ func (b Builder) callRecoverScopedDefer(fn Expr, mayRecover bool, call func()) { b.Call(b.Pkg.rtFunc("EndRecoverFrame"), prev) } +// CallRecoverAlias invokes fn through a compiler-generated wrapper while +// preserving the wrapped function as the direct deferred call for recover. +func (b Builder) CallRecoverAlias(from Expr, mayRecover bool, fn Expr, buildCall func(Builder, Expr, ...Expr) Expr, args ...Expr) Expr { + token := b.recoverDeferToken(fn, mayRecover) + if from.IsNil() || token.IsNil() { + return buildCall(b, fn, args...) + } + prev := b.Call( + b.Pkg.rtFunc("StartRecoverFrameAlias"), + b.PtrCast(b.Prog.VoidPtr(), from), + token, + ) + ret := buildCall(b, fn, args...) + b.Call(b.Pkg.rtFunc("EndRecoverFrame"), prev) + return ret +} + func (b Builder) recoverDeferToken(fn Expr, mayRecover bool) Expr { switch fn.kind { case vkClosure, vkIfaceMethod: diff --git a/ssa/interface.go b/ssa/interface.go index 556bf23baf..1fde542203 100644 --- a/ssa/interface.go +++ b/ssa/interface.go @@ -64,6 +64,16 @@ func iMethodOf(rawIntf *types.Interface, name string) int { // Imethod returns closure of an interface method. func (b Builder) Imethod(intf Expr, method *types.Func) Expr { + return b.imethod(intf, method, false) +} + +// ImethodWithRecoverToken returns an interface method invocation whose code +// pointer may also be used as recover-frame bookkeeping data. +func (b Builder) ImethodWithRecoverToken(intf Expr, method *types.Func) Expr { + return b.imethod(intf, method, true) +} + +func (b Builder) imethod(intf Expr, method *types.Func, recoverToken bool) Expr { prog := b.Prog intfType := types.Unalias(intf.raw.Type) patchedIntfType := prog.patch(intfType) @@ -84,11 +94,11 @@ func (b Builder) Imethod(intf Expr, method *types.Func) Expr { i := iMethodOf(rawIntf, method.Name()) b.recordUseIfaceMethod(rawIntf, i) data := b.InlineCall(b.Pkg.rtFunc("IfacePtrData"), intf) - var fn Expr impl := intf.impl itab := Expr{b.faceItab(impl), prog.VoidPtrPtr()} pfn := b.Advance(itab, prog.IntVal(uint64(i+3), prog.Int())) - if prog.enableGoGlobalDCE { + var fn Expr + if prog.enableGoGlobalDCE && !recoverToken { fnType := prog.Elem(pfn.Type) fn = Expr{ prog.methodCheckedLoad(b.impl, pfn.impl, methodCapabilityKey(method)), @@ -96,6 +106,13 @@ func (b Builder) Imethod(intf Expr, method *types.Func) Expr { } } else { fn = b.Load(pfn) + if prog.enableGoGlobalDCE { + // A type.checked.load result is a virtual-call capability, not a + // general-purpose pointer. Recover bookkeeping needs the same code + // address as ordinary data, so retain the capability check while + // carrying the raw itab load into the transient invocation pair. + prog.methodCheckedLoad(b.impl, pfn.impl, methodCapabilityKey(method)) + } } // This is a transient interface invocation pair, not a first-class // funcval. The method receiver remains an ordinary ABI parameter. diff --git a/test/go/recover_defer_fixedbugs_test.go b/test/go/recover_defer_fixedbugs_test.go index db96fca4d8..1f04b3a394 100644 --- a/test/go/recover_defer_fixedbugs_test.go +++ b/test/go/recover_defer_fixedbugs_test.go @@ -86,6 +86,54 @@ func TestRecoverFixedbugReturnedDeferredFuncValue(t *testing.T) { } } +type fixedbugRecoverMethod int + +var fixedbugMethodRecover any + +func (fixedbugRecoverMethod) recoverValue() { + fixedbugMethodRecover = recover() +} + +func TestRecoverDirectDeferredMethod(t *testing.T) { + fixedbugMethodRecover = nil + func() { + defer fixedbugRecoverMethod(0).recoverValue() + panic("direct deferred method") + }() + if fixedbugMethodRecover != "direct deferred method" { + t.Fatalf("direct deferred method recover = %v, want panic value", fixedbugMethodRecover) + } +} + +type fixedbugRecoverInterface interface { + recoverValue() +} + +func TestRecoverDirectDeferredInterfaceMethod(t *testing.T) { + fixedbugMethodRecover = nil + func() { + var v fixedbugRecoverInterface = fixedbugRecoverMethod(0) + defer v.recoverValue() + panic("direct deferred interface method") + }() + if fixedbugMethodRecover != "direct deferred interface method" { + t.Fatalf("direct deferred interface method recover = %v, want panic value", fixedbugMethodRecover) + } +} + +func TestRecoverDirectDeferredMethodValue(t *testing.T) { + fixedbugMethodRecover = nil + func() { + var v fixedbugRecoverInterface = fixedbugRecoverMethod(0) + f := v.recoverValue + defer f() + panic("direct deferred method value") + }() + if fixedbugMethodRecover != "direct deferred method value" { + t.Fatalf("direct deferred method value recover = %v, want panic value", fixedbugMethodRecover) + } +} + var fixedbugRecursiveRecover any func fixedbugRecursiveDeferredRecover(depth int) { From 170f176bc6e54d25ba8b1620ca1b32340be57501 Mon Sep 17 00:00:00 2001 From: Li Jie Date: Mon, 10 Aug 2026 10:01:09 +0800 Subject: [PATCH 04/21] cl: refresh recover IR snapshots --- cl/_testgo/cgodefer/cgodefer.go | 103 ++++-- cl/_testgo/closureall/in.go | 63 ++-- cl/_testgo/closureenv/in.go | 43 +-- cl/_testgo/defer4/in.go | 92 ++--- cl/_testgo/deferclosure/in.go | 34 +- cl/_testgo/deferiface/in.go | 31 +- cl/_testgo/genericembediface/in.go | 86 ++--- cl/_testgo/goexit/in.go | 192 +++++----- cl/_testgo/ifaceprom/in.go | 102 +++--- cl/_testgo/indexerr/in.go | 557 ++++++++++++++++------------- cl/_testgo/makeslice/in.go | 84 +++-- cl/_testgo/reader/in.go | 522 ++++++++++++++------------- cl/_testgo/recoverthenpanic/in.go | 166 ++++----- cl/_testgo/reflectconv/in.go | 169 ++++----- 14 files changed, 1204 insertions(+), 1040 deletions(-) diff --git a/cl/_testgo/cgodefer/cgodefer.go b/cl/_testgo/cgodefer/cgodefer.go index 5ce8dd6bfe..6925b641c8 100644 --- a/cl/_testgo/cgodefer/cgodefer.go +++ b/cl/_testgo/cgodefer/cgodefer.go @@ -6,6 +6,11 @@ package main */ import "C" +func main() { + p := C.malloc(1024) + defer C.free(p) +} + // CHECK-LABEL: define [0 x i8] @main._Cfunc_free(ptr %0){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %1 = call ptr @"{{.*}}/runtime/internal/runtime.AllocZ"(i64 8) @@ -15,6 +20,27 @@ import "C" // CHECK-NEXT: ret [0 x i8] %4 // CHECK-NEXT: } +// CHECK-LABEL: define ptr @main._Cgo_ptr(ptr %0){{.*}} { +// CHECK-NEXT: _llgo_0: +// CHECK-NEXT: ret ptr %0 +// CHECK-NEXT: } + +// CHECK-LABEL: define void @main.init(){{.*}} { +// CHECK-NEXT: _llgo_0: +// CHECK-NEXT: %0 = load i1, ptr @"main.init$guard", align 1 +// CHECK-NEXT: br i1 %0, label %_llgo_2, label %_llgo_1 +// CHECK-EMPTY: +// CHECK-NEXT: _llgo_1: ; preds = %_llgo_0 +// CHECK-NEXT: store i1 true, ptr @"main.init$guard", align 1 +// CHECK-NEXT: call void @syscall.init() +// CHECK-NEXT: store ptr @_cgo_{{.*}}_Cfunc_free, ptr @main._cgo_{{.*}}_Cfunc_free, align 8 +// CHECK-NEXT: store ptr @_cgo_{{.*}}_Cfunc__Cmalloc, ptr @main._cgo_{{.*}}_Cfunc__Cmalloc, align 8 +// CHECK-NEXT: br label %_llgo_2 +// CHECK-EMPTY: +// CHECK-NEXT: _llgo_2: ; preds = %_llgo_1, %_llgo_0 +// CHECK-NEXT: ret void +// CHECK-NEXT: } + // CHECK-LABEL: define void @main.main(){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %0 = call ptr @"{{.*}}/runtime/internal/runtime.AllocZ"(i64 8) @@ -45,7 +71,7 @@ import "C" // CHECK-NEXT: %17 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %10, i32 0, i32 4 // CHECK-NEXT: %18 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %10, i32 0, i32 5 // CHECK-NEXT: store ptr null, ptr %18, align 8 -// CHECK-NEXT: %19 = call i32 @{{.*}}sigsetjmp(ptr %9, i32 0) +// CHECK-NEXT: %19 = call i32 @{{(__)?}}sigsetjmp(ptr %9, i32 0) // CHECK-NEXT: %20 = icmp eq i32 %19, 0 // CHECK-NEXT: br i1 %20, label %_llgo_4, label %_llgo_5 // CHECK-EMPTY: @@ -91,44 +117,45 @@ import "C" // CHECK-NEXT: store ptr %32, ptr %18, align 8 // CHECK-NEXT: %33 = extractvalue { ptr, i64, { ptr, ptr } } %31, 2 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.FreeDeferNode"(ptr %30) -// CHECK-NEXT: %34 = extractvalue { ptr, ptr } %33, 1 -// CHECK-NEXT: %35 = extractvalue { ptr, ptr } %33, 0 -// CHECK-NEXT: %__llgo_funcval_code1 = call ptr asm "", "=r,0"(ptr %35) -// CHECK-NEXT: call void %__llgo_funcval_code1(ptr {{(nest|swiftself)}} %34) +// CHECK-NEXT: %34 = extractvalue { ptr, ptr } %33, 0 +// CHECK-NEXT: %35 = call ptr @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr %34) +// CHECK-NEXT: %36 = extractvalue { ptr, ptr } %33, 1 +// CHECK-NEXT: %37 = extractvalue { ptr, ptr } %33, 0 +// CHECK-NEXT: %__llgo_funcval_code1 = call ptr asm "", "=r,0"(ptr %37) +// CHECK-NEXT: call void %__llgo_funcval_code1(ptr {{(nest|swiftself)}} %36) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %35) // CHECK-NEXT: br label %_llgo_8 // CHECK-EMPTY: // CHECK-NEXT: _llgo_8: ; preds = %_llgo_7, %_llgo_2 -// CHECK-NEXT: %36 = load %"{{.*}}/runtime/internal/runtime.Defer", ptr %10, align 8 -// CHECK-NEXT: %37 = extractvalue %"{{.*}}/runtime/internal/runtime.Defer" %36, 2 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.SetThreadDefer"(ptr %37) -// CHECK-NEXT: %38 = load ptr, ptr %17, align 8 -// CHECK-NEXT: indirectbr ptr %38, [label %_llgo_3, label %_llgo_6] +// CHECK-NEXT: %38 = load %"{{.*}}/runtime/internal/runtime.Defer", ptr %10, align 8 +// CHECK-NEXT: %39 = extractvalue %"{{.*}}/runtime/internal/runtime.Defer" %38, 2 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.SetThreadDefer"(ptr %39) +// CHECK-NEXT: %40 = load ptr, ptr %17, align 8 +// CHECK-NEXT: indirectbr ptr %40, [label %_llgo_3, label %_llgo_6] +// CHECK-NEXT: } + +// CHECK-LABEL: define { ptr, ptr } @"main.main$1"(ptr {{(nest|swiftself)}} %0){{.*}} { +// CHECK-NEXT: _llgo_0: +// CHECK-NEXT: %1 = call ptr @"{{.*}}/runtime/internal/runtime.AllocZ"(i64 8) +// CHECK-NEXT: %2 = load { ptr }, ptr %0, align 8 +// CHECK-NEXT: %3 = extractvalue { ptr } %2, 0 +// CHECK-NEXT: %4 = load ptr, ptr %3, align 8 +// CHECK-NEXT: store ptr %4, ptr %1, align 8 +// CHECK-NEXT: %5 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 8) +// CHECK-NEXT: %6 = getelementptr inbounds { ptr }, ptr %5, i32 0, i32 0 +// CHECK-NEXT: store ptr %1, ptr %6, align 8 +// CHECK-NEXT: %7 = insertvalue { ptr, ptr } { ptr @"main.main$1$1", ptr undef }, ptr %5, 1 +// CHECK-NEXT: ret { ptr, ptr } %7 +// CHECK-NEXT: } + +// CHECK-LABEL: define void @"main.main$1$1"(ptr {{(nest|swiftself)}} %0){{.*}} { +// CHECK-NEXT: _llgo_0: +// CHECK-NEXT: %1 = load { ptr }, ptr %0, align 8 +// CHECK-NEXT: %2 = extractvalue { ptr } %1, 0 +// CHECK-NEXT: %3 = load ptr, ptr %2, align 8 +// CHECK-NEXT: %4 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_Pointer, ptr undef }, ptr %3, 1 +// CHECK-NEXT: %5 = extractvalue { ptr } %1, 0 +// CHECK-NEXT: %6 = load ptr, ptr %5, align 8 +// CHECK-NEXT: %7 = call [0 x i8] @main._Cfunc_free(ptr %6) +// CHECK-NEXT: ret void // CHECK-NEXT: } -func main() { - // CHECK-LABEL: define { ptr, ptr } @"main.main$1"(ptr {{(nest|swiftself)}} %0){{.*}} { - // CHECK-NEXT: _llgo_0: - // CHECK-NEXT: %1 = call ptr @"{{.*}}/runtime/internal/runtime.AllocZ"(i64 8) - // CHECK-NEXT: %2 = load { ptr }, ptr %0, align 8 - // CHECK-NEXT: %3 = extractvalue { ptr } %2, 0 - // CHECK-NEXT: %4 = load ptr, ptr %3, align 8 - // CHECK-NEXT: store ptr %4, ptr %1, align 8 - // CHECK-NEXT: %5 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 8) - // CHECK-NEXT: %6 = getelementptr inbounds { ptr }, ptr %5, i32 0, i32 0 - // CHECK-NEXT: store ptr %1, ptr %6, align 8 - // CHECK-NEXT: %7 = insertvalue { ptr, ptr } { ptr @"main.main$1$1", ptr undef }, ptr %5, 1 - // CHECK-NEXT: ret { ptr, ptr } %7 - // CHECK-NEXT: } - p := C.malloc(1024) - // CHECK-LABEL: define void @"main.main$1$1"(ptr {{(nest|swiftself)}} %0){{.*}} { - // CHECK-NEXT: _llgo_0: - // CHECK-NEXT: %1 = load { ptr }, ptr %0, align 8 - // CHECK-NEXT: %2 = extractvalue { ptr } %1, 0 - // CHECK-NEXT: %3 = load ptr, ptr %2, align 8 - // CHECK-NEXT: %4 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_Pointer, ptr undef }, ptr %3, 1 - // CHECK-NEXT: %5 = extractvalue { ptr } %1, 0 - // CHECK-NEXT: %6 = load ptr, ptr %5, align 8 - // CHECK-NEXT: %7 = call [0 x i8] @main._Cfunc_free(ptr %6) - // CHECK-NEXT: ret void - // CHECK-NEXT: } - defer C.free(p) -} diff --git a/cl/_testgo/closureall/in.go b/cl/_testgo/closureall/in.go index 5d7e0ed0d9..10e445f318 100644 --- a/cl/_testgo/closureall/in.go +++ b/cl/_testgo/closureall/in.go @@ -5,10 +5,10 @@ import _ "unsafe" // for go:linkname import "github.com/goplus/lib/c" -// CHECK: @0 = private unnamed_addr constant [46 x i8] c"{{.*}}/cl/_testgo/closureall.S", align 1 -// CHECK: @1 = private unnamed_addr constant [3 x i8] c"Inc", align 1 -// CHECK: @7 = private unnamed_addr constant [3 x i8] c"Add", align 1 -// CHECK: @9 = private unnamed_addr constant [23 x i8] c"interface{Add(int) int}", align 1 +// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [46 x i8] c"{{.*}}/cl/_testgo/closureall.S", align 1{{$}} +// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [3 x i8] c"Inc", align 1{{$}} +// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [3 x i8] c"Add", align 1{{$}} +// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [23 x i8] c"interface{Add(int) int}", align 1{{$}} //go:linkname cSqrt C.sqrt func cSqrt(x c.Double) c.Double @@ -30,29 +30,10 @@ type S struct { v int } -// CHECK-LABEL: define i64 @main.S.Inc(%main.S %0, i64 %1){{.*}} { -// CHECK-NEXT: _llgo_0: -// CHECK-NEXT: %2 = alloca %main.S, align 8 -// CHECK-NEXT: call void @llvm.memset.p0.i64(ptr %2, i8 0, i64 8, i1 false) -// CHECK-NEXT: store %main.S %0, ptr %2, align 8 -// CHECK-NEXT: %3 = getelementptr inbounds %main.S, ptr %2, i32 0, i32 0 -// CHECK-NEXT: %4 = load i64, ptr %3, align 8 -// CHECK-NEXT: %5 = add i64 %4, %1 -// CHECK-NEXT: ret i64 %5 -// CHECK-NEXT: } - func (s S) Inc(x int) int { return s.v + x } -// CHECK-LABEL: define i64 @"main.(*S).Add"(ptr %0, i64 %1){{.*}} { -// CHECK-NEXT: _llgo_0: -// CHECK-NEXT: %2 = getelementptr inbounds %main.S, ptr %0, i32 0, i32 0 -// CHECK-NEXT: %3 = load i64, ptr %2, align 8 -// CHECK-NEXT: %4 = add i64 %3, %1 -// CHECK-NEXT: ret i64 %4 -// CHECK-NEXT: } - func (s *S) Add(x int) int { return s.v + x } @@ -100,10 +81,29 @@ func makeWithFree(base int) Fn { return func(x int) int { return x + base } } +// CHECK-LABEL: define i64 @main.S.Inc(%main.S %0, i64 %1){{.*}} { +// CHECK-NEXT: _llgo_0: +// CHECK-NEXT: %2 = alloca %main.S, align 8 +// CHECK-NEXT: call void @llvm.memset.p0.i64(ptr %2, i8 0, i64 8, i1 false) +// CHECK-NEXT: store %main.S %0, ptr %2, align 8 +// CHECK-NEXT: %3 = getelementptr inbounds %main.S, ptr %2, i32 0, i32 0 +// CHECK-NEXT: %4 = load i64, ptr %3, align 8 +// CHECK-NEXT: %5 = add i64 %4, %1 +// CHECK-NEXT: ret i64 %5 +// CHECK-NEXT: } + +// CHECK-LABEL: define i64 @"main.(*S).Add"(ptr %0, i64 %1){{.*}} { +// CHECK-NEXT: _llgo_0: +// CHECK-NEXT: %2 = getelementptr inbounds %main.S, ptr %0, i32 0, i32 0 +// CHECK-NEXT: %3 = load i64, ptr %2, align 8 +// CHECK-NEXT: %4 = add i64 %3, %1 +// CHECK-NEXT: ret i64 %4 +// CHECK-NEXT: } + // CHECK-LABEL: define i64 @"main.(*S).Inc"(ptr %0, i64 %1){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %2 = icmp eq ptr %0, null -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicWrapNilPointer"(i1 %2, %"{{.*}}/runtime/internal/runtime.String" { ptr @0, i64 46 }, %"{{.*}}/runtime/internal/runtime.String" { ptr @1, i64 3 }) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicWrapNilPointer"(i1 %2, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 46 }, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 3 }) // CHECK-NEXT: %3 = load %main.S, ptr %0, align 8 // CHECK-NEXT: %4 = call i64 @main.S.Inc(%main.S %3, i64 %1) // CHECK-NEXT: ret i64 %4 @@ -184,13 +184,13 @@ func makeWithFree(base int) Fn { // CHECK-NEXT: %27 = extractvalue { ptr, ptr } %25, 0 // CHECK-NEXT: %__llgo_funcval_code3 = call ptr asm "", "=r,0"(ptr %27) // CHECK-NEXT: %28 = call i64 %__llgo_funcval_code3(ptr {{(nest|swiftself)}} %26, i64 9) -// CHECK-NEXT: %29 = call double @sqrt(double 4.000000e+00) +// CHECK-NEXT: %29 = call double @{{(sqrt|main.cSqrt)}}(double 4.000000e+00) // CHECK-NEXT: %30 = call i32 @main.callCInt({ ptr, ptr } { ptr @abs, ptr null }, i32 -3) // CHECK-NEXT: %31 = call i32 @main.callCallback(ptr @"main.main$1", i32 7) // CHECK-NEXT: ret void // CHECK-EMPTY: // CHECK-NEXT: _llgo_2: ; preds = %_llgo_0 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr %21, %"{{.*}}/runtime/internal/runtime.String" { ptr @9, i64 23 }, %"{{.*}}/runtime/internal/runtime.String" { ptr @7, i64 3 }) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr %21, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 23 }, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 3 }) // CHECK-NEXT: unreachable // CHECK-NEXT: } @@ -258,8 +258,11 @@ func makeWithFree(base int) Fn { // CHECK-NEXT: %7 = load ptr, ptr %6, align 8 // CHECK-NEXT: %8 = insertvalue { ptr, ptr } undef, ptr %7, 0 // CHECK-NEXT: %9 = insertvalue { ptr, ptr } %8, ptr %4, 1 -// CHECK-NEXT: %10 = extractvalue { ptr, ptr } %9, 1 -// CHECK-NEXT: %11 = extractvalue { ptr, ptr } %9, 0 -// CHECK-NEXT: %12 = call i64 %11(ptr %10, i64 %1) -// CHECK-NEXT: ret i64 %12 +// CHECK-NEXT: %10 = extractvalue { ptr, ptr } %9, 0 +// CHECK-NEXT: %11 = call ptr @"{{.*}}/runtime/internal/runtime.StartRecoverFrameAlias"(ptr @"main.interface{Add(int) int}.Add$bound", ptr %10) +// CHECK-NEXT: %12 = extractvalue { ptr, ptr } %9, 1 +// CHECK-NEXT: %13 = extractvalue { ptr, ptr } %9, 0 +// CHECK-NEXT: %14 = call i64 %13(ptr %12, i64 %1) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %11) +// CHECK-NEXT: ret i64 %14 // CHECK-NEXT: } diff --git a/cl/_testgo/closureenv/in.go b/cl/_testgo/closureenv/in.go index b83578930d..0ab147b9ad 100644 --- a/cl/_testgo/closureenv/in.go +++ b/cl/_testgo/closureenv/in.go @@ -1,14 +1,14 @@ // LITTEST package main -// CHECK: {{^}}@0 = private unnamed_addr constant [18 x i8] c"zero-sized capture", align 1{{$}} -// CHECK: {{^}}@2 = private unnamed_addr constant [26 x i8] c"zero-sized capture address", align 1{{$}} -// CHECK: {{^}}@3 = private unnamed_addr constant [26 x i8] c"zero-sized pointer capture", align 1{{$}} -// CHECK: {{^}}@6 = private unnamed_addr constant [5 x i8] c"IsNil", align 1{{$}} -// CHECK: {{^}}@10 = private unnamed_addr constant [23 x i8] c"interface{IsNil() bool}", align 1{{$}} -// CHECK: {{^}}@11 = private unnamed_addr constant [25 x i8] c"nil receiver method value", align 1{{$}} -// CHECK: {{^}}@12 = private unnamed_addr constant [2 x i8] c"ok", align 1{{$}} -// CHECK: {{^}}@13 = private unnamed_addr constant [32 x i8] c"typed-nil interface method value", align 1{{$}} +// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [18 x i8] c"zero-sized capture", align 1{{$}} +// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [26 x i8] c"zero-sized capture address", align 1{{$}} +// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [26 x i8] c"zero-sized pointer capture", align 1{{$}} +// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [5 x i8] c"IsNil", align 1{{$}} +// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [23 x i8] c"interface{IsNil() bool}", align 1{{$}} +// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [25 x i8] c"nil receiver method value", align 1{{$}} +// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [2 x i8] c"ok", align 1{{$}} +// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [32 x i8] c"typed-nil interface method value", align 1{{$}} type nilReceiver struct{} @@ -86,7 +86,7 @@ func main() { // CHECK-EMPTY: // CHECK-NEXT: _llgo_1: ; preds = %_llgo_0 // CHECK-NEXT: %5 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @0, i64 18 }, ptr %5, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 18 }, ptr %5, align 8 // CHECK-NEXT: %6 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %5, 1 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Panic"(%"{{.*}}/runtime/internal/runtime.eface" %6) // CHECK-NEXT: unreachable @@ -104,7 +104,7 @@ func main() { // CHECK-EMPTY: // CHECK-NEXT: _llgo_3: ; preds = %_llgo_2 // CHECK-NEXT: %14 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @2, i64 26 }, ptr %14, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 26 }, ptr %14, align 8 // CHECK-NEXT: %15 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %14, 1 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Panic"(%"{{.*}}/runtime/internal/runtime.eface" %15) // CHECK-NEXT: unreachable @@ -119,7 +119,7 @@ func main() { // CHECK-EMPTY: // CHECK-NEXT: _llgo_5: ; preds = %_llgo_4 // CHECK-NEXT: %20 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @3, i64 26 }, ptr %20, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 26 }, ptr %20, align 8 // CHECK-NEXT: %21 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %20, 1 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Panic"(%"{{.*}}/runtime/internal/runtime.eface" %21) // CHECK-NEXT: unreachable @@ -137,13 +137,13 @@ func main() { // CHECK-EMPTY: // CHECK-NEXT: _llgo_7: ; preds = %_llgo_6 // CHECK-NEXT: %28 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @11, i64 25 }, ptr %28, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 25 }, ptr %28, align 8 // CHECK-NEXT: %29 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %28, 1 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Panic"(%"{{.*}}/runtime/internal/runtime.eface" %29) // CHECK-NEXT: unreachable // CHECK-EMPTY: // CHECK-NEXT: _llgo_8: ; preds = %_llgo_6 -// CHECK-NEXT: %30 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$36psrSzSiKQuwmDQNUwPgWt23w6DHhlw0KM1_Hu7IbY", ptr @"*_llgo_main.nilReceiver") +// CHECK-NEXT: %30 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @"*_llgo_main.nilReceiver") // CHECK-NEXT: %31 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %30, 0 // CHECK-NEXT: %32 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %31, ptr null, 1 // CHECK-NEXT: %33 = call ptr @"{{.*}}/runtime/internal/runtime.IfaceType"(%"{{.*}}/runtime/internal/runtime.iface" %32) @@ -152,13 +152,13 @@ func main() { // CHECK-EMPTY: // CHECK-NEXT: _llgo_9: ; preds = %_llgo_11 // CHECK-NEXT: %35 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @13, i64 32 }, ptr %35, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 32 }, ptr %35, align 8 // CHECK-NEXT: %36 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %35, 1 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Panic"(%"{{.*}}/runtime/internal/runtime.eface" %36) // CHECK-NEXT: unreachable // CHECK-EMPTY: // CHECK-NEXT: _llgo_10: ; preds = %_llgo_11 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintString"(%"{{.*}}/runtime/internal/runtime.String" { ptr @12, i64 2 }) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintString"(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 2 }) // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintByte"(i8 10) // CHECK-NEXT: ret void // CHECK-EMPTY: @@ -174,7 +174,7 @@ func main() { // CHECK-NEXT: br i1 %42, label %_llgo_10, label %_llgo_9 // CHECK-EMPTY: // CHECK-NEXT: _llgo_12: ; preds = %_llgo_8 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr %33, %"{{.*}}/runtime/internal/runtime.String" { ptr @10, i64 23 }, %"{{.*}}/runtime/internal/runtime.String" { ptr @6, i64 5 }) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr %33, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 23 }, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 5 }) // CHECK-NEXT: unreachable // CHECK-NEXT: } @@ -248,8 +248,11 @@ func main() { // CHECK-NEXT: %6 = load ptr, ptr %5, align 8 // CHECK-NEXT: %7 = insertvalue { ptr, ptr } undef, ptr %6, 0 // CHECK-NEXT: %8 = insertvalue { ptr, ptr } %7, ptr %3, 1 -// CHECK-NEXT: %9 = extractvalue { ptr, ptr } %8, 1 -// CHECK-NEXT: %10 = extractvalue { ptr, ptr } %8, 0 -// CHECK-NEXT: %11 = call i1 %10(ptr %9) -// CHECK-NEXT: ret i1 %11 +// CHECK-NEXT: %9 = extractvalue { ptr, ptr } %8, 0 +// CHECK-NEXT: %10 = call ptr @"{{.*}}/runtime/internal/runtime.StartRecoverFrameAlias"(ptr @"main.interface{IsNil() bool}.IsNil$bound", ptr %9) +// CHECK-NEXT: %11 = extractvalue { ptr, ptr } %8, 1 +// CHECK-NEXT: %12 = extractvalue { ptr, ptr } %8, 0 +// CHECK-NEXT: %13 = call i1 %12(ptr %11) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %10) +// CHECK-NEXT: ret i1 %13 // CHECK-NEXT: } diff --git a/cl/_testgo/defer4/in.go b/cl/_testgo/defer4/in.go index 583580903e..c9dbafee92 100644 --- a/cl/_testgo/defer4/in.go +++ b/cl/_testgo/defer4/in.go @@ -48,7 +48,7 @@ func main() { // CHECK-LABEL: define void @main.fail(){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %0 = call ptr @"{{.*}}/runtime/internal/runtime.GetThreadDefer"() -// CHECK-NEXT: %1 = alloca i8 +// CHECK-NEXT: %1 = alloca i8, i64 {{.*}}, align 1 // CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 48) // CHECK-NEXT: %3 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, i32 0, i32 0 // CHECK-NEXT: store ptr %1, ptr %3, align 8 @@ -74,7 +74,9 @@ func main() { // CHECK-NEXT: _llgo_2: ; preds = %_llgo_5 // CHECK-NEXT: store ptr blockaddress(@main.fail, %_llgo_6), ptr %8, align 8 // CHECK-NEXT: %13 = load i64, ptr %7, align 8 +// CHECK-NEXT: %14 = call ptr @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr @"main.fail$1") // CHECK-NEXT: call void @"main.fail$1"() +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %14) // CHECK-NEXT: br label %_llgo_6 // CHECK-EMPTY: // CHECK-NEXT: _llgo_3: ; preds = %_llgo_5, %_llgo_8 @@ -82,78 +84,80 @@ func main() { // CHECK-NEXT: br label %_llgo_1 // CHECK-EMPTY: // CHECK-NEXT: _llgo_4: ; preds = %_llgo_0 -// CHECK-NEXT: %14 = load ptr, ptr %10, align 8 -// CHECK-NEXT: %15 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 32) -// CHECK-NEXT: %16 = getelementptr inbounds { ptr, i64, %"{{.*}}/runtime/internal/runtime.String" }, ptr %15, i32 0, i32 0 -// CHECK-NEXT: store ptr %14, ptr %16, align 8 -// CHECK-NEXT: %17 = getelementptr inbounds { ptr, i64, %"{{.*}}/runtime/internal/runtime.String" }, ptr %15, i32 0, i32 1 -// CHECK-NEXT: store i64 0, ptr %17, align 8 -// CHECK-NEXT: %18 = getelementptr inbounds { ptr, i64, %"{{.*}}/runtime/internal/runtime.String" }, ptr %15, i32 0, i32 2 -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 3 }, ptr %18, align 8 -// CHECK-NEXT: store ptr %15, ptr %10, align 8 -// CHECK-NEXT: %19 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 13 }, ptr %19, align 8 -// CHECK-NEXT: %20 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %19, 1 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Panic"(%"{{.*}}/runtime/internal/runtime.eface" %20) +// CHECK-NEXT: %15 = load ptr, ptr %10, align 8 +// CHECK-NEXT: %16 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 32) +// CHECK-NEXT: %17 = getelementptr inbounds { ptr, i64, %"{{.*}}/runtime/internal/runtime.String" }, ptr %16, i32 0, i32 0 +// CHECK-NEXT: store ptr %15, ptr %17, align 8 +// CHECK-NEXT: %18 = getelementptr inbounds { ptr, i64, %"{{.*}}/runtime/internal/runtime.String" }, ptr %16, i32 0, i32 1 +// CHECK-NEXT: store i64 0, ptr %18, align 8 +// CHECK-NEXT: %19 = getelementptr inbounds { ptr, i64, %"{{.*}}/runtime/internal/runtime.String" }, ptr %16, i32 0, i32 2 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 3 }, ptr %19, align 8 +// CHECK-NEXT: store ptr %16, ptr %10, align 8 +// CHECK-NEXT: %20 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 13 }, ptr %20, align 8 +// CHECK-NEXT: %21 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %20, 1 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Panic"(%"{{.*}}/runtime/internal/runtime.eface" %21) // CHECK-NEXT: unreachable // CHECK-EMPTY: // CHECK-NEXT: _llgo_5: ; preds = %_llgo_0 // CHECK-NEXT: store ptr blockaddress(@main.fail, %_llgo_3), ptr %9, align 8 -// CHECK-NEXT: %21 = load ptr, ptr %8, align 8 -// CHECK-NEXT: indirectbr ptr %21, [label %_llgo_3, label %_llgo_6, label %_llgo_2] +// CHECK-NEXT: %22 = load ptr, ptr %8, align 8 +// CHECK-NEXT: indirectbr ptr %22, [label %_llgo_3, label %_llgo_6, label %_llgo_2] // CHECK-EMPTY: // CHECK-NEXT: _llgo_6: ; preds = %_llgo_5, %_llgo_2 // CHECK-NEXT: store ptr blockaddress(@main.fail, %_llgo_3), ptr %8, align 8 -// CHECK-NEXT: %22 = load i64, ptr %7, align 8 -// CHECK-NEXT: %23 = load ptr, ptr %10, align 8 -// CHECK-NEXT: %24 = icmp ne ptr %23, null -// CHECK-NEXT: br i1 %24, label %_llgo_7, label %_llgo_8 +// CHECK-NEXT: %23 = load i64, ptr %7, align 8 +// CHECK-NEXT: %24 = load ptr, ptr %10, align 8 +// CHECK-NEXT: %25 = icmp ne ptr %24, null +// CHECK-NEXT: br i1 %25, label %_llgo_7, label %_llgo_8 // CHECK-EMPTY: // CHECK-NEXT: _llgo_7: ; preds = %_llgo_6 -// CHECK-NEXT: %25 = load ptr, ptr %10, align 8 -// CHECK-NEXT: %26 = load { ptr, i64, %"{{.*}}/runtime/internal/runtime.String" }, ptr %25, align 8 -// CHECK-NEXT: %27 = extractvalue { ptr, i64, %"{{.*}}/runtime/internal/runtime.String" } %26, 0 -// CHECK-NEXT: store ptr %27, ptr %10, align 8 -// CHECK-NEXT: %28 = extractvalue { ptr, i64, %"{{.*}}/runtime/internal/runtime.String" } %26, 2 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.FreeDeferNode"(ptr %25) -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintString"(%"{{.*}}/runtime/internal/runtime.String" %28) +// CHECK-NEXT: %26 = load ptr, ptr %10, align 8 +// CHECK-NEXT: %27 = load { ptr, i64, %"{{.*}}/runtime/internal/runtime.String" }, ptr %26, align 8 +// CHECK-NEXT: %28 = extractvalue { ptr, i64, %"{{.*}}/runtime/internal/runtime.String" } %27, 0 +// CHECK-NEXT: store ptr %28, ptr %10, align 8 +// CHECK-NEXT: %29 = extractvalue { ptr, i64, %"{{.*}}/runtime/internal/runtime.String" } %27, 2 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.FreeDeferNode"(ptr %26) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintString"(%"{{.*}}/runtime/internal/runtime.String" %29) // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintByte"(i8 10) // CHECK-NEXT: br label %_llgo_8 // CHECK-EMPTY: // CHECK-NEXT: _llgo_8: ; preds = %_llgo_7, %_llgo_6 -// CHECK-NEXT: %29 = load %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, align 8 -// CHECK-NEXT: %30 = extractvalue %"{{.*}}/runtime/internal/runtime.Defer" %29, 2 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.SetThreadDefer"(ptr %30) -// CHECK-NEXT: %31 = load ptr, ptr %9, align 8 -// CHECK-NEXT: indirectbr ptr %31, [label %_llgo_3] +// CHECK-NEXT: %30 = load %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, align 8 +// CHECK-NEXT: %31 = extractvalue %"{{.*}}/runtime/internal/runtime.Defer" %30, 2 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.SetThreadDefer"(ptr %31) +// CHECK-NEXT: %32 = load ptr, ptr %9, align 8 +// CHECK-NEXT: indirectbr ptr %32, [label %_llgo_3] // CHECK-NEXT: } // CHECK-LABEL: define void @"main.fail$1"(){{.*}} { // CHECK-NEXT: _llgo_0: -// CHECK-NEXT: %0 = call %"{{.*}}/runtime/internal/runtime.eface" @"{{.*}}/runtime/internal/runtime.Recover"() -// CHECK-NEXT: %1 = call i1 @"{{.*}}/runtime/internal/runtime.EfaceEqual"(%"{{.*}}/runtime/internal/runtime.eface" %0, %"{{.*}}/runtime/internal/runtime.eface" zeroinitializer) -// CHECK-NEXT: %2 = xor i1 %1, true -// CHECK-NEXT: br i1 %2, label %_llgo_1, label %_llgo_2 +// CHECK-NEXT: %0 = alloca i8, align 1 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.BindRecoverFrame"(ptr @"main.fail$1", ptr %0) +// CHECK-NEXT: %1 = call %"{{.*}}/runtime/internal/runtime.eface" @"{{.*}}/runtime/internal/runtime.Recover"(ptr %0) +// CHECK-NEXT: %2 = call i1 @"{{.*}}/runtime/internal/runtime.EfaceEqual"(%"{{.*}}/runtime/internal/runtime.eface" %1, %"{{.*}}/runtime/internal/runtime.eface" zeroinitializer) +// CHECK-NEXT: %3 = xor i1 %2, true +// CHECK-NEXT: br i1 %3, label %_llgo_1, label %_llgo_2 // CHECK-EMPTY: // CHECK-NEXT: _llgo_1: ; preds = %_llgo_0 -// CHECK-NEXT: %3 = extractvalue %"{{.*}}/runtime/internal/runtime.eface" %0, 0 -// CHECK-NEXT: %4 = icmp eq ptr %3, @_llgo_string -// CHECK-NEXT: br i1 %4, label %_llgo_3, label %_llgo_4 +// CHECK-NEXT: %4 = extractvalue %"{{.*}}/runtime/internal/runtime.eface" %1, 0 +// CHECK-NEXT: %5 = icmp eq ptr %4, @_llgo_string +// CHECK-NEXT: br i1 %5, label %_llgo_3, label %_llgo_4 // CHECK-EMPTY: // CHECK-NEXT: _llgo_2: ; preds = %_llgo_3, %_llgo_0 // CHECK-NEXT: ret void // CHECK-EMPTY: // CHECK-NEXT: _llgo_3: ; preds = %_llgo_1 -// CHECK-NEXT: %5 = extractvalue %"{{.*}}/runtime/internal/runtime.eface" %0, 1 -// CHECK-NEXT: %6 = load %"{{.*}}/runtime/internal/runtime.String", ptr %5, align 8 +// CHECK-NEXT: %6 = extractvalue %"{{.*}}/runtime/internal/runtime.eface" %1, 1 +// CHECK-NEXT: %7 = load %"{{.*}}/runtime/internal/runtime.String", ptr %6, align 8 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintString"(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 8 }) // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintByte"(i8 32) -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintString"(%"{{.*}}/runtime/internal/runtime.String" %6) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintString"(%"{{.*}}/runtime/internal/runtime.String" %7) // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintByte"(i8 10) // CHECK-NEXT: br label %_llgo_2 // CHECK-EMPTY: // CHECK-NEXT: _llgo_4: ; preds = %_llgo_1 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr %3, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 6 }, %"{{.*}}/runtime/internal/runtime.String" zeroinitializer) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr %4, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 6 }, %"{{.*}}/runtime/internal/runtime.String" zeroinitializer) // CHECK-NEXT: unreachable // CHECK-NEXT: } @@ -173,7 +177,7 @@ func main() { // CHECK-LABEL: define void @main.main(){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %0 = call ptr @"{{.*}}/runtime/internal/runtime.GetThreadDefer"() -// CHECK-NEXT: %1 = alloca i8 +// CHECK-NEXT: %1 = alloca i8, i64 {{.*}}, align 1 // CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 48) // CHECK-NEXT: %3 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, i32 0, i32 0 // CHECK-NEXT: store ptr %1, ptr %3, align 8 diff --git a/cl/_testgo/deferclosure/in.go b/cl/_testgo/deferclosure/in.go index ecd61152a3..7c87545949 100644 --- a/cl/_testgo/deferclosure/in.go +++ b/cl/_testgo/deferclosure/in.go @@ -133,7 +133,7 @@ func main() { // CHECK-NEXT: store ptr %0, ptr %2, align 8 // CHECK-NEXT: %3 = insertvalue { ptr, ptr } { ptr @"main.testDeferClosureValue$1", ptr undef }, ptr %1, 1 // CHECK-NEXT: %4 = call ptr @"{{.*}}/runtime/internal/runtime.GetThreadDefer"() -// CHECK-NEXT: %5 = alloca i8 +// CHECK-NEXT: %5 = alloca i8, i64 {{.*}}, align 1 // CHECK-NEXT: %6 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 48) // CHECK-NEXT: %7 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %6, i32 0, i32 0 // CHECK-NEXT: store ptr %5, ptr %7, align 8 @@ -227,12 +227,13 @@ func main() { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %0 = alloca %main.FuncHolder, align 8 // CHECK-NEXT: call void @llvm.memset.p0.i64(ptr %0, i8 0, i64 16, i1 false) +// CHECK-NEXT: store volatile %main.FuncHolder zeroinitializer, ptr %0, align 8 // CHECK-NEXT: %1 = getelementptr inbounds %main.FuncHolder, ptr %0, i32 0, i32 0 -// CHECK-NEXT: store { ptr, ptr } { ptr @"main.testDeferFieldAccess$1", ptr null }, ptr %1, align 8 +// CHECK-NEXT: store volatile { ptr, ptr } { ptr @"main.testDeferFieldAccess$1", ptr null }, ptr %1, align 8 // CHECK-NEXT: %2 = getelementptr inbounds %main.FuncHolder, ptr %0, i32 0, i32 0 -// CHECK-NEXT: %3 = load { ptr, ptr }, ptr %2, align 8 +// CHECK-NEXT: %3 = load volatile { ptr, ptr }, ptr %2, align 8 // CHECK-NEXT: %4 = call ptr @"{{.*}}/runtime/internal/runtime.GetThreadDefer"() -// CHECK-NEXT: %5 = alloca i8 +// CHECK-NEXT: %5 = alloca i8, i64 {{.*}}, align 1 // CHECK-NEXT: %6 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 48) // CHECK-NEXT: %7 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %6, i32 0, i32 0 // CHECK-NEXT: store ptr %5, ptr %7, align 8 @@ -296,18 +297,21 @@ func main() { // CHECK-NEXT: store ptr %28, ptr %14, align 8 // CHECK-NEXT: %29 = extractvalue { ptr, i64, { ptr, ptr } } %27, 2 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.FreeDeferNode"(ptr %26) -// CHECK-NEXT: %30 = extractvalue { ptr, ptr } %29, 1 -// CHECK-NEXT: %31 = extractvalue { ptr, ptr } %29, 0 -// CHECK-NEXT: %__llgo_funcval_code = call ptr asm "", "=r,0"(ptr %31) -// CHECK-NEXT: call void %__llgo_funcval_code(ptr {{(nest|swiftself)}} %30) +// CHECK-NEXT: %30 = extractvalue { ptr, ptr } %29, 0 +// CHECK-NEXT: %31 = call ptr @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr %30) +// CHECK-NEXT: %32 = extractvalue { ptr, ptr } %29, 1 +// CHECK-NEXT: %33 = extractvalue { ptr, ptr } %29, 0 +// CHECK-NEXT: %__llgo_funcval_code = call ptr asm "", "=r,0"(ptr %33) +// CHECK-NEXT: call void %__llgo_funcval_code(ptr {{(nest|swiftself)}} %32) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %31) // CHECK-NEXT: br label %_llgo_8 // CHECK-EMPTY: // CHECK-NEXT: _llgo_8: ; preds = %_llgo_7, %_llgo_2 -// CHECK-NEXT: %32 = load %"{{.*}}/runtime/internal/runtime.Defer", ptr %6, align 8 -// CHECK-NEXT: %33 = extractvalue %"{{.*}}/runtime/internal/runtime.Defer" %32, 2 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.SetThreadDefer"(ptr %33) -// CHECK-NEXT: %34 = load ptr, ptr %13, align 8 -// CHECK-NEXT: indirectbr ptr %34, [label %_llgo_3, label %_llgo_6] +// CHECK-NEXT: %34 = load %"{{.*}}/runtime/internal/runtime.Defer", ptr %6, align 8 +// CHECK-NEXT: %35 = extractvalue %"{{.*}}/runtime/internal/runtime.Defer" %34, 2 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.SetThreadDefer"(ptr %35) +// CHECK-NEXT: %36 = load ptr, ptr %13, align 8 +// CHECK-NEXT: indirectbr ptr %36, [label %_llgo_3, label %_llgo_6] // CHECK-NEXT: } // CHECK-LABEL: define void @"main.testDeferFieldAccess$1"(){{.*}} { @@ -322,7 +326,7 @@ func main() { // CHECK-NEXT: %0 = call ptr @"{{.*}}/runtime/internal/runtime.AllocZ"(i64 16) // CHECK-NEXT: call void @"main.(*Handler).SetHandler"(ptr %0, { ptr, ptr } { ptr @"main.testDeferMethodLiteral$1", ptr null }) // CHECK-NEXT: %1 = call ptr @"{{.*}}/runtime/internal/runtime.GetThreadDefer"() -// CHECK-NEXT: %2 = alloca i8 +// CHECK-NEXT: %2 = alloca i8, i64 {{.*}}, align 1 // CHECK-NEXT: %3 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 48) // CHECK-NEXT: %4 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %3, i32 0, i32 0 // CHECK-NEXT: store ptr %2, ptr %4, align 8 @@ -426,7 +430,7 @@ func main() { // CHECK-NEXT: store ptr %1, ptr %3, align 8 // CHECK-NEXT: %4 = insertvalue { ptr, ptr } { ptr @"main.testDeferStructClosure$1", ptr undef }, ptr %2, 1 // CHECK-NEXT: %5 = call ptr @"{{.*}}/runtime/internal/runtime.GetThreadDefer"() -// CHECK-NEXT: %6 = alloca i8 +// CHECK-NEXT: %6 = alloca i8, i64 {{.*}}, align 1 // CHECK-NEXT: %7 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 48) // CHECK-NEXT: %8 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %7, i32 0, i32 0 // CHECK-NEXT: store ptr %6, ptr %8, align 8 diff --git a/cl/_testgo/deferiface/in.go b/cl/_testgo/deferiface/in.go index bcee22b9ae..74d4c7e1ab 100644 --- a/cl/_testgo/deferiface/in.go +++ b/cl/_testgo/deferiface/in.go @@ -1,8 +1,8 @@ // LITTEST package main -// CHECK: {{^}}@0 = private unnamed_addr constant [5 x i8] c"reset", align 1{{$}} -// CHECK: {{^}}@8 = private unnamed_addr constant [4 x i8] c"body", align 1{{$}} +// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [5 x i8] c"reset", align 1{{$}} +// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [4 x i8] c"body", align 1{{$}} type resetter interface { Reset() @@ -42,7 +42,7 @@ func main() { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %1 = getelementptr inbounds %main.item, ptr %0, i32 0, i32 0 // CHECK-NEXT: %2 = load i64, ptr %1, align 8 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintString"(%"{{.*}}/runtime/internal/runtime.String" { ptr @0, i64 5 }) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintString"(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 5 }) // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintByte"(i8 32) // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintInt"(i64 %2) // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintByte"(i8 10) @@ -54,7 +54,7 @@ func main() { // CHECK-NEXT: %0 = call ptr @"{{.*}}/runtime/internal/runtime.AllocZ"(i64 8) // CHECK-NEXT: %1 = getelementptr inbounds %main.item, ptr %0, i32 0, i32 0 // CHECK-NEXT: store i64 42, ptr %1, align 8 -// CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$yjH5fOWhYIH6Pv7ce-kmK-CVKIWOLvKPVzRvjwBotEM", ptr @"*_llgo_main.item") +// CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @"*_llgo_main.item") // CHECK-NEXT: %3 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %2, 0 // CHECK-NEXT: %4 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %3, ptr %0, 1 // CHECK-NEXT: call void @main.run(%"{{.*}}/runtime/internal/runtime.iface" %4) @@ -86,7 +86,7 @@ func main() { // CHECK-NEXT: %16 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %9, i32 0, i32 4 // CHECK-NEXT: %17 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %9, i32 0, i32 5 // CHECK-NEXT: store ptr null, ptr %17, align 8 -// CHECK-NEXT: %18 = call i32 @{{.*}}sigsetjmp(ptr %8, i32 0) +// CHECK-NEXT: %18 = call i32 @{{(__)?}}sigsetjmp(ptr %8, i32 0) // CHECK-NEXT: %19 = icmp eq i32 %18, 0 // CHECK-NEXT: br i1 %19, label %_llgo_4, label %_llgo_5 // CHECK-EMPTY: @@ -114,7 +114,7 @@ func main() { // CHECK-NEXT: %27 = getelementptr inbounds { ptr, i64, { ptr, ptr } }, ptr %24, i32 0, i32 2 // CHECK-NEXT: store { ptr, ptr } %6, ptr %27, align 8 // CHECK-NEXT: store ptr %24, ptr %17, align 8 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintString"(%"{{.*}}/runtime/internal/runtime.String" { ptr @8, i64 4 }) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintString"(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 4 }) // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintByte"(i8 10) // CHECK-NEXT: store ptr blockaddress(@main.run, %_llgo_6), ptr %16, align 8 // CHECK-NEXT: br label %_llgo_2 @@ -134,15 +134,18 @@ func main() { // CHECK-NEXT: store ptr %31, ptr %17, align 8 // CHECK-NEXT: %32 = extractvalue { ptr, i64, { ptr, ptr } } %30, 2 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.FreeDeferNode"(ptr %29) -// CHECK-NEXT: %33 = extractvalue { ptr, ptr } %32, 1 -// CHECK-NEXT: %34 = extractvalue { ptr, ptr } %32, 0 -// CHECK-NEXT: call void %34(ptr %33) +// CHECK-NEXT: %33 = extractvalue { ptr, ptr } %32, 0 +// CHECK-NEXT: %34 = call ptr @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr %33) +// CHECK-NEXT: %35 = extractvalue { ptr, ptr } %32, 1 +// CHECK-NEXT: %36 = extractvalue { ptr, ptr } %32, 0 +// CHECK-NEXT: call void %36(ptr %35) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %34) // CHECK-NEXT: br label %_llgo_8 // CHECK-EMPTY: // CHECK-NEXT: _llgo_8: ; preds = %_llgo_7, %_llgo_2 -// CHECK-NEXT: %35 = load %"{{.*}}/runtime/internal/runtime.Defer", ptr %9, align 8 -// CHECK-NEXT: %36 = extractvalue %"{{.*}}/runtime/internal/runtime.Defer" %35, 2 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.SetThreadDefer"(ptr %36) -// CHECK-NEXT: %37 = load ptr, ptr %16, align 8 -// CHECK-NEXT: indirectbr ptr %37, [label %_llgo_3, label %_llgo_6] +// CHECK-NEXT: %37 = load %"{{.*}}/runtime/internal/runtime.Defer", ptr %9, align 8 +// CHECK-NEXT: %38 = extractvalue %"{{.*}}/runtime/internal/runtime.Defer" %37, 2 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.SetThreadDefer"(ptr %38) +// CHECK-NEXT: %39 = load ptr, ptr %16, align 8 +// CHECK-NEXT: indirectbr ptr %39, [label %_llgo_3, label %_llgo_6] // CHECK-NEXT: } diff --git a/cl/_testgo/genericembediface/in.go b/cl/_testgo/genericembediface/in.go index be2c2122ee..95472a2c13 100644 --- a/cl/_testgo/genericembediface/in.go +++ b/cl/_testgo/genericembediface/in.go @@ -5,12 +5,12 @@ import ( "github.com/goplus/llgo/cl/_testgo/genericembediface/streamlib" ) -// CHECK: {{^}}@2 = private unnamed_addr constant [20 x i8] c"ServerReflectionInfo", align 1{{$}} -// CHECK: {{^}}@5 = private unnamed_addr constant [7 x i8] c"Context", align 1{{$}} -// CHECK: {{^}}@11 = private unnamed_addr constant [68 x i8] c"{{.*}}/cl/_testgo/genericembediface.ReflectionServer", align 1{{$}} -// CHECK: {{^}}@19 = private unnamed_addr constant [4 x i8] c"pass", align 1{{$}} -// CHECK: {{^}}@20 = private unnamed_addr constant [58 x i8] c"{{.*}}/cl/_testgo/genericembediface.server", align 1{{$}} -// CHECK: {{^}}@21 = private unnamed_addr constant [58 x i8] c"{{.*}}/cl/_testgo/genericembediface.stream", align 1{{$}} +// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [20 x i8] c"ServerReflectionInfo", align 1{{$}} +// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [7 x i8] c"Context", align 1{{$}} +// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [68 x i8] c"{{.*}}/cl/_testgo/genericembediface.ReflectionServer", align 1{{$}} +// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [4 x i8] c"pass", align 1{{$}} +// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [58 x i8] c"{{.*}}/cl/_testgo/genericembediface.server", align 1{{$}} +// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [58 x i8] c"{{.*}}/cl/_testgo/genericembediface.stream", align 1{{$}} type Request struct{} type Response struct{} @@ -19,6 +19,27 @@ type ReflectionServer interface { ServerReflectionInfo(streamlib.BidiStreamingServer[Request, Response]) error } +func handler(srv any, stream streamlib.ServerStream) error { + return srv.(ReflectionServer).ServerReflectionInfo(&streamlib.GenericServerStream[Request, Response]{ServerStream: stream}) +} + +type server struct{} + +func (server) ServerReflectionInfo(streamlib.BidiStreamingServer[Request, Response]) error { + return nil +} + +type stream struct{} + +func (stream) Context() string { + return "Context" +} + +func main() { + _ = handler(server{}, stream{}) + println("pass") +} + // CHECK-LABEL: define %"{{.*}}/runtime/internal/runtime.iface" @main.handler(%"{{.*}}/runtime/internal/runtime.eface" %0, %"{{.*}}/runtime/internal/runtime.iface" %1){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %2 = extractvalue %"{{.*}}/runtime/internal/runtime.eface" %0, 0 @@ -48,7 +69,7 @@ type ReflectionServer interface { // CHECK-NEXT: ret %"{{.*}}/runtime/internal/runtime.iface" %21 // CHECK-EMPTY: // CHECK-NEXT: _llgo_2: ; preds = %_llgo_0 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr %2, %"{{.*}}/runtime/internal/runtime.String" { ptr @11, i64 68 }, %"{{.*}}/runtime/internal/runtime.String" { ptr @2, i64 20 }) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr %2, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 68 }, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 20 }) // CHECK-NEXT: unreachable // CHECK-NEXT: } @@ -66,22 +87,6 @@ type ReflectionServer interface { // CHECK-NEXT: ret void // CHECK-NEXT: } -func handler(srv any, stream streamlib.ServerStream) error { - return srv.(ReflectionServer).ServerReflectionInfo(&streamlib.GenericServerStream[Request, Response]{ServerStream: stream}) -} - -type server struct{} - -func (server) ServerReflectionInfo(streamlib.BidiStreamingServer[Request, Response]) error { - return nil -} - -type stream struct{} - -func (stream) Context() string { - return "Context" -} - // CHECK-LABEL: define void @main.main(){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %0 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 0) @@ -93,7 +98,7 @@ func (stream) Context() string { // CHECK-NEXT: %4 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %3, 0 // CHECK-NEXT: %5 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %4, ptr %2, 1 // CHECK-NEXT: %6 = call %"{{.*}}/runtime/internal/runtime.iface" @main.handler(%"{{.*}}/runtime/internal/runtime.eface" %1, %"{{.*}}/runtime/internal/runtime.iface" %5) -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintString"(%"{{.*}}/runtime/internal/runtime.String" { ptr @19, i64 4 }) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintString"(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 4 }) // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintByte"(i8 10) // CHECK-NEXT: ret void // CHECK-NEXT: } @@ -103,15 +108,10 @@ func (stream) Context() string { // CHECK-NEXT: ret %"{{.*}}/runtime/internal/runtime.iface" zeroinitializer // CHECK-NEXT: } -func main() { - _ = handler(server{}, stream{}) - println("pass") -} - // CHECK-LABEL: define %"{{.*}}/runtime/internal/runtime.iface" @"main.(*server).ServerReflectionInfo"(ptr %0, %"{{.*}}/runtime/internal/runtime.iface" %1){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %2 = icmp eq ptr %0, null -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicWrapNilPointer"(i1 %2, %"{{.*}}/runtime/internal/runtime.String" { ptr @20, i64 58 }, %"{{.*}}/runtime/internal/runtime.String" { ptr @2, i64 20 }) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicWrapNilPointer"(i1 %2, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 58 }, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 20 }) // CHECK-NEXT: %3 = icmp eq ptr %0, null // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.AssertNilDeref"(i1 %3) // CHECK-NEXT: %4 = call %"{{.*}}/runtime/internal/runtime.iface" @main.server.ServerReflectionInfo(%main.server zeroinitializer, %"{{.*}}/runtime/internal/runtime.iface" %1) @@ -120,13 +120,13 @@ func main() { // CHECK-LABEL: define %"{{.*}}/runtime/internal/runtime.String" @main.stream.Context(%main.stream %0){{.*}} { // CHECK-NEXT: _llgo_0: -// CHECK-NEXT: ret %"{{.*}}/runtime/internal/runtime.String" { ptr @5, i64 7 } +// CHECK-NEXT: ret %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 7 } // CHECK-NEXT: } // CHECK-LABEL: define %"{{.*}}/runtime/internal/runtime.String" @"main.(*stream).Context"(ptr %0){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %1 = icmp eq ptr %0, null -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicWrapNilPointer"(i1 %1, %"{{.*}}/runtime/internal/runtime.String" { ptr @21, i64 58 }, %"{{.*}}/runtime/internal/runtime.String" { ptr @5, i64 7 }) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicWrapNilPointer"(i1 %1, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 58 }, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 7 }) // CHECK-NEXT: %2 = icmp eq ptr %0, null // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.AssertNilDeref"(i1 %2) // CHECK-NEXT: %3 = call %"{{.*}}/runtime/internal/runtime.String" @main.stream.Context(%main.stream zeroinitializer) @@ -143,10 +143,13 @@ func main() { // CHECK-NEXT: %6 = load ptr, ptr %5, align 8 // CHECK-NEXT: %7 = insertvalue { ptr, ptr } undef, ptr %6, 0 // CHECK-NEXT: %8 = insertvalue { ptr, ptr } %7, ptr %3, 1 -// CHECK-NEXT: %9 = extractvalue { ptr, ptr } %8, 1 -// CHECK-NEXT: %10 = extractvalue { ptr, ptr } %8, 0 -// CHECK-NEXT: %11 = call %"{{.*}}/runtime/internal/runtime.String" %10(ptr %9) -// CHECK-NEXT: ret %"{{.*}}/runtime/internal/runtime.String" %11 +// CHECK-NEXT: %9 = extractvalue { ptr, ptr } %8, 0 +// CHECK-NEXT: %10 = call ptr @"{{.*}}/runtime/internal/runtime.StartRecoverFrameAlias"(ptr @"{{.*}}/cl/_testgo/genericembediface/streamlib.(*GenericServerStream[main.Request,main.Response]).Context", ptr %9) +// CHECK-NEXT: %11 = extractvalue { ptr, ptr } %8, 1 +// CHECK-NEXT: %12 = extractvalue { ptr, ptr } %8, 0 +// CHECK-NEXT: %13 = call %"{{.*}}/runtime/internal/runtime.String" %12(ptr %11) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %10) +// CHECK-NEXT: ret %"{{.*}}/runtime/internal/runtime.String" %13 // CHECK-NEXT: } // CHECK-LABEL: define linkonce %"{{.*}}/runtime/internal/runtime.String" @"{{.*}}/cl/_testgo/genericembediface/streamlib.GenericServerStream[main.Request,main.Response].Context"(%"{{.*}}/cl/_testgo/genericembediface/streamlib.GenericServerStream[main.Request,main.Response]" %0){{.*}} { @@ -162,8 +165,11 @@ func main() { // CHECK-NEXT: %7 = load ptr, ptr %6, align 8 // CHECK-NEXT: %8 = insertvalue { ptr, ptr } undef, ptr %7, 0 // CHECK-NEXT: %9 = insertvalue { ptr, ptr } %8, ptr %4, 1 -// CHECK-NEXT: %10 = extractvalue { ptr, ptr } %9, 1 -// CHECK-NEXT: %11 = extractvalue { ptr, ptr } %9, 0 -// CHECK-NEXT: %12 = call %"{{.*}}/runtime/internal/runtime.String" %11(ptr %10) -// CHECK-NEXT: ret %"{{.*}}/runtime/internal/runtime.String" %12 +// CHECK-NEXT: %10 = extractvalue { ptr, ptr } %9, 0 +// CHECK-NEXT: %11 = call ptr @"{{.*}}/runtime/internal/runtime.StartRecoverFrameAlias"(ptr @"{{.*}}/cl/_testgo/genericembediface/streamlib.GenericServerStream[main.Request,main.Response].Context", ptr %10) +// CHECK-NEXT: %12 = extractvalue { ptr, ptr } %9, 1 +// CHECK-NEXT: %13 = extractvalue { ptr, ptr } %9, 0 +// CHECK-NEXT: %14 = call %"{{.*}}/runtime/internal/runtime.String" %13(ptr %12) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %11) +// CHECK-NEXT: ret %"{{.*}}/runtime/internal/runtime.String" %14 // CHECK-NEXT: } diff --git a/cl/_testgo/goexit/in.go b/cl/_testgo/goexit/in.go index a2a9ba68fb..39ba36ad6a 100644 --- a/cl/_testgo/goexit/in.go +++ b/cl/_testgo/goexit/in.go @@ -93,7 +93,7 @@ func demo3() { // CHECK-NEXT: store ptr %2, ptr %4, align 8 // CHECK-NEXT: %5 = insertvalue { ptr, ptr } { ptr @"main.demo1$1$1", ptr undef }, ptr %3, 1 // CHECK-NEXT: %6 = call ptr @"{{.*}}/runtime/internal/runtime.GetThreadDefer"() -// CHECK-NEXT: %7 = alloca i8 +// CHECK-NEXT: %7 = alloca i8, i64 {{.*}}, align 1 // CHECK-NEXT: %8 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 48) // CHECK-NEXT: %9 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %8, i32 0, i32 0 // CHECK-NEXT: store ptr %7, ptr %9, align 8 @@ -216,7 +216,7 @@ func demo3() { // CHECK-NEXT: store ptr %2, ptr %4, align 8 // CHECK-NEXT: %5 = insertvalue { ptr, ptr } { ptr @"main.demo2$1$1", ptr undef }, ptr %3, 1 // CHECK-NEXT: %6 = call ptr @"{{.*}}/runtime/internal/runtime.GetThreadDefer"() -// CHECK-NEXT: %7 = alloca i8 +// CHECK-NEXT: %7 = alloca i8, i64 {{.*}}, align 1 // CHECK-NEXT: %8 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 48) // CHECK-NEXT: %9 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %8, i32 0, i32 0 // CHECK-NEXT: store ptr %7, ptr %9, align 8 @@ -279,44 +279,49 @@ func demo3() { // CHECK-NEXT: store ptr %30, ptr %16, align 8 // CHECK-NEXT: %31 = extractvalue { ptr, i64, { ptr, ptr } } %29, 2 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.FreeDeferNode"(ptr %28) -// CHECK-NEXT: %32 = extractvalue { ptr, ptr } %31, 1 -// CHECK-NEXT: %33 = extractvalue { ptr, ptr } %31, 0 -// CHECK-NEXT: %__llgo_funcval_code = call ptr asm "", "=r,0"(ptr %33) -// CHECK-NEXT: call void %__llgo_funcval_code(ptr {{(nest|swiftself)}} %32) +// CHECK-NEXT: %32 = extractvalue { ptr, ptr } %31, 0 +// CHECK-NEXT: %33 = call ptr @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr %32) +// CHECK-NEXT: %34 = extractvalue { ptr, ptr } %31, 1 +// CHECK-NEXT: %35 = extractvalue { ptr, ptr } %31, 0 +// CHECK-NEXT: %__llgo_funcval_code = call ptr asm "", "=r,0"(ptr %35) +// CHECK-NEXT: call void %__llgo_funcval_code(ptr {{(nest|swiftself)}} %34) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %33) // CHECK-NEXT: br label %_llgo_8 // CHECK-EMPTY: // CHECK-NEXT: _llgo_8: ; preds = %_llgo_7, %_llgo_2 -// CHECK-NEXT: %34 = load %"{{.*}}/runtime/internal/runtime.Defer", ptr %8, align 8 -// CHECK-NEXT: %35 = extractvalue %"{{.*}}/runtime/internal/runtime.Defer" %34, 2 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.SetThreadDefer"(ptr %35) -// CHECK-NEXT: %36 = load ptr, ptr %15, align 8 -// CHECK-NEXT: indirectbr ptr %36, [label %_llgo_3, label %_llgo_6] +// CHECK-NEXT: %36 = load %"{{.*}}/runtime/internal/runtime.Defer", ptr %8, align 8 +// CHECK-NEXT: %37 = extractvalue %"{{.*}}/runtime/internal/runtime.Defer" %36, 2 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.SetThreadDefer"(ptr %37) +// CHECK-NEXT: %38 = load ptr, ptr %15, align 8 +// CHECK-NEXT: indirectbr ptr %38, [label %_llgo_3, label %_llgo_6] // CHECK-NEXT: } // CHECK-LABEL: define void @"main.demo2$1$1"(ptr {{(nest|swiftself)}} %0){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %1 = load { ptr }, ptr %0, align 8 -// CHECK-NEXT: %2 = call %"{{.*}}/runtime/internal/runtime.eface" @"{{.*}}/runtime/internal/runtime.Recover"() -// CHECK-NEXT: %3 = call i1 @"{{.*}}/runtime/internal/runtime.EfaceEqual"(%"{{.*}}/runtime/internal/runtime.eface" %2, %"{{.*}}/runtime/internal/runtime.eface" zeroinitializer) -// CHECK-NEXT: %4 = xor i1 %3, true -// CHECK-NEXT: br i1 %4, label %_llgo_1, label %_llgo_2 +// CHECK-NEXT: %2 = alloca i8, align 1 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.BindRecoverFrame"(ptr @"main.demo2$1$1", ptr %2) +// CHECK-NEXT: %3 = call %"{{.*}}/runtime/internal/runtime.eface" @"{{.*}}/runtime/internal/runtime.Recover"(ptr %2) +// CHECK-NEXT: %4 = call i1 @"{{.*}}/runtime/internal/runtime.EfaceEqual"(%"{{.*}}/runtime/internal/runtime.eface" %3, %"{{.*}}/runtime/internal/runtime.eface" zeroinitializer) +// CHECK-NEXT: %5 = xor i1 %4, true +// CHECK-NEXT: br i1 %5, label %_llgo_1, label %_llgo_2 // CHECK-EMPTY: // CHECK-NEXT: _llgo_1: ; preds = %_llgo_0 -// CHECK-NEXT: %5 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 8 }, ptr %5, align 8 -// CHECK-NEXT: %6 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %5, 1 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Panic"(%"{{.*}}/runtime/internal/runtime.eface" %6) +// CHECK-NEXT: %6 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 8 }, ptr %6, align 8 +// CHECK-NEXT: %7 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %6, 1 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Panic"(%"{{.*}}/runtime/internal/runtime.eface" %7) // CHECK-NEXT: unreachable // CHECK-EMPTY: // CHECK-NEXT: _llgo_2: ; preds = %_llgo_0 -// CHECK-NEXT: %7 = extractvalue { ptr } %1, 0 -// CHECK-NEXT: %8 = load ptr, ptr %7, align 8 -// CHECK-NEXT: %9 = call ptr @llvm.stacksave.p0() -// CHECK-NEXT: %10 = alloca i1, align 1 -// CHECK-NEXT: call void @llvm.memset.p0.i64(ptr %10, i8 0, i64 1, i1 false) -// CHECK-NEXT: store i1 true, ptr %10, align 1 -// CHECK-NEXT: %11 = call i1 @"{{.*}}/runtime/internal/runtime.ChanSend"(ptr %8, ptr %10, i64 1) -// CHECK-NEXT: call void @llvm.stackrestore.p0(ptr %9) +// CHECK-NEXT: %8 = extractvalue { ptr } %1, 0 +// CHECK-NEXT: %9 = load ptr, ptr %8, align 8 +// CHECK-NEXT: %10 = call ptr @llvm.stacksave.p0() +// CHECK-NEXT: %11 = alloca i1, align 1 +// CHECK-NEXT: call void @llvm.memset.p0.i64(ptr %11, i8 0, i64 1, i1 false) +// CHECK-NEXT: store i1 true, ptr %11, align 1 +// CHECK-NEXT: %12 = call i1 @"{{.*}}/runtime/internal/runtime.ChanSend"(ptr %9, ptr %11, i64 1) +// CHECK-NEXT: call void @llvm.stackrestore.p0(ptr %10) // CHECK-NEXT: ret void // CHECK-NEXT: } @@ -352,7 +357,7 @@ func demo3() { // CHECK-NEXT: store ptr %2, ptr %4, align 8 // CHECK-NEXT: %5 = insertvalue { ptr, ptr } { ptr @"main.demo3$1$1", ptr undef }, ptr %3, 1 // CHECK-NEXT: %6 = call ptr @"{{.*}}/runtime/internal/runtime.GetThreadDefer"() -// CHECK-NEXT: %7 = alloca i8 +// CHECK-NEXT: %7 = alloca i8, i64 {{.*}}, align 1 // CHECK-NEXT: %8 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 48) // CHECK-NEXT: %9 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %8, i32 0, i32 0 // CHECK-NEXT: store ptr %7, ptr %9, align 8 @@ -378,7 +383,9 @@ func demo3() { // CHECK-NEXT: _llgo_2: ; preds = %_llgo_5, %_llgo_4 // CHECK-NEXT: store ptr blockaddress(@"main.demo3$1", %_llgo_7), ptr %14, align 8 // CHECK-NEXT: %19 = load i64, ptr %13, align 8 +// CHECK-NEXT: %20 = call ptr @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr @"main.demo3$1$2") // CHECK-NEXT: call void @"main.demo3$1$2"() +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %20) // CHECK-NEXT: br label %_llgo_7 // CHECK-EMPTY: // CHECK-NEXT: _llgo_3: ; preds = %_llgo_5, %_llgo_9 @@ -386,104 +393,111 @@ func demo3() { // CHECK-NEXT: br label %_llgo_1 // CHECK-EMPTY: // CHECK-NEXT: _llgo_4: ; preds = %_llgo_0 -// CHECK-NEXT: %20 = load ptr, ptr %16, align 8 -// CHECK-NEXT: %21 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 32) -// CHECK-NEXT: %22 = getelementptr inbounds { ptr, i64, { ptr, ptr } }, ptr %21, i32 0, i32 0 -// CHECK-NEXT: store ptr %20, ptr %22, align 8 -// CHECK-NEXT: %23 = getelementptr inbounds { ptr, i64, { ptr, ptr } }, ptr %21, i32 0, i32 1 -// CHECK-NEXT: store i64 0, ptr %23, align 8 -// CHECK-NEXT: %24 = getelementptr inbounds { ptr, i64, { ptr, ptr } }, ptr %21, i32 0, i32 2 -// CHECK-NEXT: store { ptr, ptr } %5, ptr %24, align 8 -// CHECK-NEXT: store ptr %21, ptr %16, align 8 +// CHECK-NEXT: %21 = load ptr, ptr %16, align 8 +// CHECK-NEXT: %22 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 32) +// CHECK-NEXT: %23 = getelementptr inbounds { ptr, i64, { ptr, ptr } }, ptr %22, i32 0, i32 0 +// CHECK-NEXT: store ptr %21, ptr %23, align 8 +// CHECK-NEXT: %24 = getelementptr inbounds { ptr, i64, { ptr, ptr } }, ptr %22, i32 0, i32 1 +// CHECK-NEXT: store i64 0, ptr %24, align 8 +// CHECK-NEXT: %25 = getelementptr inbounds { ptr, i64, { ptr, ptr } }, ptr %22, i32 0, i32 2 +// CHECK-NEXT: store { ptr, ptr } %5, ptr %25, align 8 +// CHECK-NEXT: store ptr %22, ptr %16, align 8 // CHECK-NEXT: call void @runtime.Goexit() // CHECK-NEXT: store ptr blockaddress(@"main.demo3$1", %_llgo_6), ptr %15, align 8 // CHECK-NEXT: br label %_llgo_2 // CHECK-EMPTY: // CHECK-NEXT: _llgo_5: ; preds = %_llgo_0 // CHECK-NEXT: store ptr blockaddress(@"main.demo3$1", %_llgo_3), ptr %15, align 8 -// CHECK-NEXT: %25 = load ptr, ptr %14, align 8 -// CHECK-NEXT: indirectbr ptr %25, [label %_llgo_3, label %_llgo_7, label %_llgo_2] +// CHECK-NEXT: %26 = load ptr, ptr %14, align 8 +// CHECK-NEXT: indirectbr ptr %26, [label %_llgo_3, label %_llgo_7, label %_llgo_2] // CHECK-EMPTY: // CHECK-NEXT: _llgo_6: ; preds = %_llgo_9 // CHECK-NEXT: ret void // CHECK-EMPTY: // CHECK-NEXT: _llgo_7: ; preds = %_llgo_5, %_llgo_2 // CHECK-NEXT: store ptr blockaddress(@"main.demo3$1", %_llgo_3), ptr %14, align 8 -// CHECK-NEXT: %26 = load i64, ptr %13, align 8 -// CHECK-NEXT: %27 = load ptr, ptr %16, align 8 -// CHECK-NEXT: %28 = icmp ne ptr %27, null -// CHECK-NEXT: br i1 %28, label %_llgo_8, label %_llgo_9 +// CHECK-NEXT: %27 = load i64, ptr %13, align 8 +// CHECK-NEXT: %28 = load ptr, ptr %16, align 8 +// CHECK-NEXT: %29 = icmp ne ptr %28, null +// CHECK-NEXT: br i1 %29, label %_llgo_8, label %_llgo_9 // CHECK-EMPTY: // CHECK-NEXT: _llgo_8: ; preds = %_llgo_7 -// CHECK-NEXT: %29 = load ptr, ptr %16, align 8 -// CHECK-NEXT: %30 = load { ptr, i64, { ptr, ptr } }, ptr %29, align 8 -// CHECK-NEXT: %31 = extractvalue { ptr, i64, { ptr, ptr } } %30, 0 -// CHECK-NEXT: store ptr %31, ptr %16, align 8 -// CHECK-NEXT: %32 = extractvalue { ptr, i64, { ptr, ptr } } %30, 2 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.FreeDeferNode"(ptr %29) -// CHECK-NEXT: %33 = extractvalue { ptr, ptr } %32, 1 -// CHECK-NEXT: %34 = extractvalue { ptr, ptr } %32, 0 -// CHECK-NEXT: %__llgo_funcval_code = call ptr asm "", "=r,0"(ptr %34) -// CHECK-NEXT: call void %__llgo_funcval_code(ptr {{(nest|swiftself)}} %33) +// CHECK-NEXT: %30 = load ptr, ptr %16, align 8 +// CHECK-NEXT: %31 = load { ptr, i64, { ptr, ptr } }, ptr %30, align 8 +// CHECK-NEXT: %32 = extractvalue { ptr, i64, { ptr, ptr } } %31, 0 +// CHECK-NEXT: store ptr %32, ptr %16, align 8 +// CHECK-NEXT: %33 = extractvalue { ptr, i64, { ptr, ptr } } %31, 2 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.FreeDeferNode"(ptr %30) +// CHECK-NEXT: %34 = extractvalue { ptr, ptr } %33, 0 +// CHECK-NEXT: %35 = call ptr @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr %34) +// CHECK-NEXT: %36 = extractvalue { ptr, ptr } %33, 1 +// CHECK-NEXT: %37 = extractvalue { ptr, ptr } %33, 0 +// CHECK-NEXT: %__llgo_funcval_code = call ptr asm "", "=r,0"(ptr %37) +// CHECK-NEXT: call void %__llgo_funcval_code(ptr {{(nest|swiftself)}} %36) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %35) // CHECK-NEXT: br label %_llgo_9 // CHECK-EMPTY: // CHECK-NEXT: _llgo_9: ; preds = %_llgo_8, %_llgo_7 -// CHECK-NEXT: %35 = load %"{{.*}}/runtime/internal/runtime.Defer", ptr %8, align 8 -// CHECK-NEXT: %36 = extractvalue %"{{.*}}/runtime/internal/runtime.Defer" %35, 2 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.SetThreadDefer"(ptr %36) -// CHECK-NEXT: %37 = load ptr, ptr %15, align 8 -// CHECK-NEXT: indirectbr ptr %37, [label %_llgo_3, label %_llgo_6] +// CHECK-NEXT: %38 = load %"{{.*}}/runtime/internal/runtime.Defer", ptr %8, align 8 +// CHECK-NEXT: %39 = extractvalue %"{{.*}}/runtime/internal/runtime.Defer" %38, 2 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.SetThreadDefer"(ptr %39) +// CHECK-NEXT: %40 = load ptr, ptr %15, align 8 +// CHECK-NEXT: indirectbr ptr %40, [label %_llgo_3, label %_llgo_6] // CHECK-NEXT: } // CHECK-LABEL: define void @"main.demo3$1$1"(ptr {{(nest|swiftself)}} %0){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %1 = load { ptr }, ptr %0, align 8 -// CHECK-NEXT: %2 = call %"{{.*}}/runtime/internal/runtime.eface" @"{{.*}}/runtime/internal/runtime.Recover"() -// CHECK-NEXT: %3 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 5 }, ptr %3, align 8 -// CHECK-NEXT: %4 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %3, 1 -// CHECK-NEXT: %5 = call i1 @"{{.*}}/runtime/internal/runtime.EfaceEqual"(%"{{.*}}/runtime/internal/runtime.eface" %2, %"{{.*}}/runtime/internal/runtime.eface" %4) -// CHECK-NEXT: %6 = xor i1 %5, true -// CHECK-NEXT: br i1 %6, label %_llgo_1, label %_llgo_2 +// CHECK-NEXT: %2 = alloca i8, align 1 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.BindRecoverFrame"(ptr @"main.demo3$1$1", ptr %2) +// CHECK-NEXT: %3 = call %"{{.*}}/runtime/internal/runtime.eface" @"{{.*}}/runtime/internal/runtime.Recover"(ptr %2) +// CHECK-NEXT: %4 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 5 }, ptr %4, align 8 +// CHECK-NEXT: %5 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %4, 1 +// CHECK-NEXT: %6 = call i1 @"{{.*}}/runtime/internal/runtime.EfaceEqual"(%"{{.*}}/runtime/internal/runtime.eface" %3, %"{{.*}}/runtime/internal/runtime.eface" %5) +// CHECK-NEXT: %7 = xor i1 %6, true +// CHECK-NEXT: br i1 %7, label %_llgo_1, label %_llgo_2 // CHECK-EMPTY: // CHECK-NEXT: _llgo_1: ; preds = %_llgo_0 -// CHECK-NEXT: %7 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 10 }, ptr %7, align 8 -// CHECK-NEXT: %8 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %7, 1 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Panic"(%"{{.*}}/runtime/internal/runtime.eface" %8) +// CHECK-NEXT: %8 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 10 }, ptr %8, align 8 +// CHECK-NEXT: %9 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %8, 1 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Panic"(%"{{.*}}/runtime/internal/runtime.eface" %9) // CHECK-NEXT: unreachable // CHECK-EMPTY: // CHECK-NEXT: _llgo_2: ; preds = %_llgo_0 -// CHECK-NEXT: %9 = extractvalue { ptr } %1, 0 -// CHECK-NEXT: %10 = load ptr, ptr %9, align 8 -// CHECK-NEXT: %11 = call ptr @llvm.stacksave.p0() -// CHECK-NEXT: %12 = alloca i1, align 1 -// CHECK-NEXT: call void @llvm.memset.p0.i64(ptr %12, i8 0, i64 1, i1 false) -// CHECK-NEXT: store i1 true, ptr %12, align 1 -// CHECK-NEXT: %13 = call i1 @"{{.*}}/runtime/internal/runtime.ChanSend"(ptr %10, ptr %12, i64 1) -// CHECK-NEXT: call void @llvm.stackrestore.p0(ptr %11) +// CHECK-NEXT: %10 = extractvalue { ptr } %1, 0 +// CHECK-NEXT: %11 = load ptr, ptr %10, align 8 +// CHECK-NEXT: %12 = call ptr @llvm.stacksave.p0() +// CHECK-NEXT: %13 = alloca i1, align 1 +// CHECK-NEXT: call void @llvm.memset.p0.i64(ptr %13, i8 0, i64 1, i1 false) +// CHECK-NEXT: store i1 true, ptr %13, align 1 +// CHECK-NEXT: %14 = call i1 @"{{.*}}/runtime/internal/runtime.ChanSend"(ptr %11, ptr %13, i64 1) +// CHECK-NEXT: call void @llvm.stackrestore.p0(ptr %12) // CHECK-NEXT: ret void // CHECK-NEXT: } // CHECK-LABEL: define void @"main.demo3$1$2"(){{.*}} { // CHECK-NEXT: _llgo_0: -// CHECK-NEXT: %0 = call %"{{.*}}/runtime/internal/runtime.eface" @"{{.*}}/runtime/internal/runtime.Recover"() -// CHECK-NEXT: %1 = call i1 @"{{.*}}/runtime/internal/runtime.EfaceEqual"(%"{{.*}}/runtime/internal/runtime.eface" %0, %"{{.*}}/runtime/internal/runtime.eface" zeroinitializer) -// CHECK-NEXT: %2 = xor i1 %1, true -// CHECK-NEXT: br i1 %2, label %_llgo_1, label %_llgo_2 +// CHECK-NEXT: %0 = alloca i8, align 1 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.BindRecoverFrame"(ptr @"main.demo3$1$2", ptr %0) +// CHECK-NEXT: %1 = call %"{{.*}}/runtime/internal/runtime.eface" @"{{.*}}/runtime/internal/runtime.Recover"(ptr %0) +// CHECK-NEXT: %2 = call i1 @"{{.*}}/runtime/internal/runtime.EfaceEqual"(%"{{.*}}/runtime/internal/runtime.eface" %1, %"{{.*}}/runtime/internal/runtime.eface" zeroinitializer) +// CHECK-NEXT: %3 = xor i1 %2, true +// CHECK-NEXT: br i1 %3, label %_llgo_1, label %_llgo_2 // CHECK-EMPTY: // CHECK-NEXT: _llgo_1: ; preds = %_llgo_0 -// CHECK-NEXT: %3 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 8 }, ptr %3, align 8 -// CHECK-NEXT: %4 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %3, 1 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Panic"(%"{{.*}}/runtime/internal/runtime.eface" %4) +// CHECK-NEXT: %4 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 8 }, ptr %4, align 8 +// CHECK-NEXT: %5 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %4, 1 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Panic"(%"{{.*}}/runtime/internal/runtime.eface" %5) // CHECK-NEXT: unreachable // CHECK-EMPTY: // CHECK-NEXT: _llgo_2: ; preds = %_llgo_0 -// CHECK-NEXT: %5 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 5 }, ptr %5, align 8 -// CHECK-NEXT: %6 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %5, 1 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Panic"(%"{{.*}}/runtime/internal/runtime.eface" %6) +// CHECK-NEXT: %6 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 5 }, ptr %6, align 8 +// CHECK-NEXT: %7 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %6, 1 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Panic"(%"{{.*}}/runtime/internal/runtime.eface" %7) // CHECK-NEXT: unreachable // CHECK-NEXT: } diff --git a/cl/_testgo/ifaceprom/in.go b/cl/_testgo/ifaceprom/in.go index 3dd49d6e04..dedb859701 100644 --- a/cl/_testgo/ifaceprom/in.go +++ b/cl/_testgo/ifaceprom/in.go @@ -5,11 +5,11 @@ package main // struct. In particular, this test exercises that the correct // method is called. -// CHECK: @0 = private unnamed_addr constant [3 x i8] c"two", align 1 -// CHECK: @1 = private unnamed_addr constant [48 x i8] c"{{.*}}/cl/_testgo/ifaceprom.impl", align 1 -// CHECK: @2 = private unnamed_addr constant [3 x i8] c"one", align 1 -// CHECK: @13 = private unnamed_addr constant [45 x i8] c"{{.*}}/cl/_testgo/ifaceprom.I", align 1 -// CHECK: @14 = private unnamed_addr constant [4 x i8] c"pass", align 1 +// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [3 x i8] c"two", align 1{{$}} +// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [48 x i8] c"{{.*}}/cl/_testgo/ifaceprom.impl", align 1{{$}} +// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [3 x i8] c"one", align 1{{$}} +// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [45 x i8] c"{{.*}}/cl/_testgo/ifaceprom.I", align 1{{$}} +// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [4 x i8] c"pass", align 1{{$}} type I interface { one() int @@ -79,10 +79,13 @@ func main() { // CHECK-NEXT: %7 = load ptr, ptr %6, align 8 // CHECK-NEXT: %8 = insertvalue { ptr, ptr } undef, ptr %7, 0 // CHECK-NEXT: %9 = insertvalue { ptr, ptr } %8, ptr %4, 1 -// CHECK-NEXT: %10 = extractvalue { ptr, ptr } %9, 1 -// CHECK-NEXT: %11 = extractvalue { ptr, ptr } %9, 0 -// CHECK-NEXT: %12 = call i64 %11(ptr %10) -// CHECK-NEXT: ret i64 %12 +// CHECK-NEXT: %10 = extractvalue { ptr, ptr } %9, 0 +// CHECK-NEXT: %11 = call ptr @"{{.*}}/runtime/internal/runtime.StartRecoverFrameAlias"(ptr @main.S.one, ptr %10) +// CHECK-NEXT: %12 = extractvalue { ptr, ptr } %9, 1 +// CHECK-NEXT: %13 = extractvalue { ptr, ptr } %9, 0 +// CHECK-NEXT: %14 = call i64 %13(ptr %12) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %11) +// CHECK-NEXT: ret i64 %14 // CHECK-NEXT: } // CHECK-LABEL: define %"{{.*}}/runtime/internal/runtime.String" @main.S.two(%main.S %0){{.*}} { @@ -98,10 +101,13 @@ func main() { // CHECK-NEXT: %7 = load ptr, ptr %6, align 8 // CHECK-NEXT: %8 = insertvalue { ptr, ptr } undef, ptr %7, 0 // CHECK-NEXT: %9 = insertvalue { ptr, ptr } %8, ptr %4, 1 -// CHECK-NEXT: %10 = extractvalue { ptr, ptr } %9, 1 -// CHECK-NEXT: %11 = extractvalue { ptr, ptr } %9, 0 -// CHECK-NEXT: %12 = call %"{{.*}}/runtime/internal/runtime.String" %11(ptr %10) -// CHECK-NEXT: ret %"{{.*}}/runtime/internal/runtime.String" %12 +// CHECK-NEXT: %10 = extractvalue { ptr, ptr } %9, 0 +// CHECK-NEXT: %11 = call ptr @"{{.*}}/runtime/internal/runtime.StartRecoverFrameAlias"(ptr @main.S.two, ptr %10) +// CHECK-NEXT: %12 = extractvalue { ptr, ptr } %9, 1 +// CHECK-NEXT: %13 = extractvalue { ptr, ptr } %9, 0 +// CHECK-NEXT: %14 = call %"{{.*}}/runtime/internal/runtime.String" %13(ptr %12) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %11) +// CHECK-NEXT: ret %"{{.*}}/runtime/internal/runtime.String" %14 // CHECK-NEXT: } // CHECK-LABEL: define i64 @"main.(*S).one"(ptr %0){{.*}} { @@ -114,10 +120,13 @@ func main() { // CHECK-NEXT: %6 = load ptr, ptr %5, align 8 // CHECK-NEXT: %7 = insertvalue { ptr, ptr } undef, ptr %6, 0 // CHECK-NEXT: %8 = insertvalue { ptr, ptr } %7, ptr %3, 1 -// CHECK-NEXT: %9 = extractvalue { ptr, ptr } %8, 1 -// CHECK-NEXT: %10 = extractvalue { ptr, ptr } %8, 0 -// CHECK-NEXT: %11 = call i64 %10(ptr %9) -// CHECK-NEXT: ret i64 %11 +// CHECK-NEXT: %9 = extractvalue { ptr, ptr } %8, 0 +// CHECK-NEXT: %10 = call ptr @"{{.*}}/runtime/internal/runtime.StartRecoverFrameAlias"(ptr @"main.(*S).one", ptr %9) +// CHECK-NEXT: %11 = extractvalue { ptr, ptr } %8, 1 +// CHECK-NEXT: %12 = extractvalue { ptr, ptr } %8, 0 +// CHECK-NEXT: %13 = call i64 %12(ptr %11) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %10) +// CHECK-NEXT: ret i64 %13 // CHECK-NEXT: } // CHECK-LABEL: define %"{{.*}}/runtime/internal/runtime.String" @"main.(*S).two"(ptr %0){{.*}} { @@ -130,10 +139,13 @@ func main() { // CHECK-NEXT: %6 = load ptr, ptr %5, align 8 // CHECK-NEXT: %7 = insertvalue { ptr, ptr } undef, ptr %6, 0 // CHECK-NEXT: %8 = insertvalue { ptr, ptr } %7, ptr %3, 1 -// CHECK-NEXT: %9 = extractvalue { ptr, ptr } %8, 1 -// CHECK-NEXT: %10 = extractvalue { ptr, ptr } %8, 0 -// CHECK-NEXT: %11 = call %"{{.*}}/runtime/internal/runtime.String" %10(ptr %9) -// CHECK-NEXT: ret %"{{.*}}/runtime/internal/runtime.String" %11 +// CHECK-NEXT: %9 = extractvalue { ptr, ptr } %8, 0 +// CHECK-NEXT: %10 = call ptr @"{{.*}}/runtime/internal/runtime.StartRecoverFrameAlias"(ptr @"main.(*S).two", ptr %9) +// CHECK-NEXT: %11 = extractvalue { ptr, ptr } %8, 1 +// CHECK-NEXT: %12 = extractvalue { ptr, ptr } %8, 0 +// CHECK-NEXT: %13 = call %"{{.*}}/runtime/internal/runtime.String" %12(ptr %11) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %10) +// CHECK-NEXT: ret %"{{.*}}/runtime/internal/runtime.String" %13 // CHECK-NEXT: } // CHECK-LABEL: define i64 @main.impl.one(%main.impl %0){{.*}} { @@ -143,13 +155,13 @@ func main() { // CHECK-LABEL: define %"{{.*}}/runtime/internal/runtime.String" @main.impl.two(%main.impl %0){{.*}} { // CHECK-NEXT: _llgo_0: -// CHECK-NEXT: ret %"{{.*}}/runtime/internal/runtime.String" { ptr @0, i64 3 } +// CHECK-NEXT: ret %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 3 } // CHECK-NEXT: } // CHECK-LABEL: define i64 @"main.(*impl).one"(ptr %0){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %1 = icmp eq ptr %0, null -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicWrapNilPointer"(i1 %1, %"{{.*}}/runtime/internal/runtime.String" { ptr @1, i64 48 }, %"{{.*}}/runtime/internal/runtime.String" { ptr @2, i64 3 }) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicWrapNilPointer"(i1 %1, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 48 }, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 3 }) // CHECK-NEXT: %2 = icmp eq ptr %0, null // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.AssertNilDeref"(i1 %2) // CHECK-NEXT: %3 = call i64 @main.impl.one(%main.impl zeroinitializer) @@ -159,7 +171,7 @@ func main() { // CHECK-LABEL: define %"{{.*}}/runtime/internal/runtime.String" @"main.(*impl).two"(ptr %0){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %1 = icmp eq ptr %0, null -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicWrapNilPointer"(i1 %1, %"{{.*}}/runtime/internal/runtime.String" { ptr @1, i64 48 }, %"{{.*}}/runtime/internal/runtime.String" { ptr @0, i64 3 }) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicWrapNilPointer"(i1 %1, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 48 }, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 3 }) // CHECK-NEXT: %2 = icmp eq ptr %0, null // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.AssertNilDeref"(i1 %2) // CHECK-NEXT: %3 = call %"{{.*}}/runtime/internal/runtime.String" @main.impl.two(%main.impl zeroinitializer) @@ -186,7 +198,7 @@ func main() { // CHECK-NEXT: %1 = getelementptr inbounds %main.S, ptr %0, i32 0, i32 0 // CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 0) // CHECK-NEXT: store %main.impl zeroinitializer, ptr %2, align 1 -// CHECK-NEXT: %3 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"{{.*}}/cl/_testgo/ifaceprom.iface${{[-A-Za-z0-9_]+}}", ptr @_llgo_main.impl) +// CHECK-NEXT: %3 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"{{.*}}/cl/_testgo/ifaceprom.iface$zZ89tENb5h_KNjvpxf1TXPfaWFYn0IZrZwyVf42lRtA", ptr @_llgo_main.impl) // CHECK-NEXT: %4 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %3, 0 // CHECK-NEXT: %5 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %4, ptr %2, 1 // CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.iface" %5, ptr %1, align 8 @@ -273,7 +285,7 @@ func main() { // CHECK-NEXT: %54 = extractvalue { ptr, ptr } %53, 1 // CHECK-NEXT: %55 = extractvalue { ptr, ptr } %53, 0 // CHECK-NEXT: %56 = call %"{{.*}}/runtime/internal/runtime.String" %55(ptr %54) -// CHECK-NEXT: %57 = call i1 @"{{.*}}/runtime/internal/runtime.StringEqual"(%"{{.*}}/runtime/internal/runtime.String" %56, %"{{.*}}/runtime/internal/runtime.String" { ptr @0, i64 3 }) +// CHECK-NEXT: %57 = call i1 @"{{.*}}/runtime/internal/runtime.StringEqual"(%"{{.*}}/runtime/internal/runtime.String" %56, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 3 }) // CHECK-NEXT: %58 = xor i1 %57, true // CHECK-NEXT: br i1 %58, label %_llgo_9, label %_llgo_10 // CHECK-EMPTY: @@ -296,7 +308,7 @@ func main() { // CHECK-NEXT: %69 = extractvalue { ptr, ptr } %68, 1 // CHECK-NEXT: %70 = extractvalue { ptr, ptr } %68, 0 // CHECK-NEXT: %71 = call %"{{.*}}/runtime/internal/runtime.String" %70(ptr %69) -// CHECK-NEXT: %72 = call i1 @"{{.*}}/runtime/internal/runtime.StringEqual"(%"{{.*}}/runtime/internal/runtime.String" %71, %"{{.*}}/runtime/internal/runtime.String" { ptr @0, i64 3 }) +// CHECK-NEXT: %72 = call i1 @"{{.*}}/runtime/internal/runtime.StringEqual"(%"{{.*}}/runtime/internal/runtime.String" %71, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 3 }) // CHECK-NEXT: %73 = xor i1 %72, true // CHECK-NEXT: br i1 %73, label %_llgo_11, label %_llgo_12 // CHECK-EMPTY: @@ -336,7 +348,7 @@ func main() { // CHECK-NEXT: unreachable // CHECK-EMPTY: // CHECK-NEXT: _llgo_16: ; preds = %_llgo_23 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintString"(%"{{.*}}/runtime/internal/runtime.String" { ptr @14, i64 4 }) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintString"(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 4 }) // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintByte"(i8 10) // CHECK-NEXT: ret void // CHECK-EMPTY: @@ -353,7 +365,7 @@ func main() { // CHECK-NEXT: br i1 %94, label %_llgo_5, label %_llgo_6 // CHECK-EMPTY: // CHECK-NEXT: _llgo_18: ; preds = %_llgo_4 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr %36, %"{{.*}}/runtime/internal/runtime.String" { ptr @13, i64 45 }, %"{{.*}}/runtime/internal/runtime.String" { ptr @2, i64 3 }) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr %36, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 45 }, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 3 }) // CHECK-NEXT: unreachable // CHECK-EMPTY: // CHECK-NEXT: _llgo_19: ; preds = %_llgo_6 @@ -369,7 +381,7 @@ func main() { // CHECK-NEXT: br i1 %101, label %_llgo_7, label %_llgo_8 // CHECK-EMPTY: // CHECK-NEXT: _llgo_20: ; preds = %_llgo_6 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr %42, %"{{.*}}/runtime/internal/runtime.String" { ptr @13, i64 45 }, %"{{.*}}/runtime/internal/runtime.String" { ptr @2, i64 3 }) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr %42, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 45 }, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 3 }) // CHECK-NEXT: unreachable // CHECK-EMPTY: // CHECK-NEXT: _llgo_21: ; preds = %_llgo_12 @@ -381,12 +393,12 @@ func main() { // CHECK-NEXT: %106 = extractvalue { ptr, ptr } %104, 0 // CHECK-NEXT: %__llgo_funcval_code2 = call ptr asm "", "=r,0"(ptr %106) // CHECK-NEXT: %107 = call %"{{.*}}/runtime/internal/runtime.String" %__llgo_funcval_code2(ptr {{(nest|swiftself)}} %105) -// CHECK-NEXT: %108 = call i1 @"{{.*}}/runtime/internal/runtime.StringEqual"(%"{{.*}}/runtime/internal/runtime.String" %107, %"{{.*}}/runtime/internal/runtime.String" { ptr @0, i64 3 }) +// CHECK-NEXT: %108 = call i1 @"{{.*}}/runtime/internal/runtime.StringEqual"(%"{{.*}}/runtime/internal/runtime.String" %107, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 3 }) // CHECK-NEXT: %109 = xor i1 %108, true // CHECK-NEXT: br i1 %109, label %_llgo_13, label %_llgo_14 // CHECK-EMPTY: // CHECK-NEXT: _llgo_22: ; preds = %_llgo_12 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr %78, %"{{.*}}/runtime/internal/runtime.String" { ptr @13, i64 45 }, %"{{.*}}/runtime/internal/runtime.String" { ptr @2, i64 3 }) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr %78, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 45 }, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 3 }) // CHECK-NEXT: unreachable // CHECK-EMPTY: // CHECK-NEXT: _llgo_23: ; preds = %_llgo_14 @@ -398,12 +410,12 @@ func main() { // CHECK-NEXT: %114 = extractvalue { ptr, ptr } %112, 0 // CHECK-NEXT: %__llgo_funcval_code3 = call ptr asm "", "=r,0"(ptr %114) // CHECK-NEXT: %115 = call %"{{.*}}/runtime/internal/runtime.String" %__llgo_funcval_code3(ptr {{(nest|swiftself)}} %113) -// CHECK-NEXT: %116 = call i1 @"{{.*}}/runtime/internal/runtime.StringEqual"(%"{{.*}}/runtime/internal/runtime.String" %115, %"{{.*}}/runtime/internal/runtime.String" { ptr @0, i64 3 }) +// CHECK-NEXT: %116 = call i1 @"{{.*}}/runtime/internal/runtime.StringEqual"(%"{{.*}}/runtime/internal/runtime.String" %115, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 3 }) // CHECK-NEXT: %117 = xor i1 %116, true // CHECK-NEXT: br i1 %117, label %_llgo_15, label %_llgo_16 // CHECK-EMPTY: // CHECK-NEXT: _llgo_24: ; preds = %_llgo_14 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr %84, %"{{.*}}/runtime/internal/runtime.String" { ptr @13, i64 45 }, %"{{.*}}/runtime/internal/runtime.String" { ptr @2, i64 3 }) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr %84, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 45 }, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 3 }) // CHECK-NEXT: unreachable // CHECK-NEXT: } @@ -417,10 +429,13 @@ func main() { // CHECK-NEXT: %6 = load ptr, ptr %5, align 8 // CHECK-NEXT: %7 = insertvalue { ptr, ptr } undef, ptr %6, 0 // CHECK-NEXT: %8 = insertvalue { ptr, ptr } %7, ptr %3, 1 -// CHECK-NEXT: %9 = extractvalue { ptr, ptr } %8, 1 -// CHECK-NEXT: %10 = extractvalue { ptr, ptr } %8, 0 -// CHECK-NEXT: %11 = call i64 %10(ptr %9) -// CHECK-NEXT: ret i64 %11 +// CHECK-NEXT: %9 = extractvalue { ptr, ptr } %8, 0 +// CHECK-NEXT: %10 = call ptr @"{{.*}}/runtime/internal/runtime.StartRecoverFrameAlias"(ptr @"main.I.one$bound", ptr %9) +// CHECK-NEXT: %11 = extractvalue { ptr, ptr } %8, 1 +// CHECK-NEXT: %12 = extractvalue { ptr, ptr } %8, 0 +// CHECK-NEXT: %13 = call i64 %12(ptr %11) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %10) +// CHECK-NEXT: ret i64 %13 // CHECK-NEXT: } // CHECK-LABEL: define %"{{.*}}/runtime/internal/runtime.String" @"main.I.two$bound"(ptr {{(nest|swiftself)}} %0){{.*}} { @@ -433,8 +448,11 @@ func main() { // CHECK-NEXT: %6 = load ptr, ptr %5, align 8 // CHECK-NEXT: %7 = insertvalue { ptr, ptr } undef, ptr %6, 0 // CHECK-NEXT: %8 = insertvalue { ptr, ptr } %7, ptr %3, 1 -// CHECK-NEXT: %9 = extractvalue { ptr, ptr } %8, 1 -// CHECK-NEXT: %10 = extractvalue { ptr, ptr } %8, 0 -// CHECK-NEXT: %11 = call %"{{.*}}/runtime/internal/runtime.String" %10(ptr %9) -// CHECK-NEXT: ret %"{{.*}}/runtime/internal/runtime.String" %11 +// CHECK-NEXT: %9 = extractvalue { ptr, ptr } %8, 0 +// CHECK-NEXT: %10 = call ptr @"{{.*}}/runtime/internal/runtime.StartRecoverFrameAlias"(ptr @"main.I.two$bound", ptr %9) +// CHECK-NEXT: %11 = extractvalue { ptr, ptr } %8, 1 +// CHECK-NEXT: %12 = extractvalue { ptr, ptr } %8, 0 +// CHECK-NEXT: %13 = call %"{{.*}}/runtime/internal/runtime.String" %12(ptr %11) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %10) +// CHECK-NEXT: ret %"{{.*}}/runtime/internal/runtime.String" %13 // CHECK-NEXT: } diff --git a/cl/_testgo/indexerr/in.go b/cl/_testgo/indexerr/in.go index 62fdecd500..b12c5d6897 100644 --- a/cl/_testgo/indexerr/in.go +++ b/cl/_testgo/indexerr/in.go @@ -215,7 +215,7 @@ func slice2(n int) { // CHECK-LABEL: define void @"main.init#1"(){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %0 = call ptr @"{{.*}}/runtime/internal/runtime.GetThreadDefer"() -// CHECK-NEXT: %1 = alloca i8 +// CHECK-NEXT: %1 = alloca i8, i64 {{.*}}, align 1 // CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 48) // CHECK-NEXT: %3 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, i32 0, i32 0 // CHECK-NEXT: store ptr %1, ptr %3, align 8 @@ -241,12 +241,14 @@ func slice2(n int) { // CHECK-NEXT: _llgo_2: ; preds = %_llgo_5, %_llgo_4 // CHECK-NEXT: store ptr blockaddress(@"main.init#1", %_llgo_3), ptr %8, align 8 // CHECK-NEXT: %13 = load i64, ptr %7, align 8 +// CHECK-NEXT: %14 = call ptr @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr @"main.init#1$1") // CHECK-NEXT: call void @"main.init#1$1"() -// CHECK-NEXT: %14 = load %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, align 8 -// CHECK-NEXT: %15 = extractvalue %"{{.*}}/runtime/internal/runtime.Defer" %14, 2 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.SetThreadDefer"(ptr %15) -// CHECK-NEXT: %16 = load ptr, ptr %9, align 8 -// CHECK-NEXT: indirectbr ptr %16, [label %_llgo_3, label %_llgo_6] +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %14) +// CHECK-NEXT: %15 = load %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, align 8 +// CHECK-NEXT: %16 = extractvalue %"{{.*}}/runtime/internal/runtime.Defer" %15, 2 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.SetThreadDefer"(ptr %16) +// CHECK-NEXT: %17 = load ptr, ptr %9, align 8 +// CHECK-NEXT: indirectbr ptr %17, [label %_llgo_3, label %_llgo_6] // CHECK-EMPTY: // CHECK-NEXT: _llgo_3: ; preds = %_llgo_5, %_llgo_2 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Rethrow"(ptr %0) @@ -259,8 +261,8 @@ func slice2(n int) { // CHECK-EMPTY: // CHECK-NEXT: _llgo_5: ; preds = %_llgo_0 // CHECK-NEXT: store ptr blockaddress(@"main.init#1", %_llgo_3), ptr %9, align 8 -// CHECK-NEXT: %17 = load ptr, ptr %8, align 8 -// CHECK-NEXT: indirectbr ptr %17, [label %_llgo_3, label %_llgo_2] +// CHECK-NEXT: %18 = load ptr, ptr %8, align 8 +// CHECK-NEXT: indirectbr ptr %18, [label %_llgo_3, label %_llgo_2] // CHECK-EMPTY: // CHECK-NEXT: _llgo_6: ; preds = %_llgo_2 // CHECK-NEXT: ret void @@ -268,15 +270,17 @@ func slice2(n int) { // CHECK-LABEL: define void @"main.init#1$1"(){{.*}} { // CHECK-NEXT: _llgo_0: -// CHECK-NEXT: %0 = call %"{{.*}}/runtime/internal/runtime.eface" @"{{.*}}/runtime/internal/runtime.Recover"() -// CHECK-NEXT: %1 = call i1 @"{{.*}}/runtime/internal/runtime.EfaceEqual"(%"{{.*}}/runtime/internal/runtime.eface" %0, %"{{.*}}/runtime/internal/runtime.eface" zeroinitializer) -// CHECK-NEXT: br i1 %1, label %_llgo_1, label %_llgo_2 +// CHECK-NEXT: %0 = alloca i8, align 1 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.BindRecoverFrame"(ptr @"main.init#1$1", ptr %0) +// CHECK-NEXT: %1 = call %"{{.*}}/runtime/internal/runtime.eface" @"{{.*}}/runtime/internal/runtime.Recover"(ptr %0) +// CHECK-NEXT: %2 = call i1 @"{{.*}}/runtime/internal/runtime.EfaceEqual"(%"{{.*}}/runtime/internal/runtime.eface" %1, %"{{.*}}/runtime/internal/runtime.eface" zeroinitializer) +// CHECK-NEXT: br i1 %2, label %_llgo_1, label %_llgo_2 // CHECK-EMPTY: // CHECK-NEXT: _llgo_1: ; preds = %_llgo_0 -// CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 19 }, ptr %2, align 8 -// CHECK-NEXT: %3 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %2, 1 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Panic"(%"{{.*}}/runtime/internal/runtime.eface" %3) +// CHECK-NEXT: %3 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 19 }, ptr %3, align 8 +// CHECK-NEXT: %4 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %3, 1 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Panic"(%"{{.*}}/runtime/internal/runtime.eface" %4) // CHECK-NEXT: unreachable // CHECK-EMPTY: // CHECK-NEXT: _llgo_2: ; preds = %_llgo_0 @@ -286,7 +290,7 @@ func slice2(n int) { // CHECK-LABEL: define void @"main.init#10"(){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %0 = call ptr @"{{.*}}/runtime/internal/runtime.GetThreadDefer"() -// CHECK-NEXT: %1 = alloca i8 +// CHECK-NEXT: %1 = alloca i8, i64 {{.*}}, align 1 // CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 48) // CHECK-NEXT: %3 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, i32 0, i32 0 // CHECK-NEXT: store ptr %1, ptr %3, align 8 @@ -312,42 +316,44 @@ func slice2(n int) { // CHECK-NEXT: _llgo_2: ; preds = %_llgo_5, %_llgo_4 // CHECK-NEXT: store ptr blockaddress(@"main.init#10", %_llgo_3), ptr %8, align 8 // CHECK-NEXT: %13 = load i64, ptr %7, align 8 +// CHECK-NEXT: %14 = call ptr @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr @"main.init#10$1") // CHECK-NEXT: call void @"main.init#10$1"() -// CHECK-NEXT: %14 = load %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, align 8 -// CHECK-NEXT: %15 = extractvalue %"{{.*}}/runtime/internal/runtime.Defer" %14, 2 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.SetThreadDefer"(ptr %15) -// CHECK-NEXT: %16 = load ptr, ptr %9, align 8 -// CHECK-NEXT: indirectbr ptr %16, [label %_llgo_3, label %_llgo_6] +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %14) +// CHECK-NEXT: %15 = load %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, align 8 +// CHECK-NEXT: %16 = extractvalue %"{{.*}}/runtime/internal/runtime.Defer" %15, 2 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.SetThreadDefer"(ptr %16) +// CHECK-NEXT: %17 = load ptr, ptr %9, align 8 +// CHECK-NEXT: indirectbr ptr %17, [label %_llgo_3, label %_llgo_6] // CHECK-EMPTY: // CHECK-NEXT: _llgo_3: ; preds = %_llgo_5, %_llgo_2 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Rethrow"(ptr %0) // CHECK-NEXT: br label %_llgo_1 // CHECK-EMPTY: // CHECK-NEXT: _llgo_4: ; preds = %_llgo_0 -// CHECK-NEXT: %17 = call ptr @"{{.*}}/runtime/internal/runtime.AllocZ"(i64 16) -// CHECK-NEXT: %18 = getelementptr inbounds i64, ptr %17, i64 0 -// CHECK-NEXT: store i64 1, ptr %18, align 8 -// CHECK-NEXT: %19 = getelementptr inbounds i64, ptr %17, i64 1 -// CHECK-NEXT: store i64 2, ptr %19, align 8 -// CHECK-NEXT: %20 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" undef, ptr %17, 0 -// CHECK-NEXT: %21 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" %20, i64 2, 1 -// CHECK-NEXT: %22 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" %21, i64 2, 2 -// CHECK-NEXT: %23 = extractvalue %"{{.*}}/runtime/internal/runtime.Slice" %22, 0 -// CHECK-NEXT: %24 = extractvalue %"{{.*}}/runtime/internal/runtime.Slice" %22, 1 -// CHECK-NEXT: %25 = icmp uge i64 -1, %24 -// CHECK-NEXT: %26 = or i1 %25, true -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.CheckIndexRange"(i1 %26, i64 -1, i1 true, i64 %24) -// CHECK-NEXT: %27 = getelementptr inbounds i64, ptr %23, i64 -1 -// CHECK-NEXT: %28 = load i64, ptr %27, align 8 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintInt"(i64 %28) +// CHECK-NEXT: %18 = call ptr @"{{.*}}/runtime/internal/runtime.AllocZ"(i64 16) +// CHECK-NEXT: %19 = getelementptr inbounds i64, ptr %18, i64 0 +// CHECK-NEXT: store i64 1, ptr %19, align 8 +// CHECK-NEXT: %20 = getelementptr inbounds i64, ptr %18, i64 1 +// CHECK-NEXT: store i64 2, ptr %20, align 8 +// CHECK-NEXT: %21 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" undef, ptr %18, 0 +// CHECK-NEXT: %22 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" %21, i64 2, 1 +// CHECK-NEXT: %23 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" %22, i64 2, 2 +// CHECK-NEXT: %24 = extractvalue %"{{.*}}/runtime/internal/runtime.Slice" %23, 0 +// CHECK-NEXT: %25 = extractvalue %"{{.*}}/runtime/internal/runtime.Slice" %23, 1 +// CHECK-NEXT: %26 = icmp uge i64 -1, %25 +// CHECK-NEXT: %27 = or i1 %26, true +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.CheckIndexRange"(i1 %27, i64 -1, i1 true, i64 %25) +// CHECK-NEXT: %28 = getelementptr inbounds i64, ptr %24, i64 -1 +// CHECK-NEXT: %29 = load i64, ptr %28, align 8 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintInt"(i64 %29) // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintByte"(i8 10) // CHECK-NEXT: store ptr blockaddress(@"main.init#10", %_llgo_6), ptr %9, align 8 // CHECK-NEXT: br label %_llgo_2 // CHECK-EMPTY: // CHECK-NEXT: _llgo_5: ; preds = %_llgo_0 // CHECK-NEXT: store ptr blockaddress(@"main.init#10", %_llgo_3), ptr %9, align 8 -// CHECK-NEXT: %29 = load ptr, ptr %8, align 8 -// CHECK-NEXT: indirectbr ptr %29, [label %_llgo_3, label %_llgo_2] +// CHECK-NEXT: %30 = load ptr, ptr %8, align 8 +// CHECK-NEXT: indirectbr ptr %30, [label %_llgo_3, label %_llgo_2] // CHECK-EMPTY: // CHECK-NEXT: _llgo_6: ; preds = %_llgo_2 // CHECK-NEXT: ret void @@ -355,15 +361,17 @@ func slice2(n int) { // CHECK-LABEL: define void @"main.init#10$1"(){{.*}} { // CHECK-NEXT: _llgo_0: -// CHECK-NEXT: %0 = call %"{{.*}}/runtime/internal/runtime.eface" @"{{.*}}/runtime/internal/runtime.Recover"() -// CHECK-NEXT: %1 = call i1 @"{{.*}}/runtime/internal/runtime.EfaceEqual"(%"{{.*}}/runtime/internal/runtime.eface" %0, %"{{.*}}/runtime/internal/runtime.eface" zeroinitializer) -// CHECK-NEXT: br i1 %1, label %_llgo_1, label %_llgo_2 +// CHECK-NEXT: %0 = alloca i8, align 1 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.BindRecoverFrame"(ptr @"main.init#10$1", ptr %0) +// CHECK-NEXT: %1 = call %"{{.*}}/runtime/internal/runtime.eface" @"{{.*}}/runtime/internal/runtime.Recover"(ptr %0) +// CHECK-NEXT: %2 = call i1 @"{{.*}}/runtime/internal/runtime.EfaceEqual"(%"{{.*}}/runtime/internal/runtime.eface" %1, %"{{.*}}/runtime/internal/runtime.eface" zeroinitializer) +// CHECK-NEXT: br i1 %2, label %_llgo_1, label %_llgo_2 // CHECK-EMPTY: // CHECK-NEXT: _llgo_1: ; preds = %_llgo_0 -// CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 12 }, ptr %2, align 8 -// CHECK-NEXT: %3 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %2, 1 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Panic"(%"{{.*}}/runtime/internal/runtime.eface" %3) +// CHECK-NEXT: %3 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 12 }, ptr %3, align 8 +// CHECK-NEXT: %4 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %3, 1 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Panic"(%"{{.*}}/runtime/internal/runtime.eface" %4) // CHECK-NEXT: unreachable // CHECK-EMPTY: // CHECK-NEXT: _llgo_2: ; preds = %_llgo_0 @@ -373,7 +381,7 @@ func slice2(n int) { // CHECK-LABEL: define void @"main.init#11"(){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %0 = call ptr @"{{.*}}/runtime/internal/runtime.GetThreadDefer"() -// CHECK-NEXT: %1 = alloca i8 +// CHECK-NEXT: %1 = alloca i8, i64 {{.*}}, align 1 // CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 48) // CHECK-NEXT: %3 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, i32 0, i32 0 // CHECK-NEXT: store ptr %1, ptr %3, align 8 @@ -399,41 +407,43 @@ func slice2(n int) { // CHECK-NEXT: _llgo_2: ; preds = %_llgo_5, %_llgo_4 // CHECK-NEXT: store ptr blockaddress(@"main.init#11", %_llgo_3), ptr %8, align 8 // CHECK-NEXT: %13 = load i64, ptr %7, align 8 +// CHECK-NEXT: %14 = call ptr @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr @"main.init#11$1") // CHECK-NEXT: call void @"main.init#11$1"() -// CHECK-NEXT: %14 = load %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, align 8 -// CHECK-NEXT: %15 = extractvalue %"{{.*}}/runtime/internal/runtime.Defer" %14, 2 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.SetThreadDefer"(ptr %15) -// CHECK-NEXT: %16 = load ptr, ptr %9, align 8 -// CHECK-NEXT: indirectbr ptr %16, [label %_llgo_3, label %_llgo_6] +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %14) +// CHECK-NEXT: %15 = load %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, align 8 +// CHECK-NEXT: %16 = extractvalue %"{{.*}}/runtime/internal/runtime.Defer" %15, 2 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.SetThreadDefer"(ptr %16) +// CHECK-NEXT: %17 = load ptr, ptr %9, align 8 +// CHECK-NEXT: indirectbr ptr %17, [label %_llgo_3, label %_llgo_6] // CHECK-EMPTY: // CHECK-NEXT: _llgo_3: ; preds = %_llgo_5, %_llgo_2 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Rethrow"(ptr %0) // CHECK-NEXT: br label %_llgo_1 // CHECK-EMPTY: // CHECK-NEXT: _llgo_4: ; preds = %_llgo_0 -// CHECK-NEXT: %17 = call ptr @"{{.*}}/runtime/internal/runtime.AllocZ"(i64 16) -// CHECK-NEXT: %18 = getelementptr inbounds i64, ptr %17, i64 0 -// CHECK-NEXT: store i64 1, ptr %18, align 8 -// CHECK-NEXT: %19 = getelementptr inbounds i64, ptr %17, i64 1 -// CHECK-NEXT: store i64 2, ptr %19, align 8 -// CHECK-NEXT: %20 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" undef, ptr %17, 0 -// CHECK-NEXT: %21 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" %20, i64 2, 1 -// CHECK-NEXT: %22 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" %21, i64 2, 2 -// CHECK-NEXT: %23 = extractvalue %"{{.*}}/runtime/internal/runtime.Slice" %22, 0 -// CHECK-NEXT: %24 = extractvalue %"{{.*}}/runtime/internal/runtime.Slice" %22, 1 -// CHECK-NEXT: %25 = icmp uge i64 2, %24 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.CheckIndexRange"(i1 %25, i64 2, i1 true, i64 %24) -// CHECK-NEXT: %26 = getelementptr inbounds i64, ptr %23, i64 2 -// CHECK-NEXT: %27 = load i64, ptr %26, align 8 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintInt"(i64 %27) +// CHECK-NEXT: %18 = call ptr @"{{.*}}/runtime/internal/runtime.AllocZ"(i64 16) +// CHECK-NEXT: %19 = getelementptr inbounds i64, ptr %18, i64 0 +// CHECK-NEXT: store i64 1, ptr %19, align 8 +// CHECK-NEXT: %20 = getelementptr inbounds i64, ptr %18, i64 1 +// CHECK-NEXT: store i64 2, ptr %20, align 8 +// CHECK-NEXT: %21 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" undef, ptr %18, 0 +// CHECK-NEXT: %22 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" %21, i64 2, 1 +// CHECK-NEXT: %23 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" %22, i64 2, 2 +// CHECK-NEXT: %24 = extractvalue %"{{.*}}/runtime/internal/runtime.Slice" %23, 0 +// CHECK-NEXT: %25 = extractvalue %"{{.*}}/runtime/internal/runtime.Slice" %23, 1 +// CHECK-NEXT: %26 = icmp uge i64 2, %25 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.CheckIndexRange"(i1 %26, i64 2, i1 true, i64 %25) +// CHECK-NEXT: %27 = getelementptr inbounds i64, ptr %24, i64 2 +// CHECK-NEXT: %28 = load i64, ptr %27, align 8 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintInt"(i64 %28) // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintByte"(i8 10) // CHECK-NEXT: store ptr blockaddress(@"main.init#11", %_llgo_6), ptr %9, align 8 // CHECK-NEXT: br label %_llgo_2 // CHECK-EMPTY: // CHECK-NEXT: _llgo_5: ; preds = %_llgo_0 // CHECK-NEXT: store ptr blockaddress(@"main.init#11", %_llgo_3), ptr %9, align 8 -// CHECK-NEXT: %28 = load ptr, ptr %8, align 8 -// CHECK-NEXT: indirectbr ptr %28, [label %_llgo_3, label %_llgo_2] +// CHECK-NEXT: %29 = load ptr, ptr %8, align 8 +// CHECK-NEXT: indirectbr ptr %29, [label %_llgo_3, label %_llgo_2] // CHECK-EMPTY: // CHECK-NEXT: _llgo_6: ; preds = %_llgo_2 // CHECK-NEXT: ret void @@ -441,15 +451,17 @@ func slice2(n int) { // CHECK-LABEL: define void @"main.init#11$1"(){{.*}} { // CHECK-NEXT: _llgo_0: -// CHECK-NEXT: %0 = call %"{{.*}}/runtime/internal/runtime.eface" @"{{.*}}/runtime/internal/runtime.Recover"() -// CHECK-NEXT: %1 = call i1 @"{{.*}}/runtime/internal/runtime.EfaceEqual"(%"{{.*}}/runtime/internal/runtime.eface" %0, %"{{.*}}/runtime/internal/runtime.eface" zeroinitializer) -// CHECK-NEXT: br i1 %1, label %_llgo_1, label %_llgo_2 +// CHECK-NEXT: %0 = alloca i8, align 1 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.BindRecoverFrame"(ptr @"main.init#11$1", ptr %0) +// CHECK-NEXT: %1 = call %"{{.*}}/runtime/internal/runtime.eface" @"{{.*}}/runtime/internal/runtime.Recover"(ptr %0) +// CHECK-NEXT: %2 = call i1 @"{{.*}}/runtime/internal/runtime.EfaceEqual"(%"{{.*}}/runtime/internal/runtime.eface" %1, %"{{.*}}/runtime/internal/runtime.eface" zeroinitializer) +// CHECK-NEXT: br i1 %2, label %_llgo_1, label %_llgo_2 // CHECK-EMPTY: // CHECK-NEXT: _llgo_1: ; preds = %_llgo_0 -// CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 13 }, ptr %2, align 8 -// CHECK-NEXT: %3 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %2, 1 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Panic"(%"{{.*}}/runtime/internal/runtime.eface" %3) +// CHECK-NEXT: %3 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 13 }, ptr %3, align 8 +// CHECK-NEXT: %4 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %3, 1 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Panic"(%"{{.*}}/runtime/internal/runtime.eface" %4) // CHECK-NEXT: unreachable // CHECK-EMPTY: // CHECK-NEXT: _llgo_2: ; preds = %_llgo_0 @@ -459,7 +471,7 @@ func slice2(n int) { // CHECK-LABEL: define void @"main.init#12"(){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %0 = call ptr @"{{.*}}/runtime/internal/runtime.GetThreadDefer"() -// CHECK-NEXT: %1 = alloca i8 +// CHECK-NEXT: %1 = alloca i8, i64 {{.*}}, align 1 // CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 48) // CHECK-NEXT: %3 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, i32 0, i32 0 // CHECK-NEXT: store ptr %1, ptr %3, align 8 @@ -485,41 +497,43 @@ func slice2(n int) { // CHECK-NEXT: _llgo_2: ; preds = %_llgo_5, %_llgo_4 // CHECK-NEXT: store ptr blockaddress(@"main.init#12", %_llgo_3), ptr %8, align 8 // CHECK-NEXT: %13 = load i64, ptr %7, align 8 +// CHECK-NEXT: %14 = call ptr @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr @"main.init#12$1") // CHECK-NEXT: call void @"main.init#12$1"() -// CHECK-NEXT: %14 = load %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, align 8 -// CHECK-NEXT: %15 = extractvalue %"{{.*}}/runtime/internal/runtime.Defer" %14, 2 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.SetThreadDefer"(ptr %15) -// CHECK-NEXT: %16 = load ptr, ptr %9, align 8 -// CHECK-NEXT: indirectbr ptr %16, [label %_llgo_3, label %_llgo_6] +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %14) +// CHECK-NEXT: %15 = load %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, align 8 +// CHECK-NEXT: %16 = extractvalue %"{{.*}}/runtime/internal/runtime.Defer" %15, 2 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.SetThreadDefer"(ptr %16) +// CHECK-NEXT: %17 = load ptr, ptr %9, align 8 +// CHECK-NEXT: indirectbr ptr %17, [label %_llgo_3, label %_llgo_6] // CHECK-EMPTY: // CHECK-NEXT: _llgo_3: ; preds = %_llgo_5, %_llgo_2 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Rethrow"(ptr %0) // CHECK-NEXT: br label %_llgo_1 // CHECK-EMPTY: // CHECK-NEXT: _llgo_4: ; preds = %_llgo_0 -// CHECK-NEXT: %17 = call ptr @"{{.*}}/runtime/internal/runtime.AllocZ"(i64 16) -// CHECK-NEXT: %18 = getelementptr inbounds i64, ptr %17, i64 0 -// CHECK-NEXT: store i64 1, ptr %18, align 8 -// CHECK-NEXT: %19 = getelementptr inbounds i64, ptr %17, i64 1 -// CHECK-NEXT: store i64 2, ptr %19, align 8 -// CHECK-NEXT: %20 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" undef, ptr %17, 0 -// CHECK-NEXT: %21 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" %20, i64 2, 1 -// CHECK-NEXT: %22 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" %21, i64 2, 2 -// CHECK-NEXT: %23 = extractvalue %"{{.*}}/runtime/internal/runtime.Slice" %22, 0 -// CHECK-NEXT: %24 = extractvalue %"{{.*}}/runtime/internal/runtime.Slice" %22, 1 -// CHECK-NEXT: %25 = icmp uge i64 2, %24 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.CheckIndexRange"(i1 %25, i64 2, i1 false, i64 %24) -// CHECK-NEXT: %26 = getelementptr inbounds i64, ptr %23, i64 2 -// CHECK-NEXT: %27 = load i64, ptr %26, align 8 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintInt"(i64 %27) +// CHECK-NEXT: %18 = call ptr @"{{.*}}/runtime/internal/runtime.AllocZ"(i64 16) +// CHECK-NEXT: %19 = getelementptr inbounds i64, ptr %18, i64 0 +// CHECK-NEXT: store i64 1, ptr %19, align 8 +// CHECK-NEXT: %20 = getelementptr inbounds i64, ptr %18, i64 1 +// CHECK-NEXT: store i64 2, ptr %20, align 8 +// CHECK-NEXT: %21 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" undef, ptr %18, 0 +// CHECK-NEXT: %22 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" %21, i64 2, 1 +// CHECK-NEXT: %23 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" %22, i64 2, 2 +// CHECK-NEXT: %24 = extractvalue %"{{.*}}/runtime/internal/runtime.Slice" %23, 0 +// CHECK-NEXT: %25 = extractvalue %"{{.*}}/runtime/internal/runtime.Slice" %23, 1 +// CHECK-NEXT: %26 = icmp uge i64 2, %25 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.CheckIndexRange"(i1 %26, i64 2, i1 false, i64 %25) +// CHECK-NEXT: %27 = getelementptr inbounds i64, ptr %24, i64 2 +// CHECK-NEXT: %28 = load i64, ptr %27, align 8 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintInt"(i64 %28) // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintByte"(i8 10) // CHECK-NEXT: store ptr blockaddress(@"main.init#12", %_llgo_6), ptr %9, align 8 // CHECK-NEXT: br label %_llgo_2 // CHECK-EMPTY: // CHECK-NEXT: _llgo_5: ; preds = %_llgo_0 // CHECK-NEXT: store ptr blockaddress(@"main.init#12", %_llgo_3), ptr %9, align 8 -// CHECK-NEXT: %28 = load ptr, ptr %8, align 8 -// CHECK-NEXT: indirectbr ptr %28, [label %_llgo_3, label %_llgo_2] +// CHECK-NEXT: %29 = load ptr, ptr %8, align 8 +// CHECK-NEXT: indirectbr ptr %29, [label %_llgo_3, label %_llgo_2] // CHECK-EMPTY: // CHECK-NEXT: _llgo_6: ; preds = %_llgo_2 // CHECK-NEXT: ret void @@ -527,15 +541,17 @@ func slice2(n int) { // CHECK-LABEL: define void @"main.init#12$1"(){{.*}} { // CHECK-NEXT: _llgo_0: -// CHECK-NEXT: %0 = call %"{{.*}}/runtime/internal/runtime.eface" @"{{.*}}/runtime/internal/runtime.Recover"() -// CHECK-NEXT: %1 = call i1 @"{{.*}}/runtime/internal/runtime.EfaceEqual"(%"{{.*}}/runtime/internal/runtime.eface" %0, %"{{.*}}/runtime/internal/runtime.eface" zeroinitializer) -// CHECK-NEXT: br i1 %1, label %_llgo_1, label %_llgo_2 +// CHECK-NEXT: %0 = alloca i8, align 1 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.BindRecoverFrame"(ptr @"main.init#12$1", ptr %0) +// CHECK-NEXT: %1 = call %"{{.*}}/runtime/internal/runtime.eface" @"{{.*}}/runtime/internal/runtime.Recover"(ptr %0) +// CHECK-NEXT: %2 = call i1 @"{{.*}}/runtime/internal/runtime.EfaceEqual"(%"{{.*}}/runtime/internal/runtime.eface" %1, %"{{.*}}/runtime/internal/runtime.eface" zeroinitializer) +// CHECK-NEXT: br i1 %2, label %_llgo_1, label %_llgo_2 // CHECK-EMPTY: // CHECK-NEXT: _llgo_1: ; preds = %_llgo_0 -// CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 12 }, ptr %2, align 8 -// CHECK-NEXT: %3 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %2, 1 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Panic"(%"{{.*}}/runtime/internal/runtime.eface" %3) +// CHECK-NEXT: %3 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 12 }, ptr %3, align 8 +// CHECK-NEXT: %4 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %3, 1 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Panic"(%"{{.*}}/runtime/internal/runtime.eface" %4) // CHECK-NEXT: unreachable // CHECK-EMPTY: // CHECK-NEXT: _llgo_2: ; preds = %_llgo_0 @@ -545,7 +561,7 @@ func slice2(n int) { // CHECK-LABEL: define void @"main.init#2"(){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %0 = call ptr @"{{.*}}/runtime/internal/runtime.GetThreadDefer"() -// CHECK-NEXT: %1 = alloca i8 +// CHECK-NEXT: %1 = alloca i8, i64 {{.*}}, align 1 // CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 48) // CHECK-NEXT: %3 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, i32 0, i32 0 // CHECK-NEXT: store ptr %1, ptr %3, align 8 @@ -571,12 +587,14 @@ func slice2(n int) { // CHECK-NEXT: _llgo_2: ; preds = %_llgo_5, %_llgo_4 // CHECK-NEXT: store ptr blockaddress(@"main.init#2", %_llgo_3), ptr %8, align 8 // CHECK-NEXT: %13 = load i64, ptr %7, align 8 +// CHECK-NEXT: %14 = call ptr @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr @"main.init#2$1") // CHECK-NEXT: call void @"main.init#2$1"() -// CHECK-NEXT: %14 = load %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, align 8 -// CHECK-NEXT: %15 = extractvalue %"{{.*}}/runtime/internal/runtime.Defer" %14, 2 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.SetThreadDefer"(ptr %15) -// CHECK-NEXT: %16 = load ptr, ptr %9, align 8 -// CHECK-NEXT: indirectbr ptr %16, [label %_llgo_3, label %_llgo_6] +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %14) +// CHECK-NEXT: %15 = load %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, align 8 +// CHECK-NEXT: %16 = extractvalue %"{{.*}}/runtime/internal/runtime.Defer" %15, 2 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.SetThreadDefer"(ptr %16) +// CHECK-NEXT: %17 = load ptr, ptr %9, align 8 +// CHECK-NEXT: indirectbr ptr %17, [label %_llgo_3, label %_llgo_6] // CHECK-EMPTY: // CHECK-NEXT: _llgo_3: ; preds = %_llgo_5, %_llgo_2 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Rethrow"(ptr %0) @@ -589,8 +607,8 @@ func slice2(n int) { // CHECK-EMPTY: // CHECK-NEXT: _llgo_5: ; preds = %_llgo_0 // CHECK-NEXT: store ptr blockaddress(@"main.init#2", %_llgo_3), ptr %9, align 8 -// CHECK-NEXT: %17 = load ptr, ptr %8, align 8 -// CHECK-NEXT: indirectbr ptr %17, [label %_llgo_3, label %_llgo_2] +// CHECK-NEXT: %18 = load ptr, ptr %8, align 8 +// CHECK-NEXT: indirectbr ptr %18, [label %_llgo_3, label %_llgo_2] // CHECK-EMPTY: // CHECK-NEXT: _llgo_6: ; preds = %_llgo_2 // CHECK-NEXT: ret void @@ -598,15 +616,17 @@ func slice2(n int) { // CHECK-LABEL: define void @"main.init#2$1"(){{.*}} { // CHECK-NEXT: _llgo_0: -// CHECK-NEXT: %0 = call %"{{.*}}/runtime/internal/runtime.eface" @"{{.*}}/runtime/internal/runtime.Recover"() -// CHECK-NEXT: %1 = call i1 @"{{.*}}/runtime/internal/runtime.EfaceEqual"(%"{{.*}}/runtime/internal/runtime.eface" %0, %"{{.*}}/runtime/internal/runtime.eface" zeroinitializer) -// CHECK-NEXT: br i1 %1, label %_llgo_1, label %_llgo_2 +// CHECK-NEXT: %0 = alloca i8, align 1 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.BindRecoverFrame"(ptr @"main.init#2$1", ptr %0) +// CHECK-NEXT: %1 = call %"{{.*}}/runtime/internal/runtime.eface" @"{{.*}}/runtime/internal/runtime.Recover"(ptr %0) +// CHECK-NEXT: %2 = call i1 @"{{.*}}/runtime/internal/runtime.EfaceEqual"(%"{{.*}}/runtime/internal/runtime.eface" %1, %"{{.*}}/runtime/internal/runtime.eface" zeroinitializer) +// CHECK-NEXT: br i1 %2, label %_llgo_1, label %_llgo_2 // CHECK-EMPTY: // CHECK-NEXT: _llgo_1: ; preds = %_llgo_0 -// CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 18 }, ptr %2, align 8 -// CHECK-NEXT: %3 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %2, 1 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Panic"(%"{{.*}}/runtime/internal/runtime.eface" %3) +// CHECK-NEXT: %3 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 18 }, ptr %3, align 8 +// CHECK-NEXT: %4 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %3, 1 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Panic"(%"{{.*}}/runtime/internal/runtime.eface" %4) // CHECK-NEXT: unreachable // CHECK-EMPTY: // CHECK-NEXT: _llgo_2: ; preds = %_llgo_0 @@ -616,7 +636,7 @@ func slice2(n int) { // CHECK-LABEL: define void @"main.init#3"(){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %0 = call ptr @"{{.*}}/runtime/internal/runtime.GetThreadDefer"() -// CHECK-NEXT: %1 = alloca i8 +// CHECK-NEXT: %1 = alloca i8, i64 {{.*}}, align 1 // CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 48) // CHECK-NEXT: %3 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, i32 0, i32 0 // CHECK-NEXT: store ptr %1, ptr %3, align 8 @@ -642,12 +662,14 @@ func slice2(n int) { // CHECK-NEXT: _llgo_2: ; preds = %_llgo_5, %_llgo_4 // CHECK-NEXT: store ptr blockaddress(@"main.init#3", %_llgo_3), ptr %8, align 8 // CHECK-NEXT: %13 = load i64, ptr %7, align 8 +// CHECK-NEXT: %14 = call ptr @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr @"main.init#3$1") // CHECK-NEXT: call void @"main.init#3$1"() -// CHECK-NEXT: %14 = load %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, align 8 -// CHECK-NEXT: %15 = extractvalue %"{{.*}}/runtime/internal/runtime.Defer" %14, 2 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.SetThreadDefer"(ptr %15) -// CHECK-NEXT: %16 = load ptr, ptr %9, align 8 -// CHECK-NEXT: indirectbr ptr %16, [label %_llgo_3, label %_llgo_6] +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %14) +// CHECK-NEXT: %15 = load %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, align 8 +// CHECK-NEXT: %16 = extractvalue %"{{.*}}/runtime/internal/runtime.Defer" %15, 2 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.SetThreadDefer"(ptr %16) +// CHECK-NEXT: %17 = load ptr, ptr %9, align 8 +// CHECK-NEXT: indirectbr ptr %17, [label %_llgo_3, label %_llgo_6] // CHECK-EMPTY: // CHECK-NEXT: _llgo_3: ; preds = %_llgo_5, %_llgo_2 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Rethrow"(ptr %0) @@ -660,8 +682,8 @@ func slice2(n int) { // CHECK-EMPTY: // CHECK-NEXT: _llgo_5: ; preds = %_llgo_0 // CHECK-NEXT: store ptr blockaddress(@"main.init#3", %_llgo_3), ptr %9, align 8 -// CHECK-NEXT: %17 = load ptr, ptr %8, align 8 -// CHECK-NEXT: indirectbr ptr %17, [label %_llgo_3, label %_llgo_2] +// CHECK-NEXT: %18 = load ptr, ptr %8, align 8 +// CHECK-NEXT: indirectbr ptr %18, [label %_llgo_3, label %_llgo_2] // CHECK-EMPTY: // CHECK-NEXT: _llgo_6: ; preds = %_llgo_2 // CHECK-NEXT: ret void @@ -669,15 +691,17 @@ func slice2(n int) { // CHECK-LABEL: define void @"main.init#3$1"(){{.*}} { // CHECK-NEXT: _llgo_0: -// CHECK-NEXT: %0 = call %"{{.*}}/runtime/internal/runtime.eface" @"{{.*}}/runtime/internal/runtime.Recover"() -// CHECK-NEXT: %1 = call i1 @"{{.*}}/runtime/internal/runtime.EfaceEqual"(%"{{.*}}/runtime/internal/runtime.eface" %0, %"{{.*}}/runtime/internal/runtime.eface" zeroinitializer) -// CHECK-NEXT: br i1 %1, label %_llgo_1, label %_llgo_2 +// CHECK-NEXT: %0 = alloca i8, align 1 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.BindRecoverFrame"(ptr @"main.init#3$1", ptr %0) +// CHECK-NEXT: %1 = call %"{{.*}}/runtime/internal/runtime.eface" @"{{.*}}/runtime/internal/runtime.Recover"(ptr %0) +// CHECK-NEXT: %2 = call i1 @"{{.*}}/runtime/internal/runtime.EfaceEqual"(%"{{.*}}/runtime/internal/runtime.eface" %1, %"{{.*}}/runtime/internal/runtime.eface" zeroinitializer) +// CHECK-NEXT: br i1 %2, label %_llgo_1, label %_llgo_2 // CHECK-EMPTY: // CHECK-NEXT: _llgo_1: ; preds = %_llgo_0 -// CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 17 }, ptr %2, align 8 -// CHECK-NEXT: %3 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %2, 1 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Panic"(%"{{.*}}/runtime/internal/runtime.eface" %3) +// CHECK-NEXT: %3 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 17 }, ptr %3, align 8 +// CHECK-NEXT: %4 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %3, 1 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Panic"(%"{{.*}}/runtime/internal/runtime.eface" %4) // CHECK-NEXT: unreachable // CHECK-EMPTY: // CHECK-NEXT: _llgo_2: ; preds = %_llgo_0 @@ -687,7 +711,7 @@ func slice2(n int) { // CHECK-LABEL: define void @"main.init#4"(){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %0 = call ptr @"{{.*}}/runtime/internal/runtime.GetThreadDefer"() -// CHECK-NEXT: %1 = alloca i8 +// CHECK-NEXT: %1 = alloca i8, i64 {{.*}}, align 1 // CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 48) // CHECK-NEXT: %3 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, i32 0, i32 0 // CHECK-NEXT: store ptr %1, ptr %3, align 8 @@ -713,12 +737,14 @@ func slice2(n int) { // CHECK-NEXT: _llgo_2: ; preds = %_llgo_5, %_llgo_4 // CHECK-NEXT: store ptr blockaddress(@"main.init#4", %_llgo_3), ptr %8, align 8 // CHECK-NEXT: %13 = load i64, ptr %7, align 8 +// CHECK-NEXT: %14 = call ptr @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr @"main.init#4$1") // CHECK-NEXT: call void @"main.init#4$1"() -// CHECK-NEXT: %14 = load %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, align 8 -// CHECK-NEXT: %15 = extractvalue %"{{.*}}/runtime/internal/runtime.Defer" %14, 2 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.SetThreadDefer"(ptr %15) -// CHECK-NEXT: %16 = load ptr, ptr %9, align 8 -// CHECK-NEXT: indirectbr ptr %16, [label %_llgo_3, label %_llgo_6] +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %14) +// CHECK-NEXT: %15 = load %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, align 8 +// CHECK-NEXT: %16 = extractvalue %"{{.*}}/runtime/internal/runtime.Defer" %15, 2 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.SetThreadDefer"(ptr %16) +// CHECK-NEXT: %17 = load ptr, ptr %9, align 8 +// CHECK-NEXT: indirectbr ptr %17, [label %_llgo_3, label %_llgo_6] // CHECK-EMPTY: // CHECK-NEXT: _llgo_3: ; preds = %_llgo_5, %_llgo_2 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Rethrow"(ptr %0) @@ -731,8 +757,8 @@ func slice2(n int) { // CHECK-EMPTY: // CHECK-NEXT: _llgo_5: ; preds = %_llgo_0 // CHECK-NEXT: store ptr blockaddress(@"main.init#4", %_llgo_3), ptr %9, align 8 -// CHECK-NEXT: %17 = load ptr, ptr %8, align 8 -// CHECK-NEXT: indirectbr ptr %17, [label %_llgo_3, label %_llgo_2] +// CHECK-NEXT: %18 = load ptr, ptr %8, align 8 +// CHECK-NEXT: indirectbr ptr %18, [label %_llgo_3, label %_llgo_2] // CHECK-EMPTY: // CHECK-NEXT: _llgo_6: ; preds = %_llgo_2 // CHECK-NEXT: ret void @@ -740,15 +766,17 @@ func slice2(n int) { // CHECK-LABEL: define void @"main.init#4$1"(){{.*}} { // CHECK-NEXT: _llgo_0: -// CHECK-NEXT: %0 = call %"{{.*}}/runtime/internal/runtime.eface" @"{{.*}}/runtime/internal/runtime.Recover"() -// CHECK-NEXT: %1 = call i1 @"{{.*}}/runtime/internal/runtime.EfaceEqual"(%"{{.*}}/runtime/internal/runtime.eface" %0, %"{{.*}}/runtime/internal/runtime.eface" zeroinitializer) -// CHECK-NEXT: br i1 %1, label %_llgo_1, label %_llgo_2 +// CHECK-NEXT: %0 = alloca i8, align 1 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.BindRecoverFrame"(ptr @"main.init#4$1", ptr %0) +// CHECK-NEXT: %1 = call %"{{.*}}/runtime/internal/runtime.eface" @"{{.*}}/runtime/internal/runtime.Recover"(ptr %0) +// CHECK-NEXT: %2 = call i1 @"{{.*}}/runtime/internal/runtime.EfaceEqual"(%"{{.*}}/runtime/internal/runtime.eface" %1, %"{{.*}}/runtime/internal/runtime.eface" zeroinitializer) +// CHECK-NEXT: br i1 %2, label %_llgo_1, label %_llgo_2 // CHECK-EMPTY: // CHECK-NEXT: _llgo_1: ; preds = %_llgo_0 -// CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 19 }, ptr %2, align 8 -// CHECK-NEXT: %3 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %2, 1 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Panic"(%"{{.*}}/runtime/internal/runtime.eface" %3) +// CHECK-NEXT: %3 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 19 }, ptr %3, align 8 +// CHECK-NEXT: %4 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %3, 1 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Panic"(%"{{.*}}/runtime/internal/runtime.eface" %4) // CHECK-NEXT: unreachable // CHECK-EMPTY: // CHECK-NEXT: _llgo_2: ; preds = %_llgo_0 @@ -758,7 +786,7 @@ func slice2(n int) { // CHECK-LABEL: define void @"main.init#5"(){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %0 = call ptr @"{{.*}}/runtime/internal/runtime.GetThreadDefer"() -// CHECK-NEXT: %1 = alloca i8 +// CHECK-NEXT: %1 = alloca i8, i64 {{.*}}, align 1 // CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 48) // CHECK-NEXT: %3 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, i32 0, i32 0 // CHECK-NEXT: store ptr %1, ptr %3, align 8 @@ -784,12 +812,14 @@ func slice2(n int) { // CHECK-NEXT: _llgo_2: ; preds = %_llgo_5, %_llgo_4 // CHECK-NEXT: store ptr blockaddress(@"main.init#5", %_llgo_3), ptr %8, align 8 // CHECK-NEXT: %13 = load i64, ptr %7, align 8 +// CHECK-NEXT: %14 = call ptr @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr @"main.init#5$1") // CHECK-NEXT: call void @"main.init#5$1"() -// CHECK-NEXT: %14 = load %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, align 8 -// CHECK-NEXT: %15 = extractvalue %"{{.*}}/runtime/internal/runtime.Defer" %14, 2 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.SetThreadDefer"(ptr %15) -// CHECK-NEXT: %16 = load ptr, ptr %9, align 8 -// CHECK-NEXT: indirectbr ptr %16, [label %_llgo_3, label %_llgo_6] +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %14) +// CHECK-NEXT: %15 = load %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, align 8 +// CHECK-NEXT: %16 = extractvalue %"{{.*}}/runtime/internal/runtime.Defer" %15, 2 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.SetThreadDefer"(ptr %16) +// CHECK-NEXT: %17 = load ptr, ptr %9, align 8 +// CHECK-NEXT: indirectbr ptr %17, [label %_llgo_3, label %_llgo_6] // CHECK-EMPTY: // CHECK-NEXT: _llgo_3: ; preds = %_llgo_5, %_llgo_2 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Rethrow"(ptr %0) @@ -802,8 +832,8 @@ func slice2(n int) { // CHECK-EMPTY: // CHECK-NEXT: _llgo_5: ; preds = %_llgo_0 // CHECK-NEXT: store ptr blockaddress(@"main.init#5", %_llgo_3), ptr %9, align 8 -// CHECK-NEXT: %17 = load ptr, ptr %8, align 8 -// CHECK-NEXT: indirectbr ptr %17, [label %_llgo_3, label %_llgo_2] +// CHECK-NEXT: %18 = load ptr, ptr %8, align 8 +// CHECK-NEXT: indirectbr ptr %18, [label %_llgo_3, label %_llgo_2] // CHECK-EMPTY: // CHECK-NEXT: _llgo_6: ; preds = %_llgo_2 // CHECK-NEXT: ret void @@ -811,15 +841,17 @@ func slice2(n int) { // CHECK-LABEL: define void @"main.init#5$1"(){{.*}} { // CHECK-NEXT: _llgo_0: -// CHECK-NEXT: %0 = call %"{{.*}}/runtime/internal/runtime.eface" @"{{.*}}/runtime/internal/runtime.Recover"() -// CHECK-NEXT: %1 = call i1 @"{{.*}}/runtime/internal/runtime.EfaceEqual"(%"{{.*}}/runtime/internal/runtime.eface" %0, %"{{.*}}/runtime/internal/runtime.eface" zeroinitializer) -// CHECK-NEXT: br i1 %1, label %_llgo_1, label %_llgo_2 +// CHECK-NEXT: %0 = alloca i8, align 1 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.BindRecoverFrame"(ptr @"main.init#5$1", ptr %0) +// CHECK-NEXT: %1 = call %"{{.*}}/runtime/internal/runtime.eface" @"{{.*}}/runtime/internal/runtime.Recover"(ptr %0) +// CHECK-NEXT: %2 = call i1 @"{{.*}}/runtime/internal/runtime.EfaceEqual"(%"{{.*}}/runtime/internal/runtime.eface" %1, %"{{.*}}/runtime/internal/runtime.eface" zeroinitializer) +// CHECK-NEXT: br i1 %2, label %_llgo_1, label %_llgo_2 // CHECK-EMPTY: // CHECK-NEXT: _llgo_1: ; preds = %_llgo_0 -// CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 18 }, ptr %2, align 8 -// CHECK-NEXT: %3 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %2, 1 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Panic"(%"{{.*}}/runtime/internal/runtime.eface" %3) +// CHECK-NEXT: %3 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 18 }, ptr %3, align 8 +// CHECK-NEXT: %4 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %3, 1 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Panic"(%"{{.*}}/runtime/internal/runtime.eface" %4) // CHECK-NEXT: unreachable // CHECK-EMPTY: // CHECK-NEXT: _llgo_2: ; preds = %_llgo_0 @@ -829,7 +861,7 @@ func slice2(n int) { // CHECK-LABEL: define void @"main.init#6"(){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %0 = call ptr @"{{.*}}/runtime/internal/runtime.GetThreadDefer"() -// CHECK-NEXT: %1 = alloca i8 +// CHECK-NEXT: %1 = alloca i8, i64 {{.*}}, align 1 // CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 48) // CHECK-NEXT: %3 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, i32 0, i32 0 // CHECK-NEXT: store ptr %1, ptr %3, align 8 @@ -855,12 +887,14 @@ func slice2(n int) { // CHECK-NEXT: _llgo_2: ; preds = %_llgo_5, %_llgo_4 // CHECK-NEXT: store ptr blockaddress(@"main.init#6", %_llgo_3), ptr %8, align 8 // CHECK-NEXT: %13 = load i64, ptr %7, align 8 +// CHECK-NEXT: %14 = call ptr @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr @"main.init#6$1") // CHECK-NEXT: call void @"main.init#6$1"() -// CHECK-NEXT: %14 = load %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, align 8 -// CHECK-NEXT: %15 = extractvalue %"{{.*}}/runtime/internal/runtime.Defer" %14, 2 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.SetThreadDefer"(ptr %15) -// CHECK-NEXT: %16 = load ptr, ptr %9, align 8 -// CHECK-NEXT: indirectbr ptr %16, [label %_llgo_3, label %_llgo_6] +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %14) +// CHECK-NEXT: %15 = load %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, align 8 +// CHECK-NEXT: %16 = extractvalue %"{{.*}}/runtime/internal/runtime.Defer" %15, 2 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.SetThreadDefer"(ptr %16) +// CHECK-NEXT: %17 = load ptr, ptr %9, align 8 +// CHECK-NEXT: indirectbr ptr %17, [label %_llgo_3, label %_llgo_6] // CHECK-EMPTY: // CHECK-NEXT: _llgo_3: ; preds = %_llgo_5, %_llgo_2 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Rethrow"(ptr %0) @@ -873,8 +907,8 @@ func slice2(n int) { // CHECK-EMPTY: // CHECK-NEXT: _llgo_5: ; preds = %_llgo_0 // CHECK-NEXT: store ptr blockaddress(@"main.init#6", %_llgo_3), ptr %9, align 8 -// CHECK-NEXT: %17 = load ptr, ptr %8, align 8 -// CHECK-NEXT: indirectbr ptr %17, [label %_llgo_3, label %_llgo_2] +// CHECK-NEXT: %18 = load ptr, ptr %8, align 8 +// CHECK-NEXT: indirectbr ptr %18, [label %_llgo_3, label %_llgo_2] // CHECK-EMPTY: // CHECK-NEXT: _llgo_6: ; preds = %_llgo_2 // CHECK-NEXT: ret void @@ -882,15 +916,17 @@ func slice2(n int) { // CHECK-LABEL: define void @"main.init#6$1"(){{.*}} { // CHECK-NEXT: _llgo_0: -// CHECK-NEXT: %0 = call %"{{.*}}/runtime/internal/runtime.eface" @"{{.*}}/runtime/internal/runtime.Recover"() -// CHECK-NEXT: %1 = call i1 @"{{.*}}/runtime/internal/runtime.EfaceEqual"(%"{{.*}}/runtime/internal/runtime.eface" %0, %"{{.*}}/runtime/internal/runtime.eface" zeroinitializer) -// CHECK-NEXT: br i1 %1, label %_llgo_1, label %_llgo_2 +// CHECK-NEXT: %0 = alloca i8, align 1 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.BindRecoverFrame"(ptr @"main.init#6$1", ptr %0) +// CHECK-NEXT: %1 = call %"{{.*}}/runtime/internal/runtime.eface" @"{{.*}}/runtime/internal/runtime.Recover"(ptr %0) +// CHECK-NEXT: %2 = call i1 @"{{.*}}/runtime/internal/runtime.EfaceEqual"(%"{{.*}}/runtime/internal/runtime.eface" %1, %"{{.*}}/runtime/internal/runtime.eface" zeroinitializer) +// CHECK-NEXT: br i1 %2, label %_llgo_1, label %_llgo_2 // CHECK-EMPTY: // CHECK-NEXT: _llgo_1: ; preds = %_llgo_0 -// CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 19 }, ptr %2, align 8 -// CHECK-NEXT: %3 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %2, 1 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Panic"(%"{{.*}}/runtime/internal/runtime.eface" %3) +// CHECK-NEXT: %3 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 19 }, ptr %3, align 8 +// CHECK-NEXT: %4 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %3, 1 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Panic"(%"{{.*}}/runtime/internal/runtime.eface" %4) // CHECK-NEXT: unreachable // CHECK-EMPTY: // CHECK-NEXT: _llgo_2: ; preds = %_llgo_0 @@ -900,7 +936,7 @@ func slice2(n int) { // CHECK-LABEL: define void @"main.init#7"(){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %0 = call ptr @"{{.*}}/runtime/internal/runtime.GetThreadDefer"() -// CHECK-NEXT: %1 = alloca i8 +// CHECK-NEXT: %1 = alloca i8, i64 {{.*}}, align 1 // CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 48) // CHECK-NEXT: %3 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, i32 0, i32 0 // CHECK-NEXT: store ptr %1, ptr %3, align 8 @@ -926,36 +962,39 @@ func slice2(n int) { // CHECK-NEXT: _llgo_2: ; preds = %_llgo_5, %_llgo_4 // CHECK-NEXT: store ptr blockaddress(@"main.init#7", %_llgo_3), ptr %8, align 8 // CHECK-NEXT: %13 = load i64, ptr %7, align 8 +// CHECK-NEXT: %14 = call ptr @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr @"main.init#7$1") // CHECK-NEXT: call void @"main.init#7$1"() -// CHECK-NEXT: %14 = load %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, align 8 -// CHECK-NEXT: %15 = extractvalue %"{{.*}}/runtime/internal/runtime.Defer" %14, 2 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.SetThreadDefer"(ptr %15) -// CHECK-NEXT: %16 = load ptr, ptr %9, align 8 -// CHECK-NEXT: indirectbr ptr %16, [label %_llgo_3, label %_llgo_6] +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %14) +// CHECK-NEXT: %15 = load %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, align 8 +// CHECK-NEXT: %16 = extractvalue %"{{.*}}/runtime/internal/runtime.Defer" %15, 2 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.SetThreadDefer"(ptr %16) +// CHECK-NEXT: %17 = load ptr, ptr %9, align 8 +// CHECK-NEXT: indirectbr ptr %17, [label %_llgo_3, label %_llgo_6] // CHECK-EMPTY: // CHECK-NEXT: _llgo_3: ; preds = %_llgo_5, %_llgo_2 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Rethrow"(ptr %0) // CHECK-NEXT: br label %_llgo_1 // CHECK-EMPTY: // CHECK-NEXT: _llgo_4: ; preds = %_llgo_0 -// CHECK-NEXT: %17 = alloca [2 x i64], align 8 -// CHECK-NEXT: call void @llvm.memset.p0.i64(ptr %17, i8 0, i64 16, i1 false) -// CHECK-NEXT: %18 = getelementptr inbounds i64, ptr %17, i64 0 -// CHECK-NEXT: %19 = getelementptr inbounds i64, ptr %17, i64 1 -// CHECK-NEXT: store i64 1, ptr %18, align 8 -// CHECK-NEXT: store i64 2, ptr %19, align 8 +// CHECK-NEXT: %18 = alloca [2 x i64], align 8 +// CHECK-NEXT: call void @llvm.memset.p0.i64(ptr %18, i8 0, i64 16, i1 false) +// CHECK-NEXT: store volatile [2 x i64] zeroinitializer, ptr %18, align 8 +// CHECK-NEXT: %19 = getelementptr inbounds i64, ptr %18, i64 0 +// CHECK-NEXT: %20 = getelementptr inbounds i64, ptr %18, i64 1 +// CHECK-NEXT: store volatile i64 1, ptr %19, align 8 +// CHECK-NEXT: store volatile i64 2, ptr %20, align 8 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.CheckIndexRange"(i1 true, i64 -1, i1 true, i64 2) -// CHECK-NEXT: %20 = getelementptr inbounds i64, ptr %17, i64 -1 -// CHECK-NEXT: %21 = load i64, ptr %20, align 8 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintInt"(i64 %21) +// CHECK-NEXT: %21 = getelementptr inbounds i64, ptr %18, i64 -1 +// CHECK-NEXT: %22 = load volatile i64, ptr %21, align 8 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintInt"(i64 %22) // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintByte"(i8 10) // CHECK-NEXT: store ptr blockaddress(@"main.init#7", %_llgo_6), ptr %9, align 8 // CHECK-NEXT: br label %_llgo_2 // CHECK-EMPTY: // CHECK-NEXT: _llgo_5: ; preds = %_llgo_0 // CHECK-NEXT: store ptr blockaddress(@"main.init#7", %_llgo_3), ptr %9, align 8 -// CHECK-NEXT: %22 = load ptr, ptr %8, align 8 -// CHECK-NEXT: indirectbr ptr %22, [label %_llgo_3, label %_llgo_2] +// CHECK-NEXT: %23 = load ptr, ptr %8, align 8 +// CHECK-NEXT: indirectbr ptr %23, [label %_llgo_3, label %_llgo_2] // CHECK-EMPTY: // CHECK-NEXT: _llgo_6: ; preds = %_llgo_2 // CHECK-NEXT: ret void @@ -963,15 +1002,17 @@ func slice2(n int) { // CHECK-LABEL: define void @"main.init#7$1"(){{.*}} { // CHECK-NEXT: _llgo_0: -// CHECK-NEXT: %0 = call %"{{.*}}/runtime/internal/runtime.eface" @"{{.*}}/runtime/internal/runtime.Recover"() -// CHECK-NEXT: %1 = call i1 @"{{.*}}/runtime/internal/runtime.EfaceEqual"(%"{{.*}}/runtime/internal/runtime.eface" %0, %"{{.*}}/runtime/internal/runtime.eface" zeroinitializer) -// CHECK-NEXT: br i1 %1, label %_llgo_1, label %_llgo_2 +// CHECK-NEXT: %0 = alloca i8, align 1 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.BindRecoverFrame"(ptr @"main.init#7$1", ptr %0) +// CHECK-NEXT: %1 = call %"{{.*}}/runtime/internal/runtime.eface" @"{{.*}}/runtime/internal/runtime.Recover"(ptr %0) +// CHECK-NEXT: %2 = call i1 @"{{.*}}/runtime/internal/runtime.EfaceEqual"(%"{{.*}}/runtime/internal/runtime.eface" %1, %"{{.*}}/runtime/internal/runtime.eface" zeroinitializer) +// CHECK-NEXT: br i1 %2, label %_llgo_1, label %_llgo_2 // CHECK-EMPTY: // CHECK-NEXT: _llgo_1: ; preds = %_llgo_0 -// CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 12 }, ptr %2, align 8 -// CHECK-NEXT: %3 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %2, 1 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Panic"(%"{{.*}}/runtime/internal/runtime.eface" %3) +// CHECK-NEXT: %3 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 12 }, ptr %3, align 8 +// CHECK-NEXT: %4 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %3, 1 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Panic"(%"{{.*}}/runtime/internal/runtime.eface" %4) // CHECK-NEXT: unreachable // CHECK-EMPTY: // CHECK-NEXT: _llgo_2: ; preds = %_llgo_0 @@ -981,7 +1022,7 @@ func slice2(n int) { // CHECK-LABEL: define void @"main.init#8"(){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %0 = call ptr @"{{.*}}/runtime/internal/runtime.GetThreadDefer"() -// CHECK-NEXT: %1 = alloca i8 +// CHECK-NEXT: %1 = alloca i8, i64 {{.*}}, align 1 // CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 48) // CHECK-NEXT: %3 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, i32 0, i32 0 // CHECK-NEXT: store ptr %1, ptr %3, align 8 @@ -1007,36 +1048,39 @@ func slice2(n int) { // CHECK-NEXT: _llgo_2: ; preds = %_llgo_5, %_llgo_4 // CHECK-NEXT: store ptr blockaddress(@"main.init#8", %_llgo_3), ptr %8, align 8 // CHECK-NEXT: %13 = load i64, ptr %7, align 8 +// CHECK-NEXT: %14 = call ptr @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr @"main.init#8$1") // CHECK-NEXT: call void @"main.init#8$1"() -// CHECK-NEXT: %14 = load %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, align 8 -// CHECK-NEXT: %15 = extractvalue %"{{.*}}/runtime/internal/runtime.Defer" %14, 2 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.SetThreadDefer"(ptr %15) -// CHECK-NEXT: %16 = load ptr, ptr %9, align 8 -// CHECK-NEXT: indirectbr ptr %16, [label %_llgo_3, label %_llgo_6] +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %14) +// CHECK-NEXT: %15 = load %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, align 8 +// CHECK-NEXT: %16 = extractvalue %"{{.*}}/runtime/internal/runtime.Defer" %15, 2 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.SetThreadDefer"(ptr %16) +// CHECK-NEXT: %17 = load ptr, ptr %9, align 8 +// CHECK-NEXT: indirectbr ptr %17, [label %_llgo_3, label %_llgo_6] // CHECK-EMPTY: // CHECK-NEXT: _llgo_3: ; preds = %_llgo_5, %_llgo_2 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Rethrow"(ptr %0) // CHECK-NEXT: br label %_llgo_1 // CHECK-EMPTY: // CHECK-NEXT: _llgo_4: ; preds = %_llgo_0 -// CHECK-NEXT: %17 = alloca [2 x i64], align 8 -// CHECK-NEXT: call void @llvm.memset.p0.i64(ptr %17, i8 0, i64 16, i1 false) -// CHECK-NEXT: %18 = getelementptr inbounds i64, ptr %17, i64 0 -// CHECK-NEXT: %19 = getelementptr inbounds i64, ptr %17, i64 1 -// CHECK-NEXT: store i64 1, ptr %18, align 8 -// CHECK-NEXT: store i64 2, ptr %19, align 8 +// CHECK-NEXT: %18 = alloca [2 x i64], align 8 +// CHECK-NEXT: call void @llvm.memset.p0.i64(ptr %18, i8 0, i64 16, i1 false) +// CHECK-NEXT: store volatile [2 x i64] zeroinitializer, ptr %18, align 8 +// CHECK-NEXT: %19 = getelementptr inbounds i64, ptr %18, i64 0 +// CHECK-NEXT: %20 = getelementptr inbounds i64, ptr %18, i64 1 +// CHECK-NEXT: store volatile i64 1, ptr %19, align 8 +// CHECK-NEXT: store volatile i64 2, ptr %20, align 8 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.CheckIndexRange"(i1 true, i64 2, i1 true, i64 2) -// CHECK-NEXT: %20 = getelementptr inbounds i64, ptr %17, i64 2 -// CHECK-NEXT: %21 = load i64, ptr %20, align 8 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintInt"(i64 %21) +// CHECK-NEXT: %21 = getelementptr inbounds i64, ptr %18, i64 2 +// CHECK-NEXT: %22 = load volatile i64, ptr %21, align 8 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintInt"(i64 %22) // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintByte"(i8 10) // CHECK-NEXT: store ptr blockaddress(@"main.init#8", %_llgo_6), ptr %9, align 8 // CHECK-NEXT: br label %_llgo_2 // CHECK-EMPTY: // CHECK-NEXT: _llgo_5: ; preds = %_llgo_0 // CHECK-NEXT: store ptr blockaddress(@"main.init#8", %_llgo_3), ptr %9, align 8 -// CHECK-NEXT: %22 = load ptr, ptr %8, align 8 -// CHECK-NEXT: indirectbr ptr %22, [label %_llgo_3, label %_llgo_2] +// CHECK-NEXT: %23 = load ptr, ptr %8, align 8 +// CHECK-NEXT: indirectbr ptr %23, [label %_llgo_3, label %_llgo_2] // CHECK-EMPTY: // CHECK-NEXT: _llgo_6: ; preds = %_llgo_2 // CHECK-NEXT: ret void @@ -1044,15 +1088,17 @@ func slice2(n int) { // CHECK-LABEL: define void @"main.init#8$1"(){{.*}} { // CHECK-NEXT: _llgo_0: -// CHECK-NEXT: %0 = call %"{{.*}}/runtime/internal/runtime.eface" @"{{.*}}/runtime/internal/runtime.Recover"() -// CHECK-NEXT: %1 = call i1 @"{{.*}}/runtime/internal/runtime.EfaceEqual"(%"{{.*}}/runtime/internal/runtime.eface" %0, %"{{.*}}/runtime/internal/runtime.eface" zeroinitializer) -// CHECK-NEXT: br i1 %1, label %_llgo_1, label %_llgo_2 +// CHECK-NEXT: %0 = alloca i8, align 1 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.BindRecoverFrame"(ptr @"main.init#8$1", ptr %0) +// CHECK-NEXT: %1 = call %"{{.*}}/runtime/internal/runtime.eface" @"{{.*}}/runtime/internal/runtime.Recover"(ptr %0) +// CHECK-NEXT: %2 = call i1 @"{{.*}}/runtime/internal/runtime.EfaceEqual"(%"{{.*}}/runtime/internal/runtime.eface" %1, %"{{.*}}/runtime/internal/runtime.eface" zeroinitializer) +// CHECK-NEXT: br i1 %2, label %_llgo_1, label %_llgo_2 // CHECK-EMPTY: // CHECK-NEXT: _llgo_1: ; preds = %_llgo_0 -// CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 13 }, ptr %2, align 8 -// CHECK-NEXT: %3 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %2, 1 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Panic"(%"{{.*}}/runtime/internal/runtime.eface" %3) +// CHECK-NEXT: %3 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 13 }, ptr %3, align 8 +// CHECK-NEXT: %4 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %3, 1 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Panic"(%"{{.*}}/runtime/internal/runtime.eface" %4) // CHECK-NEXT: unreachable // CHECK-EMPTY: // CHECK-NEXT: _llgo_2: ; preds = %_llgo_0 @@ -1062,7 +1108,7 @@ func slice2(n int) { // CHECK-LABEL: define void @"main.init#9"(){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %0 = call ptr @"{{.*}}/runtime/internal/runtime.GetThreadDefer"() -// CHECK-NEXT: %1 = alloca i8 +// CHECK-NEXT: %1 = alloca i8, i64 {{.*}}, align 1 // CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 48) // CHECK-NEXT: %3 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, i32 0, i32 0 // CHECK-NEXT: store ptr %1, ptr %3, align 8 @@ -1088,36 +1134,39 @@ func slice2(n int) { // CHECK-NEXT: _llgo_2: ; preds = %_llgo_5, %_llgo_4 // CHECK-NEXT: store ptr blockaddress(@"main.init#9", %_llgo_3), ptr %8, align 8 // CHECK-NEXT: %13 = load i64, ptr %7, align 8 +// CHECK-NEXT: %14 = call ptr @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr @"main.init#9$1") // CHECK-NEXT: call void @"main.init#9$1"() -// CHECK-NEXT: %14 = load %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, align 8 -// CHECK-NEXT: %15 = extractvalue %"{{.*}}/runtime/internal/runtime.Defer" %14, 2 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.SetThreadDefer"(ptr %15) -// CHECK-NEXT: %16 = load ptr, ptr %9, align 8 -// CHECK-NEXT: indirectbr ptr %16, [label %_llgo_3, label %_llgo_6] +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %14) +// CHECK-NEXT: %15 = load %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, align 8 +// CHECK-NEXT: %16 = extractvalue %"{{.*}}/runtime/internal/runtime.Defer" %15, 2 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.SetThreadDefer"(ptr %16) +// CHECK-NEXT: %17 = load ptr, ptr %9, align 8 +// CHECK-NEXT: indirectbr ptr %17, [label %_llgo_3, label %_llgo_6] // CHECK-EMPTY: // CHECK-NEXT: _llgo_3: ; preds = %_llgo_5, %_llgo_2 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Rethrow"(ptr %0) // CHECK-NEXT: br label %_llgo_1 // CHECK-EMPTY: // CHECK-NEXT: _llgo_4: ; preds = %_llgo_0 -// CHECK-NEXT: %17 = alloca [2 x i64], align 8 -// CHECK-NEXT: call void @llvm.memset.p0.i64(ptr %17, i8 0, i64 16, i1 false) -// CHECK-NEXT: %18 = getelementptr inbounds i64, ptr %17, i64 0 -// CHECK-NEXT: %19 = getelementptr inbounds i64, ptr %17, i64 1 -// CHECK-NEXT: store i64 1, ptr %18, align 8 -// CHECK-NEXT: store i64 2, ptr %19, align 8 +// CHECK-NEXT: %18 = alloca [2 x i64], align 8 +// CHECK-NEXT: call void @llvm.memset.p0.i64(ptr %18, i8 0, i64 16, i1 false) +// CHECK-NEXT: store volatile [2 x i64] zeroinitializer, ptr %18, align 8 +// CHECK-NEXT: %19 = getelementptr inbounds i64, ptr %18, i64 0 +// CHECK-NEXT: %20 = getelementptr inbounds i64, ptr %18, i64 1 +// CHECK-NEXT: store volatile i64 1, ptr %19, align 8 +// CHECK-NEXT: store volatile i64 2, ptr %20, align 8 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.CheckIndexRange"(i1 true, i64 2, i1 false, i64 2) -// CHECK-NEXT: %20 = getelementptr inbounds i64, ptr %17, i64 2 -// CHECK-NEXT: %21 = load i64, ptr %20, align 8 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintInt"(i64 %21) +// CHECK-NEXT: %21 = getelementptr inbounds i64, ptr %18, i64 2 +// CHECK-NEXT: %22 = load volatile i64, ptr %21, align 8 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintInt"(i64 %22) // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintByte"(i8 10) // CHECK-NEXT: store ptr blockaddress(@"main.init#9", %_llgo_6), ptr %9, align 8 // CHECK-NEXT: br label %_llgo_2 // CHECK-EMPTY: // CHECK-NEXT: _llgo_5: ; preds = %_llgo_0 // CHECK-NEXT: store ptr blockaddress(@"main.init#9", %_llgo_3), ptr %9, align 8 -// CHECK-NEXT: %22 = load ptr, ptr %8, align 8 -// CHECK-NEXT: indirectbr ptr %22, [label %_llgo_3, label %_llgo_2] +// CHECK-NEXT: %23 = load ptr, ptr %8, align 8 +// CHECK-NEXT: indirectbr ptr %23, [label %_llgo_3, label %_llgo_2] // CHECK-EMPTY: // CHECK-NEXT: _llgo_6: ; preds = %_llgo_2 // CHECK-NEXT: ret void @@ -1125,15 +1174,17 @@ func slice2(n int) { // CHECK-LABEL: define void @"main.init#9$1"(){{.*}} { // CHECK-NEXT: _llgo_0: -// CHECK-NEXT: %0 = call %"{{.*}}/runtime/internal/runtime.eface" @"{{.*}}/runtime/internal/runtime.Recover"() -// CHECK-NEXT: %1 = call i1 @"{{.*}}/runtime/internal/runtime.EfaceEqual"(%"{{.*}}/runtime/internal/runtime.eface" %0, %"{{.*}}/runtime/internal/runtime.eface" zeroinitializer) -// CHECK-NEXT: br i1 %1, label %_llgo_1, label %_llgo_2 +// CHECK-NEXT: %0 = alloca i8, align 1 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.BindRecoverFrame"(ptr @"main.init#9$1", ptr %0) +// CHECK-NEXT: %1 = call %"{{.*}}/runtime/internal/runtime.eface" @"{{.*}}/runtime/internal/runtime.Recover"(ptr %0) +// CHECK-NEXT: %2 = call i1 @"{{.*}}/runtime/internal/runtime.EfaceEqual"(%"{{.*}}/runtime/internal/runtime.eface" %1, %"{{.*}}/runtime/internal/runtime.eface" zeroinitializer) +// CHECK-NEXT: br i1 %2, label %_llgo_1, label %_llgo_2 // CHECK-EMPTY: // CHECK-NEXT: _llgo_1: ; preds = %_llgo_0 -// CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 12 }, ptr %2, align 8 -// CHECK-NEXT: %3 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %2, 1 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Panic"(%"{{.*}}/runtime/internal/runtime.eface" %3) +// CHECK-NEXT: %3 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 12 }, ptr %3, align 8 +// CHECK-NEXT: %4 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %3, 1 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Panic"(%"{{.*}}/runtime/internal/runtime.eface" %4) // CHECK-NEXT: unreachable // CHECK-EMPTY: // CHECK-NEXT: _llgo_2: ; preds = %_llgo_0 diff --git a/cl/_testgo/makeslice/in.go b/cl/_testgo/makeslice/in.go index de2ee3bba9..a8f3b01e70 100644 --- a/cl/_testgo/makeslice/in.go +++ b/cl/_testgo/makeslice/in.go @@ -126,7 +126,7 @@ func init() { // CHECK-LABEL: define void @"main.init#3"(){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %0 = call ptr @"{{.*}}/runtime/internal/runtime.GetThreadDefer"() -// CHECK-NEXT: %1 = alloca i8 +// CHECK-NEXT: %1 = alloca i8, i64 {{.*}}, align 1 // CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 48) // CHECK-NEXT: %3 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, i32 0, i32 0 // CHECK-NEXT: store ptr %1, ptr %3, align 8 @@ -152,26 +152,28 @@ func init() { // CHECK-NEXT: _llgo_2: ; preds = %_llgo_5, %_llgo_4 // CHECK-NEXT: store ptr blockaddress(@"main.init#3", %_llgo_3), ptr %8, align 8 // CHECK-NEXT: %13 = load i64, ptr %7, align 8 +// CHECK-NEXT: %14 = call ptr @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr @"main.init#3$1") // CHECK-NEXT: call void @"main.init#3$1"() -// CHECK-NEXT: %14 = load %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, align 8 -// CHECK-NEXT: %15 = extractvalue %"{{.*}}/runtime/internal/runtime.Defer" %14, 2 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.SetThreadDefer"(ptr %15) -// CHECK-NEXT: %16 = load ptr, ptr %9, align 8 -// CHECK-NEXT: indirectbr ptr %16, [label %_llgo_3, label %_llgo_6] +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %14) +// CHECK-NEXT: %15 = load %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, align 8 +// CHECK-NEXT: %16 = extractvalue %"{{.*}}/runtime/internal/runtime.Defer" %15, 2 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.SetThreadDefer"(ptr %16) +// CHECK-NEXT: %17 = load ptr, ptr %9, align 8 +// CHECK-NEXT: indirectbr ptr %17, [label %_llgo_3, label %_llgo_6] // CHECK-EMPTY: // CHECK-NEXT: _llgo_3: ; preds = %_llgo_5, %_llgo_2 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Rethrow"(ptr %0) // CHECK-NEXT: br label %_llgo_1 // CHECK-EMPTY: // CHECK-NEXT: _llgo_4: ; preds = %_llgo_0 -// CHECK-NEXT: %17 = call %"{{.*}}/runtime/internal/runtime.Slice" @"{{.*}}/runtime/internal/runtime.MakeSlice"(i64 -1, i64 -1, i64 8) +// CHECK-NEXT: %18 = call %"{{.*}}/runtime/internal/runtime.Slice" @"{{.*}}/runtime/internal/runtime.MakeSlice"(i64 -1, i64 -1, i64 8) // CHECK-NEXT: store ptr blockaddress(@"main.init#3", %_llgo_6), ptr %9, align 8 // CHECK-NEXT: br label %_llgo_2 // CHECK-EMPTY: // CHECK-NEXT: _llgo_5: ; preds = %_llgo_0 // CHECK-NEXT: store ptr blockaddress(@"main.init#3", %_llgo_3), ptr %9, align 8 -// CHECK-NEXT: %18 = load ptr, ptr %8, align 8 -// CHECK-NEXT: indirectbr ptr %18, [label %_llgo_3, label %_llgo_2] +// CHECK-NEXT: %19 = load ptr, ptr %8, align 8 +// CHECK-NEXT: indirectbr ptr %19, [label %_llgo_3, label %_llgo_2] // CHECK-EMPTY: // CHECK-NEXT: _llgo_6: ; preds = %_llgo_2 // CHECK-NEXT: ret void @@ -179,9 +181,11 @@ func init() { // CHECK-LABEL: define void @"main.init#3$1"(){{.*}} { // CHECK-NEXT: _llgo_0: -// CHECK-NEXT: %0 = call %"{{.*}}/runtime/internal/runtime.eface" @"{{.*}}/runtime/internal/runtime.Recover"() -// CHECK-NEXT: %1 = call i1 @"{{.*}}/runtime/internal/runtime.EfaceEqual"(%"{{.*}}/runtime/internal/runtime.eface" %0, %"{{.*}}/runtime/internal/runtime.eface" zeroinitializer) -// CHECK-NEXT: br i1 %1, label %_llgo_1, label %_llgo_2 +// CHECK-NEXT: %0 = alloca i8, align 1 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.BindRecoverFrame"(ptr @"main.init#3$1", ptr %0) +// CHECK-NEXT: %1 = call %"{{.*}}/runtime/internal/runtime.eface" @"{{.*}}/runtime/internal/runtime.Recover"(ptr %0) +// CHECK-NEXT: %2 = call i1 @"{{.*}}/runtime/internal/runtime.EfaceEqual"(%"{{.*}}/runtime/internal/runtime.eface" %1, %"{{.*}}/runtime/internal/runtime.eface" zeroinitializer) +// CHECK-NEXT: br i1 %2, label %_llgo_1, label %_llgo_2 // CHECK-EMPTY: // CHECK-NEXT: _llgo_1: ; preds = %_llgo_0 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintString"(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 10 }) @@ -195,7 +199,7 @@ func init() { // CHECK-LABEL: define void @"main.init#4"(){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %0 = call ptr @"{{.*}}/runtime/internal/runtime.GetThreadDefer"() -// CHECK-NEXT: %1 = alloca i8 +// CHECK-NEXT: %1 = alloca i8, i64 {{.*}}, align 1 // CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 48) // CHECK-NEXT: %3 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, i32 0, i32 0 // CHECK-NEXT: store ptr %1, ptr %3, align 8 @@ -221,26 +225,28 @@ func init() { // CHECK-NEXT: _llgo_2: ; preds = %_llgo_5, %_llgo_4 // CHECK-NEXT: store ptr blockaddress(@"main.init#4", %_llgo_3), ptr %8, align 8 // CHECK-NEXT: %13 = load i64, ptr %7, align 8 +// CHECK-NEXT: %14 = call ptr @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr @"main.init#4$1") // CHECK-NEXT: call void @"main.init#4$1"() -// CHECK-NEXT: %14 = load %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, align 8 -// CHECK-NEXT: %15 = extractvalue %"{{.*}}/runtime/internal/runtime.Defer" %14, 2 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.SetThreadDefer"(ptr %15) -// CHECK-NEXT: %16 = load ptr, ptr %9, align 8 -// CHECK-NEXT: indirectbr ptr %16, [label %_llgo_3, label %_llgo_6] +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %14) +// CHECK-NEXT: %15 = load %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, align 8 +// CHECK-NEXT: %16 = extractvalue %"{{.*}}/runtime/internal/runtime.Defer" %15, 2 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.SetThreadDefer"(ptr %16) +// CHECK-NEXT: %17 = load ptr, ptr %9, align 8 +// CHECK-NEXT: indirectbr ptr %17, [label %_llgo_3, label %_llgo_6] // CHECK-EMPTY: // CHECK-NEXT: _llgo_3: ; preds = %_llgo_5, %_llgo_2 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Rethrow"(ptr %0) // CHECK-NEXT: br label %_llgo_1 // CHECK-EMPTY: // CHECK-NEXT: _llgo_4: ; preds = %_llgo_0 -// CHECK-NEXT: %17 = call %"{{.*}}/runtime/internal/runtime.Slice" @"{{.*}}/runtime/internal/runtime.MakeSlice"(i64 2, i64 1, i64 8) +// CHECK-NEXT: %18 = call %"{{.*}}/runtime/internal/runtime.Slice" @"{{.*}}/runtime/internal/runtime.MakeSlice"(i64 2, i64 1, i64 8) // CHECK-NEXT: store ptr blockaddress(@"main.init#4", %_llgo_6), ptr %9, align 8 // CHECK-NEXT: br label %_llgo_2 // CHECK-EMPTY: // CHECK-NEXT: _llgo_5: ; preds = %_llgo_0 // CHECK-NEXT: store ptr blockaddress(@"main.init#4", %_llgo_3), ptr %9, align 8 -// CHECK-NEXT: %18 = load ptr, ptr %8, align 8 -// CHECK-NEXT: indirectbr ptr %18, [label %_llgo_3, label %_llgo_2] +// CHECK-NEXT: %19 = load ptr, ptr %8, align 8 +// CHECK-NEXT: indirectbr ptr %19, [label %_llgo_3, label %_llgo_2] // CHECK-EMPTY: // CHECK-NEXT: _llgo_6: ; preds = %_llgo_2 // CHECK-NEXT: ret void @@ -248,9 +254,11 @@ func init() { // CHECK-LABEL: define void @"main.init#4$1"(){{.*}} { // CHECK-NEXT: _llgo_0: -// CHECK-NEXT: %0 = call %"{{.*}}/runtime/internal/runtime.eface" @"{{.*}}/runtime/internal/runtime.Recover"() -// CHECK-NEXT: %1 = call i1 @"{{.*}}/runtime/internal/runtime.EfaceEqual"(%"{{.*}}/runtime/internal/runtime.eface" %0, %"{{.*}}/runtime/internal/runtime.eface" zeroinitializer) -// CHECK-NEXT: br i1 %1, label %_llgo_1, label %_llgo_2 +// CHECK-NEXT: %0 = alloca i8, align 1 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.BindRecoverFrame"(ptr @"main.init#4$1", ptr %0) +// CHECK-NEXT: %1 = call %"{{.*}}/runtime/internal/runtime.eface" @"{{.*}}/runtime/internal/runtime.Recover"(ptr %0) +// CHECK-NEXT: %2 = call i1 @"{{.*}}/runtime/internal/runtime.EfaceEqual"(%"{{.*}}/runtime/internal/runtime.eface" %1, %"{{.*}}/runtime/internal/runtime.eface" zeroinitializer) +// CHECK-NEXT: br i1 %2, label %_llgo_1, label %_llgo_2 // CHECK-EMPTY: // CHECK-NEXT: _llgo_1: ; preds = %_llgo_0 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintString"(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 10 }) @@ -264,7 +272,7 @@ func init() { // CHECK-LABEL: define void @"main.init#5"(){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %0 = call ptr @"{{.*}}/runtime/internal/runtime.GetThreadDefer"() -// CHECK-NEXT: %1 = alloca i8 +// CHECK-NEXT: %1 = alloca i8, i64 {{.*}}, align 1 // CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 48) // CHECK-NEXT: %3 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, i32 0, i32 0 // CHECK-NEXT: store ptr %1, ptr %3, align 8 @@ -290,26 +298,28 @@ func init() { // CHECK-NEXT: _llgo_2: ; preds = %_llgo_5, %_llgo_4 // CHECK-NEXT: store ptr blockaddress(@"main.init#5", %_llgo_3), ptr %8, align 8 // CHECK-NEXT: %13 = load i64, ptr %7, align 8 +// CHECK-NEXT: %14 = call ptr @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr @"main.init#5$1") // CHECK-NEXT: call void @"main.init#5$1"() -// CHECK-NEXT: %14 = load %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, align 8 -// CHECK-NEXT: %15 = extractvalue %"{{.*}}/runtime/internal/runtime.Defer" %14, 2 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.SetThreadDefer"(ptr %15) -// CHECK-NEXT: %16 = load ptr, ptr %9, align 8 -// CHECK-NEXT: indirectbr ptr %16, [label %_llgo_3, label %_llgo_6] +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %14) +// CHECK-NEXT: %15 = load %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, align 8 +// CHECK-NEXT: %16 = extractvalue %"{{.*}}/runtime/internal/runtime.Defer" %15, 2 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.SetThreadDefer"(ptr %16) +// CHECK-NEXT: %17 = load ptr, ptr %9, align 8 +// CHECK-NEXT: indirectbr ptr %17, [label %_llgo_3, label %_llgo_6] // CHECK-EMPTY: // CHECK-NEXT: _llgo_3: ; preds = %_llgo_5, %_llgo_2 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Rethrow"(ptr %0) // CHECK-NEXT: br label %_llgo_1 // CHECK-EMPTY: // CHECK-NEXT: _llgo_4: ; preds = %_llgo_0 -// CHECK-NEXT: %17 = call %"{{.*}}/runtime/internal/runtime.Slice" @"{{.*}}/runtime/internal/runtime.MakeSlice"(i64 9223372036854775807, i64 9223372036854775807, i64 8) +// CHECK-NEXT: %18 = call %"{{.*}}/runtime/internal/runtime.Slice" @"{{.*}}/runtime/internal/runtime.MakeSlice"(i64 9223372036854775807, i64 9223372036854775807, i64 8) // CHECK-NEXT: store ptr blockaddress(@"main.init#5", %_llgo_6), ptr %9, align 8 // CHECK-NEXT: br label %_llgo_2 // CHECK-EMPTY: // CHECK-NEXT: _llgo_5: ; preds = %_llgo_0 // CHECK-NEXT: store ptr blockaddress(@"main.init#5", %_llgo_3), ptr %9, align 8 -// CHECK-NEXT: %18 = load ptr, ptr %8, align 8 -// CHECK-NEXT: indirectbr ptr %18, [label %_llgo_3, label %_llgo_2] +// CHECK-NEXT: %19 = load ptr, ptr %8, align 8 +// CHECK-NEXT: indirectbr ptr %19, [label %_llgo_3, label %_llgo_2] // CHECK-EMPTY: // CHECK-NEXT: _llgo_6: ; preds = %_llgo_2 // CHECK-NEXT: ret void @@ -317,9 +327,11 @@ func init() { // CHECK-LABEL: define void @"main.init#5$1"(){{.*}} { // CHECK-NEXT: _llgo_0: -// CHECK-NEXT: %0 = call %"{{.*}}/runtime/internal/runtime.eface" @"{{.*}}/runtime/internal/runtime.Recover"() -// CHECK-NEXT: %1 = call i1 @"{{.*}}/runtime/internal/runtime.EfaceEqual"(%"{{.*}}/runtime/internal/runtime.eface" %0, %"{{.*}}/runtime/internal/runtime.eface" zeroinitializer) -// CHECK-NEXT: br i1 %1, label %_llgo_1, label %_llgo_2 +// CHECK-NEXT: %0 = alloca i8, align 1 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.BindRecoverFrame"(ptr @"main.init#5$1", ptr %0) +// CHECK-NEXT: %1 = call %"{{.*}}/runtime/internal/runtime.eface" @"{{.*}}/runtime/internal/runtime.Recover"(ptr %0) +// CHECK-NEXT: %2 = call i1 @"{{.*}}/runtime/internal/runtime.EfaceEqual"(%"{{.*}}/runtime/internal/runtime.eface" %1, %"{{.*}}/runtime/internal/runtime.eface" zeroinitializer) +// CHECK-NEXT: br i1 %2, label %_llgo_1, label %_llgo_2 // CHECK-EMPTY: // CHECK-NEXT: _llgo_1: ; preds = %_llgo_0 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintString"(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 10 }) diff --git a/cl/_testgo/reader/in.go b/cl/_testgo/reader/in.go index 2fd463b8a6..79e7b6a5a3 100644 --- a/cl/_testgo/reader/in.go +++ b/cl/_testgo/reader/in.go @@ -5,21 +5,21 @@ import ( "unicode/utf8" ) -// CHECK: @2 = private unnamed_addr constant [7 x i8] c"WriteTo", align 1 -// CHECK: @17 = private unnamed_addr constant [5 x i8] c"Close", align 1 -// CHECK: @28 = private unnamed_addr constant [3 x i8] c"EOF", align 1 -// CHECK: @29 = private unnamed_addr constant [11 x i8] c"short write", align 1 -// CHECK: @30 = private unnamed_addr constant [11 x i8] c"hello world", align 1 -// CHECK: @53 = private unnamed_addr constant [50 x i8] c"{{.*}}/cl/_testgo/reader.nopCloser", align 1 -// CHECK: @54 = private unnamed_addr constant [49 x i8] c"{{.*}}/cl/_testgo/reader.WriterTo", align 1 -// CHECK: @55 = private unnamed_addr constant [58 x i8] c"{{.*}}/cl/_testgo/reader.nopCloserWriterTo", align 1 -// CHECK: @56 = private unnamed_addr constant [37 x i8] c"stringsReader.ReadAt: negative offset", align 1 -// CHECK: @57 = private unnamed_addr constant [34 x i8] c"stringsReader.Seek: invalid whence", align 1 -// CHECK: @58 = private unnamed_addr constant [37 x i8] c"stringsReader.Seek: negative position", align 1 -// CHECK: @59 = private unnamed_addr constant [48 x i8] c"stringsReader.UnreadByte: at beginning of string", align 1 -// CHECK: @60 = private unnamed_addr constant [49 x i8] c"strings.Reader.UnreadRune: at beginning of string", align 1 -// CHECK: @61 = private unnamed_addr constant [62 x i8] c"strings.Reader.UnreadRune: previous operation was not ReadRune", align 1 -// CHECK: @62 = private unnamed_addr constant [48 x i8] c"stringsReader.WriteTo: invalid WriteString count", align 1 +// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [7 x i8] c"WriteTo", align 1{{$}} +// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [5 x i8] c"Close", align 1{{$}} +// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [3 x i8] c"EOF", align 1{{$}} +// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [11 x i8] c"short write", align 1{{$}} +// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [11 x i8] c"hello world", align 1{{$}} +// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [50 x i8] c"{{.*}}/cl/_testgo/reader.nopCloser", align 1{{$}} +// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [49 x i8] c"{{.*}}/cl/_testgo/reader.WriterTo", align 1{{$}} +// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [58 x i8] c"{{.*}}/cl/_testgo/reader.nopCloserWriterTo", align 1{{$}} +// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [37 x i8] c"stringsReader.ReadAt: negative offset", align 1{{$}} +// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [34 x i8] c"stringsReader.Seek: invalid whence", align 1{{$}} +// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [37 x i8] c"stringsReader.Seek: negative position", align 1{{$}} +// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [48 x i8] c"stringsReader.UnreadByte: at beginning of string", align 1{{$}} +// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [49 x i8] c"strings.Reader.UnreadRune: at beginning of string", align 1{{$}} +// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [62 x i8] c"strings.Reader.UnreadRune: previous operation was not ReadRune", align 1{{$}} +// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [48 x i8] c"stringsReader.WriteTo: invalid WriteString count", align 1{{$}} type Reader interface { Read(p []byte) (n int, err error) @@ -129,6 +129,200 @@ func WriteString(w Writer, s string) (n int, err error) { return w.Write([]byte(s)) } +func NopCloser(r Reader) ReadCloser { + if _, ok := r.(WriterTo); ok { + return nopCloserWriterTo{r} + } + return nopCloser{r} +} + +type nopCloser struct { + Reader +} + +func (nopCloser) Close() error { return nil } + +type nopCloserWriterTo struct { + Reader +} + +func (nopCloserWriterTo) Close() error { return nil } + +func (c nopCloserWriterTo) WriteTo(w Writer) (n int64, err error) { + return c.Reader.(WriterTo).WriteTo(w) +} + +func ReadAll(r Reader) ([]byte, error) { + b := make([]byte, 0, 512) + for { + n, err := r.Read(b[len(b):cap(b)]) + b = b[:len(b)+n] + if err != nil { + if err == EOF { + err = nil + } + return b, err + } + + if len(b) == cap(b) { + // Add more capacity (let append pick how much). + b = append(b, 0)[:len(b)] + } + } +} + +type stringReader struct { + s string + i int64 // current reading index + prevRune int // index of previous rune; or < 0 +} + +func (r *stringReader) Len() int { + if r.i >= int64(len(r.s)) { + return 0 + } + return int(int64(len(r.s)) - r.i) +} + +func (r *stringReader) Size() int64 { return int64(len(r.s)) } + +func (r *stringReader) Read(b []byte) (n int, err error) { + if r.i >= int64(len(r.s)) { + return 0, EOF + } + r.prevRune = -1 + n = copy(b, r.s[r.i:]) + r.i += int64(n) + return +} + +func (r *stringReader) ReadAt(b []byte, off int64) (n int, err error) { + if off < 0 { + return 0, newError("stringsReader.ReadAt: negative offset") + } + if off >= int64(len(r.s)) { + return 0, EOF + } + n = copy(b, r.s[off:]) + if n < len(b) { + err = EOF + } + return +} + +func (r *stringReader) ReadByte() (byte, error) { + r.prevRune = -1 + if r.i >= int64(len(r.s)) { + return 0, EOF + } + b := r.s[r.i] + r.i++ + return b, nil +} + +func (r *stringReader) UnreadByte() error { + if r.i <= 0 { + return newError("stringsReader.UnreadByte: at beginning of string") + } + r.prevRune = -1 + r.i-- + return nil +} + +func (r *stringReader) ReadRune() (ch rune, size int, err error) { + if r.i >= int64(len(r.s)) { + r.prevRune = -1 + return 0, 0, EOF + } + r.prevRune = int(r.i) + if c := r.s[r.i]; c < utf8.RuneSelf { + r.i++ + return rune(c), 1, nil + } + ch, size = utf8.DecodeRuneInString(r.s[r.i:]) + r.i += int64(size) + return +} + +func (r *stringReader) UnreadRune() error { + if r.i <= 0 { + return newError("strings.Reader.UnreadRune: at beginning of string") + } + if r.prevRune < 0 { + return newError("strings.Reader.UnreadRune: previous operation was not ReadRune") + } + r.i = int64(r.prevRune) + r.prevRune = -1 + return nil +} + +const ( + SeekStart = 0 // seek relative to the origin of the file + SeekCurrent = 1 // seek relative to the current offset + SeekEnd = 2 // seek relative to the end +) + +func (r *stringReader) Seek(offset int64, whence int) (int64, error) { + r.prevRune = -1 + var abs int64 + switch whence { + case SeekStart: + abs = offset + case SeekCurrent: + abs = r.i + offset + case SeekEnd: + abs = int64(len(r.s)) + offset + default: + return 0, newError("stringsReader.Seek: invalid whence") + } + if abs < 0 { + return 0, newError("stringsReader.Seek: negative position") + } + r.i = abs + return abs, nil +} + +func (r *stringReader) WriteTo(w Writer) (n int64, err error) { + r.prevRune = -1 + if r.i >= int64(len(r.s)) { + return 0, nil + } + s := r.s[r.i:] + m, err := WriteString(w, s) + if m > len(s) { + panic("stringsReader.WriteTo: invalid WriteString count") + } + r.i += int64(m) + n = int64(m) + if m != len(s) && err == nil { + err = ErrShortWrite + } + return +} + +func newError(text string) error { + return &errorString{text} +} + +type errorString struct { + s string +} + +func (e *errorString) Error() string { + return e.s +} + +var ( + EOF = newError("EOF") + ErrShortWrite = newError("short write") +) + +func main() { + r := &stringReader{s: "hello world"} + data, err := ReadAll(r) + println(string(data), err) +} + // CHECK-LABEL: define %"{{.*}}/runtime/internal/runtime.iface" @main.NopCloser(%"{{.*}}/runtime/internal/runtime.iface" %0){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %1 = call ptr @"{{.*}}/runtime/internal/runtime.IfaceType"(%"{{.*}}/runtime/internal/runtime.iface" %0) @@ -180,29 +374,6 @@ func WriteString(w Writer, s string) (n int, err error) { // CHECK-NEXT: br i1 %25, label %_llgo_1, label %_llgo_2 // CHECK-NEXT: } -func NopCloser(r Reader) ReadCloser { - if _, ok := r.(WriterTo); ok { - return nopCloserWriterTo{r} - } - return nopCloser{r} -} - -type nopCloser struct { - Reader -} - -func (nopCloser) Close() error { return nil } - -type nopCloserWriterTo struct { - Reader -} - -func (nopCloserWriterTo) Close() error { return nil } - -func (c nopCloserWriterTo) WriteTo(w Writer) (n int64, err error) { - return c.Reader.(WriterTo).WriteTo(w) -} - // CHECK-LABEL: define { %"{{.*}}/runtime/internal/runtime.Slice", %"{{.*}}/runtime/internal/runtime.iface" } @main.ReadAll(%"{{.*}}/runtime/internal/runtime.iface" %0){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %1 = call ptr @"{{.*}}/runtime/internal/runtime.AllocZ"(i64 512) @@ -346,162 +517,6 @@ func (c nopCloserWriterTo) WriteTo(w Writer) (n int64, err error) { // CHECK-NEXT: br i1 %39, label %_llgo_1, label %_llgo_2 // CHECK-NEXT: } -func ReadAll(r Reader) ([]byte, error) { - b := make([]byte, 0, 512) - for { - n, err := r.Read(b[len(b):cap(b)]) - b = b[:len(b)+n] - if err != nil { - if err == EOF { - err = nil - } - return b, err - } - - if len(b) == cap(b) { - // Add more capacity (let append pick how much). - b = append(b, 0)[:len(b)] - } - } -} - -type stringReader struct { - s string - i int64 // current reading index - prevRune int // index of previous rune; or < 0 -} - -func (r *stringReader) Len() int { - if r.i >= int64(len(r.s)) { - return 0 - } - return int(int64(len(r.s)) - r.i) -} - -func (r *stringReader) Size() int64 { return int64(len(r.s)) } - -func (r *stringReader) Read(b []byte) (n int, err error) { - if r.i >= int64(len(r.s)) { - return 0, EOF - } - r.prevRune = -1 - n = copy(b, r.s[r.i:]) - r.i += int64(n) - return -} - -func (r *stringReader) ReadAt(b []byte, off int64) (n int, err error) { - if off < 0 { - return 0, newError("stringsReader.ReadAt: negative offset") - } - if off >= int64(len(r.s)) { - return 0, EOF - } - n = copy(b, r.s[off:]) - if n < len(b) { - err = EOF - } - return -} - -func (r *stringReader) ReadByte() (byte, error) { - r.prevRune = -1 - if r.i >= int64(len(r.s)) { - return 0, EOF - } - b := r.s[r.i] - r.i++ - return b, nil -} - -func (r *stringReader) UnreadByte() error { - if r.i <= 0 { - return newError("stringsReader.UnreadByte: at beginning of string") - } - r.prevRune = -1 - r.i-- - return nil -} - -func (r *stringReader) ReadRune() (ch rune, size int, err error) { - if r.i >= int64(len(r.s)) { - r.prevRune = -1 - return 0, 0, EOF - } - r.prevRune = int(r.i) - if c := r.s[r.i]; c < utf8.RuneSelf { - r.i++ - return rune(c), 1, nil - } - ch, size = utf8.DecodeRuneInString(r.s[r.i:]) - r.i += int64(size) - return -} - -func (r *stringReader) UnreadRune() error { - if r.i <= 0 { - return newError("strings.Reader.UnreadRune: at beginning of string") - } - if r.prevRune < 0 { - return newError("strings.Reader.UnreadRune: previous operation was not ReadRune") - } - r.i = int64(r.prevRune) - r.prevRune = -1 - return nil -} - -const ( - SeekStart = 0 // seek relative to the origin of the file - SeekCurrent = 1 // seek relative to the current offset - SeekEnd = 2 // seek relative to the end -) - -func (r *stringReader) Seek(offset int64, whence int) (int64, error) { - r.prevRune = -1 - var abs int64 - switch whence { - case SeekStart: - abs = offset - case SeekCurrent: - abs = r.i + offset - case SeekEnd: - abs = int64(len(r.s)) + offset - default: - return 0, newError("stringsReader.Seek: invalid whence") - } - if abs < 0 { - return 0, newError("stringsReader.Seek: negative position") - } - r.i = abs - return abs, nil -} - -func (r *stringReader) WriteTo(w Writer) (n int64, err error) { - r.prevRune = -1 - if r.i >= int64(len(r.s)) { - return 0, nil - } - s := r.s[r.i:] - m, err := WriteString(w, s) - if m > len(s) { - panic("stringsReader.WriteTo: invalid WriteString count") - } - r.i += int64(m) - n = int64(m) - if m != len(s) && err == nil { - err = ErrShortWrite - } - return -} - -func newError(text string) error { - return &errorString{text} -} - -type errorString struct { - s string -} - // CHECK-LABEL: define %"{{.*}}/runtime/internal/runtime.String" @"main.(*errorString).Error"(ptr %0){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %1 = getelementptr inbounds %main.errorString, ptr %0, i32 0, i32 0 @@ -517,9 +532,9 @@ type errorString struct { // CHECK-NEXT: _llgo_1: ; preds = %_llgo_0 // CHECK-NEXT: store i1 true, ptr @"main.init$guard", align 1 // CHECK-NEXT: call void @"unicode/utf8.init"() -// CHECK-NEXT: %1 = call %"{{.*}}/runtime/internal/runtime.iface" @main.newError(%"{{.*}}/runtime/internal/runtime.String" { ptr @28, i64 3 }) +// CHECK-NEXT: %1 = call %"{{.*}}/runtime/internal/runtime.iface" @main.newError(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 3 }) // CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.iface" %1, ptr @main.EOF, align 8 -// CHECK-NEXT: %2 = call %"{{.*}}/runtime/internal/runtime.iface" @main.newError(%"{{.*}}/runtime/internal/runtime.String" { ptr @29, i64 11 }) +// CHECK-NEXT: %2 = call %"{{.*}}/runtime/internal/runtime.iface" @main.newError(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 11 }) // CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.iface" %2, ptr @main.ErrShortWrite, align 8 // CHECK-NEXT: br label %_llgo_2 // CHECK-EMPTY: @@ -527,20 +542,11 @@ type errorString struct { // CHECK-NEXT: ret void // CHECK-NEXT: } -func (e *errorString) Error() string { - return e.s -} - -var ( - EOF = newError("EOF") - ErrShortWrite = newError("short write") -) - // CHECK-LABEL: define void @main.main(){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %0 = call ptr @"{{.*}}/runtime/internal/runtime.AllocZ"(i64 32) // CHECK-NEXT: %1 = getelementptr inbounds %main.stringReader, ptr %0, i32 0, i32 0 -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @30, i64 11 }, ptr %1, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 11 }, ptr %1, align 8 // CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @"*_llgo_main.stringReader") // CHECK-NEXT: %3 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %2, 0 // CHECK-NEXT: %4 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %3, ptr %0, 1 @@ -571,12 +577,6 @@ var ( // CHECK-NEXT: ret %"{{.*}}/runtime/internal/runtime.iface" zeroinitializer // CHECK-NEXT: } -func main() { - r := &stringReader{s: "hello world"} - data, err := ReadAll(r) - println(string(data), err) -} - // CHECK-LABEL: define { i64, %"{{.*}}/runtime/internal/runtime.iface" } @main.nopCloser.Read(%main.nopCloser %0, %"{{.*}}/runtime/internal/runtime.Slice" %1){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %2 = alloca %main.nopCloser, align 8 @@ -590,20 +590,23 @@ func main() { // CHECK-NEXT: %8 = load ptr, ptr %7, align 8 // CHECK-NEXT: %9 = insertvalue { ptr, ptr } undef, ptr %8, 0 // CHECK-NEXT: %10 = insertvalue { ptr, ptr } %9, ptr %5, 1 -// CHECK-NEXT: %11 = extractvalue { ptr, ptr } %10, 1 -// CHECK-NEXT: %12 = extractvalue { ptr, ptr } %10, 0 -// CHECK-NEXT: %13 = call { i64, %"{{.*}}/runtime/internal/runtime.iface" } %12(ptr %11, %"{{.*}}/runtime/internal/runtime.Slice" %1) -// CHECK-NEXT: %14 = extractvalue { i64, %"{{.*}}/runtime/internal/runtime.iface" } %13, 0 -// CHECK-NEXT: %15 = extractvalue { i64, %"{{.*}}/runtime/internal/runtime.iface" } %13, 1 -// CHECK-NEXT: %16 = insertvalue { i64, %"{{.*}}/runtime/internal/runtime.iface" } undef, i64 %14, 0 -// CHECK-NEXT: %17 = insertvalue { i64, %"{{.*}}/runtime/internal/runtime.iface" } %16, %"{{.*}}/runtime/internal/runtime.iface" %15, 1 -// CHECK-NEXT: ret { i64, %"{{.*}}/runtime/internal/runtime.iface" } %17 +// CHECK-NEXT: %11 = extractvalue { ptr, ptr } %10, 0 +// CHECK-NEXT: %12 = call ptr @"{{.*}}/runtime/internal/runtime.StartRecoverFrameAlias"(ptr @main.nopCloser.Read, ptr %11) +// CHECK-NEXT: %13 = extractvalue { ptr, ptr } %10, 1 +// CHECK-NEXT: %14 = extractvalue { ptr, ptr } %10, 0 +// CHECK-NEXT: %15 = call { i64, %"{{.*}}/runtime/internal/runtime.iface" } %14(ptr %13, %"{{.*}}/runtime/internal/runtime.Slice" %1) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %12) +// CHECK-NEXT: %16 = extractvalue { i64, %"{{.*}}/runtime/internal/runtime.iface" } %15, 0 +// CHECK-NEXT: %17 = extractvalue { i64, %"{{.*}}/runtime/internal/runtime.iface" } %15, 1 +// CHECK-NEXT: %18 = insertvalue { i64, %"{{.*}}/runtime/internal/runtime.iface" } undef, i64 %16, 0 +// CHECK-NEXT: %19 = insertvalue { i64, %"{{.*}}/runtime/internal/runtime.iface" } %18, %"{{.*}}/runtime/internal/runtime.iface" %17, 1 +// CHECK-NEXT: ret { i64, %"{{.*}}/runtime/internal/runtime.iface" } %19 // CHECK-NEXT: } // CHECK-LABEL: define %"{{.*}}/runtime/internal/runtime.iface" @"main.(*nopCloser).Close"(ptr %0){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %1 = icmp eq ptr %0, null -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicWrapNilPointer"(i1 %1, %"{{.*}}/runtime/internal/runtime.String" { ptr @53, i64 50 }, %"{{.*}}/runtime/internal/runtime.String" { ptr @17, i64 5 }) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicWrapNilPointer"(i1 %1, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 50 }, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 5 }) // CHECK-NEXT: %2 = load %main.nopCloser, ptr %0, align 8 // CHECK-NEXT: %3 = call %"{{.*}}/runtime/internal/runtime.iface" @main.nopCloser.Close(%main.nopCloser %2) // CHECK-NEXT: ret %"{{.*}}/runtime/internal/runtime.iface" %3 @@ -619,14 +622,17 @@ func main() { // CHECK-NEXT: %7 = load ptr, ptr %6, align 8 // CHECK-NEXT: %8 = insertvalue { ptr, ptr } undef, ptr %7, 0 // CHECK-NEXT: %9 = insertvalue { ptr, ptr } %8, ptr %4, 1 -// CHECK-NEXT: %10 = extractvalue { ptr, ptr } %9, 1 -// CHECK-NEXT: %11 = extractvalue { ptr, ptr } %9, 0 -// CHECK-NEXT: %12 = call { i64, %"{{.*}}/runtime/internal/runtime.iface" } %11(ptr %10, %"{{.*}}/runtime/internal/runtime.Slice" %1) -// CHECK-NEXT: %13 = extractvalue { i64, %"{{.*}}/runtime/internal/runtime.iface" } %12, 0 -// CHECK-NEXT: %14 = extractvalue { i64, %"{{.*}}/runtime/internal/runtime.iface" } %12, 1 -// CHECK-NEXT: %15 = insertvalue { i64, %"{{.*}}/runtime/internal/runtime.iface" } undef, i64 %13, 0 -// CHECK-NEXT: %16 = insertvalue { i64, %"{{.*}}/runtime/internal/runtime.iface" } %15, %"{{.*}}/runtime/internal/runtime.iface" %14, 1 -// CHECK-NEXT: ret { i64, %"{{.*}}/runtime/internal/runtime.iface" } %16 +// CHECK-NEXT: %10 = extractvalue { ptr, ptr } %9, 0 +// CHECK-NEXT: %11 = call ptr @"{{.*}}/runtime/internal/runtime.StartRecoverFrameAlias"(ptr @"main.(*nopCloser).Read", ptr %10) +// CHECK-NEXT: %12 = extractvalue { ptr, ptr } %9, 1 +// CHECK-NEXT: %13 = extractvalue { ptr, ptr } %9, 0 +// CHECK-NEXT: %14 = call { i64, %"{{.*}}/runtime/internal/runtime.iface" } %13(ptr %12, %"{{.*}}/runtime/internal/runtime.Slice" %1) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %11) +// CHECK-NEXT: %15 = extractvalue { i64, %"{{.*}}/runtime/internal/runtime.iface" } %14, 0 +// CHECK-NEXT: %16 = extractvalue { i64, %"{{.*}}/runtime/internal/runtime.iface" } %14, 1 +// CHECK-NEXT: %17 = insertvalue { i64, %"{{.*}}/runtime/internal/runtime.iface" } undef, i64 %15, 0 +// CHECK-NEXT: %18 = insertvalue { i64, %"{{.*}}/runtime/internal/runtime.iface" } %17, %"{{.*}}/runtime/internal/runtime.iface" %16, 1 +// CHECK-NEXT: ret { i64, %"{{.*}}/runtime/internal/runtime.iface" } %18 // CHECK-NEXT: } // CHECK-LABEL: define %"{{.*}}/runtime/internal/runtime.iface" @main.nopCloserWriterTo.Close(%main.nopCloserWriterTo %0){{.*}} { @@ -647,14 +653,17 @@ func main() { // CHECK-NEXT: %8 = load ptr, ptr %7, align 8 // CHECK-NEXT: %9 = insertvalue { ptr, ptr } undef, ptr %8, 0 // CHECK-NEXT: %10 = insertvalue { ptr, ptr } %9, ptr %5, 1 -// CHECK-NEXT: %11 = extractvalue { ptr, ptr } %10, 1 -// CHECK-NEXT: %12 = extractvalue { ptr, ptr } %10, 0 -// CHECK-NEXT: %13 = call { i64, %"{{.*}}/runtime/internal/runtime.iface" } %12(ptr %11, %"{{.*}}/runtime/internal/runtime.Slice" %1) -// CHECK-NEXT: %14 = extractvalue { i64, %"{{.*}}/runtime/internal/runtime.iface" } %13, 0 -// CHECK-NEXT: %15 = extractvalue { i64, %"{{.*}}/runtime/internal/runtime.iface" } %13, 1 -// CHECK-NEXT: %16 = insertvalue { i64, %"{{.*}}/runtime/internal/runtime.iface" } undef, i64 %14, 0 -// CHECK-NEXT: %17 = insertvalue { i64, %"{{.*}}/runtime/internal/runtime.iface" } %16, %"{{.*}}/runtime/internal/runtime.iface" %15, 1 -// CHECK-NEXT: ret { i64, %"{{.*}}/runtime/internal/runtime.iface" } %17 +// CHECK-NEXT: %11 = extractvalue { ptr, ptr } %10, 0 +// CHECK-NEXT: %12 = call ptr @"{{.*}}/runtime/internal/runtime.StartRecoverFrameAlias"(ptr @main.nopCloserWriterTo.Read, ptr %11) +// CHECK-NEXT: %13 = extractvalue { ptr, ptr } %10, 1 +// CHECK-NEXT: %14 = extractvalue { ptr, ptr } %10, 0 +// CHECK-NEXT: %15 = call { i64, %"{{.*}}/runtime/internal/runtime.iface" } %14(ptr %13, %"{{.*}}/runtime/internal/runtime.Slice" %1) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %12) +// CHECK-NEXT: %16 = extractvalue { i64, %"{{.*}}/runtime/internal/runtime.iface" } %15, 0 +// CHECK-NEXT: %17 = extractvalue { i64, %"{{.*}}/runtime/internal/runtime.iface" } %15, 1 +// CHECK-NEXT: %18 = insertvalue { i64, %"{{.*}}/runtime/internal/runtime.iface" } undef, i64 %16, 0 +// CHECK-NEXT: %19 = insertvalue { i64, %"{{.*}}/runtime/internal/runtime.iface" } %18, %"{{.*}}/runtime/internal/runtime.iface" %17, 1 +// CHECK-NEXT: ret { i64, %"{{.*}}/runtime/internal/runtime.iface" } %19 // CHECK-NEXT: } // CHECK-LABEL: define { i64, %"{{.*}}/runtime/internal/runtime.iface" } @main.nopCloserWriterTo.WriteTo(%main.nopCloserWriterTo %0, %"{{.*}}/runtime/internal/runtime.iface" %1){{.*}} { @@ -689,14 +698,14 @@ func main() { // CHECK-NEXT: ret { i64, %"{{.*}}/runtime/internal/runtime.iface" } %23 // CHECK-EMPTY: // CHECK-NEXT: _llgo_2: ; preds = %_llgo_0 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr %5, %"{{.*}}/runtime/internal/runtime.String" { ptr @54, i64 49 }, %"{{.*}}/runtime/internal/runtime.String" { ptr @2, i64 7 }) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr %5, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 49 }, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 7 }) // CHECK-NEXT: unreachable // CHECK-NEXT: } // CHECK-LABEL: define %"{{.*}}/runtime/internal/runtime.iface" @"main.(*nopCloserWriterTo).Close"(ptr %0){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %1 = icmp eq ptr %0, null -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicWrapNilPointer"(i1 %1, %"{{.*}}/runtime/internal/runtime.String" { ptr @55, i64 58 }, %"{{.*}}/runtime/internal/runtime.String" { ptr @17, i64 5 }) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicWrapNilPointer"(i1 %1, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 58 }, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 5 }) // CHECK-NEXT: %2 = load %main.nopCloserWriterTo, ptr %0, align 8 // CHECK-NEXT: %3 = call %"{{.*}}/runtime/internal/runtime.iface" @main.nopCloserWriterTo.Close(%main.nopCloserWriterTo %2) // CHECK-NEXT: ret %"{{.*}}/runtime/internal/runtime.iface" %3 @@ -712,20 +721,23 @@ func main() { // CHECK-NEXT: %7 = load ptr, ptr %6, align 8 // CHECK-NEXT: %8 = insertvalue { ptr, ptr } undef, ptr %7, 0 // CHECK-NEXT: %9 = insertvalue { ptr, ptr } %8, ptr %4, 1 -// CHECK-NEXT: %10 = extractvalue { ptr, ptr } %9, 1 -// CHECK-NEXT: %11 = extractvalue { ptr, ptr } %9, 0 -// CHECK-NEXT: %12 = call { i64, %"{{.*}}/runtime/internal/runtime.iface" } %11(ptr %10, %"{{.*}}/runtime/internal/runtime.Slice" %1) -// CHECK-NEXT: %13 = extractvalue { i64, %"{{.*}}/runtime/internal/runtime.iface" } %12, 0 -// CHECK-NEXT: %14 = extractvalue { i64, %"{{.*}}/runtime/internal/runtime.iface" } %12, 1 -// CHECK-NEXT: %15 = insertvalue { i64, %"{{.*}}/runtime/internal/runtime.iface" } undef, i64 %13, 0 -// CHECK-NEXT: %16 = insertvalue { i64, %"{{.*}}/runtime/internal/runtime.iface" } %15, %"{{.*}}/runtime/internal/runtime.iface" %14, 1 -// CHECK-NEXT: ret { i64, %"{{.*}}/runtime/internal/runtime.iface" } %16 +// CHECK-NEXT: %10 = extractvalue { ptr, ptr } %9, 0 +// CHECK-NEXT: %11 = call ptr @"{{.*}}/runtime/internal/runtime.StartRecoverFrameAlias"(ptr @"main.(*nopCloserWriterTo).Read", ptr %10) +// CHECK-NEXT: %12 = extractvalue { ptr, ptr } %9, 1 +// CHECK-NEXT: %13 = extractvalue { ptr, ptr } %9, 0 +// CHECK-NEXT: %14 = call { i64, %"{{.*}}/runtime/internal/runtime.iface" } %13(ptr %12, %"{{.*}}/runtime/internal/runtime.Slice" %1) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %11) +// CHECK-NEXT: %15 = extractvalue { i64, %"{{.*}}/runtime/internal/runtime.iface" } %14, 0 +// CHECK-NEXT: %16 = extractvalue { i64, %"{{.*}}/runtime/internal/runtime.iface" } %14, 1 +// CHECK-NEXT: %17 = insertvalue { i64, %"{{.*}}/runtime/internal/runtime.iface" } undef, i64 %15, 0 +// CHECK-NEXT: %18 = insertvalue { i64, %"{{.*}}/runtime/internal/runtime.iface" } %17, %"{{.*}}/runtime/internal/runtime.iface" %16, 1 +// CHECK-NEXT: ret { i64, %"{{.*}}/runtime/internal/runtime.iface" } %18 // CHECK-NEXT: } // CHECK-LABEL: define { i64, %"{{.*}}/runtime/internal/runtime.iface" } @"main.(*nopCloserWriterTo).WriteTo"(ptr %0, %"{{.*}}/runtime/internal/runtime.iface" %1){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %2 = icmp eq ptr %0, null -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicWrapNilPointer"(i1 %2, %"{{.*}}/runtime/internal/runtime.String" { ptr @55, i64 58 }, %"{{.*}}/runtime/internal/runtime.String" { ptr @2, i64 7 }) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicWrapNilPointer"(i1 %2, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 58 }, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 7 }) // CHECK-NEXT: %3 = load %main.nopCloserWriterTo, ptr %0, align 8 // CHECK-NEXT: %4 = call { i64, %"{{.*}}/runtime/internal/runtime.iface" } @main.nopCloserWriterTo.WriteTo(%main.nopCloserWriterTo %3, %"{{.*}}/runtime/internal/runtime.iface" %1) // CHECK-NEXT: %5 = extractvalue { i64, %"{{.*}}/runtime/internal/runtime.iface" } %4, 0 @@ -801,7 +813,7 @@ func main() { // CHECK-NEXT: br i1 %3, label %_llgo_1, label %_llgo_2 // CHECK-EMPTY: // CHECK-NEXT: _llgo_1: ; preds = %_llgo_0 -// CHECK-NEXT: %4 = call %"{{.*}}/runtime/internal/runtime.iface" @main.newError(%"{{.*}}/runtime/internal/runtime.String" { ptr @56, i64 37 }) +// CHECK-NEXT: %4 = call %"{{.*}}/runtime/internal/runtime.iface" @main.newError(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 37 }) // CHECK-NEXT: %5 = insertvalue { i64, %"{{.*}}/runtime/internal/runtime.iface" } { i64 0, %"{{.*}}/runtime/internal/runtime.iface" undef }, %"{{.*}}/runtime/internal/runtime.iface" %4, 1 // CHECK-NEXT: ret { i64, %"{{.*}}/runtime/internal/runtime.iface" } %5 // CHECK-EMPTY: @@ -987,12 +999,12 @@ func main() { // CHECK-NEXT: br i1 %15, label %_llgo_5, label %_llgo_7 // CHECK-EMPTY: // CHECK-NEXT: _llgo_7: ; preds = %_llgo_6 -// CHECK-NEXT: %16 = call %"{{.*}}/runtime/internal/runtime.iface" @main.newError(%"{{.*}}/runtime/internal/runtime.String" { ptr @57, i64 34 }) +// CHECK-NEXT: %16 = call %"{{.*}}/runtime/internal/runtime.iface" @main.newError(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 34 }) // CHECK-NEXT: %17 = insertvalue { i64, %"{{.*}}/runtime/internal/runtime.iface" } { i64 0, %"{{.*}}/runtime/internal/runtime.iface" undef }, %"{{.*}}/runtime/internal/runtime.iface" %16, 1 // CHECK-NEXT: ret { i64, %"{{.*}}/runtime/internal/runtime.iface" } %17 // CHECK-EMPTY: // CHECK-NEXT: _llgo_8: ; preds = %_llgo_1 -// CHECK-NEXT: %18 = call %"{{.*}}/runtime/internal/runtime.iface" @main.newError(%"{{.*}}/runtime/internal/runtime.String" { ptr @58, i64 37 }) +// CHECK-NEXT: %18 = call %"{{.*}}/runtime/internal/runtime.iface" @main.newError(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 37 }) // CHECK-NEXT: %19 = insertvalue { i64, %"{{.*}}/runtime/internal/runtime.iface" } { i64 0, %"{{.*}}/runtime/internal/runtime.iface" undef }, %"{{.*}}/runtime/internal/runtime.iface" %18, 1 // CHECK-NEXT: ret { i64, %"{{.*}}/runtime/internal/runtime.iface" } %19 // CHECK-EMPTY: @@ -1020,7 +1032,7 @@ func main() { // CHECK-NEXT: br i1 %3, label %_llgo_1, label %_llgo_2 // CHECK-EMPTY: // CHECK-NEXT: _llgo_1: ; preds = %_llgo_0 -// CHECK-NEXT: %4 = call %"{{.*}}/runtime/internal/runtime.iface" @main.newError(%"{{.*}}/runtime/internal/runtime.String" { ptr @59, i64 48 }) +// CHECK-NEXT: %4 = call %"{{.*}}/runtime/internal/runtime.iface" @main.newError(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 48 }) // CHECK-NEXT: ret %"{{.*}}/runtime/internal/runtime.iface" %4 // CHECK-EMPTY: // CHECK-NEXT: _llgo_2: ; preds = %_llgo_0 @@ -1042,7 +1054,7 @@ func main() { // CHECK-NEXT: br i1 %3, label %_llgo_1, label %_llgo_2 // CHECK-EMPTY: // CHECK-NEXT: _llgo_1: ; preds = %_llgo_0 -// CHECK-NEXT: %4 = call %"{{.*}}/runtime/internal/runtime.iface" @main.newError(%"{{.*}}/runtime/internal/runtime.String" { ptr @60, i64 49 }) +// CHECK-NEXT: %4 = call %"{{.*}}/runtime/internal/runtime.iface" @main.newError(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 49 }) // CHECK-NEXT: ret %"{{.*}}/runtime/internal/runtime.iface" %4 // CHECK-EMPTY: // CHECK-NEXT: _llgo_2: ; preds = %_llgo_0 @@ -1052,7 +1064,7 @@ func main() { // CHECK-NEXT: br i1 %7, label %_llgo_3, label %_llgo_4 // CHECK-EMPTY: // CHECK-NEXT: _llgo_3: ; preds = %_llgo_2 -// CHECK-NEXT: %8 = call %"{{.*}}/runtime/internal/runtime.iface" @main.newError(%"{{.*}}/runtime/internal/runtime.String" { ptr @61, i64 62 }) +// CHECK-NEXT: %8 = call %"{{.*}}/runtime/internal/runtime.iface" @main.newError(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 62 }) // CHECK-NEXT: ret %"{{.*}}/runtime/internal/runtime.iface" %8 // CHECK-EMPTY: // CHECK-NEXT: _llgo_4: ; preds = %_llgo_2 @@ -1096,7 +1108,7 @@ func main() { // CHECK-EMPTY: // CHECK-NEXT: _llgo_3: ; preds = %_llgo_2 // CHECK-NEXT: %20 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @62, i64 48 }, ptr %20, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 48 }, ptr %20, align 8 // CHECK-NEXT: %21 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %20, 1 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Panic"(%"{{.*}}/runtime/internal/runtime.eface" %21) // CHECK-NEXT: unreachable diff --git a/cl/_testgo/recoverthenpanic/in.go b/cl/_testgo/recoverthenpanic/in.go index 2e7958cf77..f4fe1c94e9 100644 --- a/cl/_testgo/recoverthenpanic/in.go +++ b/cl/_testgo/recoverthenpanic/in.go @@ -1,124 +1,126 @@ // LITTEST package main -// CHECK: @0 = private unnamed_addr constant [19 x i8] c"will panic in defer", align 1 -// CHECK: @1 = private unnamed_addr constant [3 x i8] c"end", align 1 -// CHECK: @2 = private unnamed_addr constant [13 x i8] c"panic in main", align 1 +// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [19 x i8] c"will panic in defer", align 1{{$}} +// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [3 x i8] c"end", align 1{{$}} +// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [13 x i8] c"panic in main", align 1{{$}} + +func End() { + if recovered := recover(); recovered != nil { + // Record but don't stop the panic. + defer panic(recovered) + println("will panic in defer") + } + println("end") +} + +func main() { + defer End() + panic("panic in main") +} // CHECK-LABEL: define void @main.End(){{.*}} { // CHECK-NEXT: _llgo_0: -// CHECK-NEXT: %0 = call %"{{.*}}/runtime/internal/runtime.eface" @"{{.*}}/runtime/internal/runtime.Recover"(ptr @main.End) -// CHECK-NEXT: %1 = call i1 @"{{.*}}/runtime/internal/runtime.EfaceEqual"(%"{{.*}}/runtime/internal/runtime.eface" %0, %"{{.*}}/runtime/internal/runtime.eface" zeroinitializer) -// CHECK-NEXT: %2 = xor i1 %1, true -// CHECK-NEXT: %3 = call ptr @"{{.*}}/runtime/internal/runtime.GetThreadDefer"() -// CHECK-NEXT: %4 = alloca i8, i64 {{.*}}, align 1 -// CHECK-NEXT: %5 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 48) -// CHECK-NEXT: %6 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %5, i32 0, i32 0 -// CHECK-NEXT: store ptr %4, ptr %6, align 8 -// CHECK-NEXT: %7 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %5, i32 0, i32 1 -// CHECK-NEXT: store i64 0, ptr %7, align 8 -// CHECK-NEXT: %8 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %5, i32 0, i32 2 -// CHECK-NEXT: store ptr %3, ptr %8, align 8 -// CHECK-NEXT: %9 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %5, i32 0, i32 3 -// CHECK-NEXT: store ptr blockaddress(@main.End, %_llgo_5), ptr %9, align 8 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.SetThreadDefer"(ptr %5) -// CHECK-NEXT: %10 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %5, i32 0, i32 1 -// CHECK-NEXT: %11 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %5, i32 0, i32 3 -// CHECK-NEXT: %12 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %5, i32 0, i32 4 -// CHECK-NEXT: %13 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %5, i32 0, i32 5 -// CHECK-NEXT: store ptr null, ptr %13, align 8 -// CHECK-NEXT: %14 = call i32 @{{.*}}sigsetjmp(ptr %4, i32 0) -// CHECK-NEXT: %15 = icmp eq i32 %14, 0 -// CHECK-NEXT: br i1 %15, label %_llgo_4, label %_llgo_7 +// CHECK-NEXT: %0 = alloca i8, align 1 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.BindRecoverFrame"(ptr @main.End, ptr %0) +// CHECK-NEXT: %1 = call %"{{.*}}/runtime/internal/runtime.eface" @"{{.*}}/runtime/internal/runtime.Recover"(ptr %0) +// CHECK-NEXT: %2 = call i1 @"{{.*}}/runtime/internal/runtime.EfaceEqual"(%"{{.*}}/runtime/internal/runtime.eface" %1, %"{{.*}}/runtime/internal/runtime.eface" zeroinitializer) +// CHECK-NEXT: %3 = xor i1 %2, true +// CHECK-NEXT: %4 = call ptr @"{{.*}}/runtime/internal/runtime.GetThreadDefer"() +// CHECK-NEXT: %5 = alloca i8, i64 {{.*}}, align 1 +// CHECK-NEXT: %6 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 48) +// CHECK-NEXT: %7 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %6, i32 0, i32 0 +// CHECK-NEXT: store ptr %5, ptr %7, align 8 +// CHECK-NEXT: %8 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %6, i32 0, i32 1 +// CHECK-NEXT: store i64 0, ptr %8, align 8 +// CHECK-NEXT: %9 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %6, i32 0, i32 2 +// CHECK-NEXT: store ptr %4, ptr %9, align 8 +// CHECK-NEXT: %10 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %6, i32 0, i32 3 +// CHECK-NEXT: store ptr blockaddress(@main.End, %_llgo_5), ptr %10, align 8 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.SetThreadDefer"(ptr %6) +// CHECK-NEXT: %11 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %6, i32 0, i32 1 +// CHECK-NEXT: %12 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %6, i32 0, i32 3 +// CHECK-NEXT: %13 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %6, i32 0, i32 4 +// CHECK-NEXT: %14 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %6, i32 0, i32 5 +// CHECK-NEXT: store ptr null, ptr %14, align 8 +// CHECK-NEXT: %15 = call i32 @{{(__)?}}sigsetjmp(ptr %5, i32 0) +// CHECK-NEXT: %16 = icmp eq i32 %15, 0 +// CHECK-NEXT: br i1 %16, label %_llgo_4, label %_llgo_7 // CHECK-EMPTY: // CHECK-NEXT: _llgo_1: ; preds = %_llgo_4 -// CHECK-NEXT: %16 = load i64, ptr %10, align 8 -// CHECK-NEXT: %17 = or i64 %16, 1 -// CHECK-NEXT: store i64 %17, ptr %10, align 8 -// CHECK-NEXT: %18 = load ptr, ptr %13, align 8 -// CHECK-NEXT: %19 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 32) -// CHECK-NEXT: %20 = getelementptr inbounds { ptr, i64, %"{{.*}}/runtime/internal/runtime.eface" }, ptr %19, i32 0, i32 0 -// CHECK-NEXT: store ptr %18, ptr %20, align 8 -// CHECK-NEXT: %21 = getelementptr inbounds { ptr, i64, %"{{.*}}/runtime/internal/runtime.eface" }, ptr %19, i32 0, i32 1 -// CHECK-NEXT: store i64 0, ptr %21, align 8 -// CHECK-NEXT: %22 = getelementptr inbounds { ptr, i64, %"{{.*}}/runtime/internal/runtime.eface" }, ptr %19, i32 0, i32 2 -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.eface" %0, ptr %22, align 8 -// CHECK-NEXT: store ptr %19, ptr %13, align 8 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintString"(%"{{.*}}/runtime/internal/runtime.String" { ptr @0, i64 19 }) +// CHECK-NEXT: %17 = load i64, ptr %11, align 8 +// CHECK-NEXT: %18 = or i64 %17, 1 +// CHECK-NEXT: store i64 %18, ptr %11, align 8 +// CHECK-NEXT: %19 = load ptr, ptr %14, align 8 +// CHECK-NEXT: %20 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 32) +// CHECK-NEXT: %21 = getelementptr inbounds { ptr, i64, %"{{.*}}/runtime/internal/runtime.eface" }, ptr %20, i32 0, i32 0 +// CHECK-NEXT: store ptr %19, ptr %21, align 8 +// CHECK-NEXT: %22 = getelementptr inbounds { ptr, i64, %"{{.*}}/runtime/internal/runtime.eface" }, ptr %20, i32 0, i32 1 +// CHECK-NEXT: store i64 0, ptr %22, align 8 +// CHECK-NEXT: %23 = getelementptr inbounds { ptr, i64, %"{{.*}}/runtime/internal/runtime.eface" }, ptr %20, i32 0, i32 2 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.eface" %1, ptr %23, align 8 +// CHECK-NEXT: store ptr %20, ptr %14, align 8 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintString"(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 19 }) // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintByte"(i8 10) // CHECK-NEXT: br label %_llgo_2 // CHECK-EMPTY: // CHECK-NEXT: _llgo_2: ; preds = %_llgo_1, %_llgo_4 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintString"(%"{{.*}}/runtime/internal/runtime.String" { ptr @1, i64 3 }) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintString"(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 3 }) // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintByte"(i8 10) -// CHECK-NEXT: store ptr blockaddress(@main.End, %_llgo_8), ptr %12, align 8 +// CHECK-NEXT: store ptr blockaddress(@main.End, %_llgo_8), ptr %13, align 8 // CHECK-NEXT: br label %_llgo_5 // CHECK-EMPTY: // CHECK-NEXT: _llgo_3: ; preds = %_llgo_6 // CHECK-NEXT: ret void // CHECK-EMPTY: // CHECK-NEXT: _llgo_4: ; preds = %_llgo_0 -// CHECK-NEXT: br i1 %2, label %_llgo_1, label %_llgo_2 +// CHECK-NEXT: br i1 %3, label %_llgo_1, label %_llgo_2 // CHECK-EMPTY: // CHECK-NEXT: _llgo_5: ; preds = %_llgo_7, %_llgo_2 -// CHECK-NEXT: store ptr blockaddress(@main.End, %_llgo_6), ptr %11, align 8 -// CHECK-NEXT: %23 = load i64, ptr %10, align 8 -// CHECK-NEXT: %24 = and i64 %23, 1 -// CHECK-NEXT: %25 = icmp ne i64 %24, 0 -// CHECK-NEXT: br i1 %25, label %_llgo_9, label %_llgo_10 +// CHECK-NEXT: store ptr blockaddress(@main.End, %_llgo_6), ptr %12, align 8 +// CHECK-NEXT: %24 = load i64, ptr %11, align 8 +// CHECK-NEXT: %25 = and i64 %24, 1 +// CHECK-NEXT: %26 = icmp ne i64 %25, 0 +// CHECK-NEXT: br i1 %26, label %_llgo_9, label %_llgo_10 // CHECK-EMPTY: // CHECK-NEXT: _llgo_6: ; preds = %_llgo_7, %_llgo_10 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Rethrow"(ptr %3) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Rethrow"(ptr %4) // CHECK-NEXT: br label %_llgo_3 // CHECK-EMPTY: // CHECK-NEXT: _llgo_7: ; preds = %_llgo_0 -// CHECK-NEXT: store ptr blockaddress(@main.End, %_llgo_6), ptr %12, align 8 -// CHECK-NEXT: %26 = load ptr, ptr %11, align 8 -// CHECK-NEXT: indirectbr ptr %26, [label %_llgo_6, label %_llgo_5] +// CHECK-NEXT: store ptr blockaddress(@main.End, %_llgo_6), ptr %13, align 8 +// CHECK-NEXT: %27 = load ptr, ptr %12, align 8 +// CHECK-NEXT: indirectbr ptr %27, [label %_llgo_6, label %_llgo_5] // CHECK-EMPTY: // CHECK-NEXT: _llgo_8: ; preds = %_llgo_10 // CHECK-NEXT: ret void // CHECK-EMPTY: // CHECK-NEXT: _llgo_9: ; preds = %_llgo_5 -// CHECK-NEXT: %27 = load ptr, ptr %13, align 8 -// CHECK-NEXT: %28 = icmp ne ptr %27, null -// CHECK-NEXT: br i1 %28, label %_llgo_11, label %_llgo_12 +// CHECK-NEXT: %28 = load ptr, ptr %14, align 8 +// CHECK-NEXT: %29 = icmp ne ptr %28, null +// CHECK-NEXT: br i1 %29, label %_llgo_11, label %_llgo_12 // CHECK-EMPTY: // CHECK-NEXT: _llgo_10: ; preds = %_llgo_12, %_llgo_5 -// CHECK-NEXT: %29 = load %"{{.*}}/runtime/internal/runtime.Defer", ptr %5, align 8 -// CHECK-NEXT: %30 = extractvalue %"{{.*}}/runtime/internal/runtime.Defer" %29, 2 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.SetThreadDefer"(ptr %30) -// CHECK-NEXT: %31 = load ptr, ptr %12, align 8 -// CHECK-NEXT: indirectbr ptr %31, [label %_llgo_6, label %_llgo_8] +// CHECK-NEXT: %30 = load %"{{.*}}/runtime/internal/runtime.Defer", ptr %6, align 8 +// CHECK-NEXT: %31 = extractvalue %"{{.*}}/runtime/internal/runtime.Defer" %30, 2 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.SetThreadDefer"(ptr %31) +// CHECK-NEXT: %32 = load ptr, ptr %13, align 8 +// CHECK-NEXT: indirectbr ptr %32, [label %_llgo_6, label %_llgo_8] // CHECK-EMPTY: // CHECK-NEXT: _llgo_11: ; preds = %_llgo_9 -// CHECK-NEXT: %32 = load ptr, ptr %13, align 8 -// CHECK-NEXT: %33 = load { ptr, i64, %"{{.*}}/runtime/internal/runtime.eface" }, ptr %32, align 8 -// CHECK-NEXT: %34 = extractvalue { ptr, i64, %"{{.*}}/runtime/internal/runtime.eface" } %33, 0 -// CHECK-NEXT: store ptr %34, ptr %13, align 8 -// CHECK-NEXT: %35 = extractvalue { ptr, i64, %"{{.*}}/runtime/internal/runtime.eface" } %33, 2 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.FreeDeferNode"(ptr %32) -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Panic"(%"{{.*}}/runtime/internal/runtime.eface" %35) +// CHECK-NEXT: %33 = load ptr, ptr %14, align 8 +// CHECK-NEXT: %34 = load { ptr, i64, %"{{.*}}/runtime/internal/runtime.eface" }, ptr %33, align 8 +// CHECK-NEXT: %35 = extractvalue { ptr, i64, %"{{.*}}/runtime/internal/runtime.eface" } %34, 0 +// CHECK-NEXT: store ptr %35, ptr %14, align 8 +// CHECK-NEXT: %36 = extractvalue { ptr, i64, %"{{.*}}/runtime/internal/runtime.eface" } %34, 2 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.FreeDeferNode"(ptr %33) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Panic"(%"{{.*}}/runtime/internal/runtime.eface" %36) // CHECK-NEXT: unreachable // CHECK-EMPTY: // CHECK-NEXT: _llgo_12: ; preds = %_llgo_9 // CHECK-NEXT: br label %_llgo_10 // CHECK-NEXT: } -func End() { - if recovered := recover(); recovered != nil { - // Record but don't stop the panic. - defer panic(recovered) - println("will panic in defer") - } - println("end") -} - -func main() { - defer End() - panic("panic in main") -} - // CHECK-LABEL: define void @main.init(){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %0 = load i1, ptr @"main.init$guard", align 1 @@ -151,7 +153,7 @@ func main() { // CHECK-NEXT: %9 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, i32 0, i32 4 // CHECK-NEXT: %10 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, i32 0, i32 5 // CHECK-NEXT: store ptr null, ptr %10, align 8 -// CHECK-NEXT: %11 = call i32 @{{.*}}sigsetjmp(ptr %1, i32 0) +// CHECK-NEXT: %11 = call i32 @{{(__)?}}sigsetjmp(ptr %1, i32 0) // CHECK-NEXT: %12 = icmp eq i32 %11, 0 // CHECK-NEXT: br i1 %12, label %_llgo_4, label %_llgo_5 // CHECK-EMPTY: @@ -176,7 +178,7 @@ func main() { // CHECK-EMPTY: // CHECK-NEXT: _llgo_4: ; preds = %_llgo_0 // CHECK-NEXT: %18 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @2, i64 13 }, ptr %18, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 13 }, ptr %18, align 8 // CHECK-NEXT: %19 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %18, 1 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Panic"(%"{{.*}}/runtime/internal/runtime.eface" %19) // CHECK-NEXT: unreachable diff --git a/cl/_testgo/reflectconv/in.go b/cl/_testgo/reflectconv/in.go index c1902c3320..fd98e51395 100644 --- a/cl/_testgo/reflectconv/in.go +++ b/cl/_testgo/reflectconv/in.go @@ -2267,7 +2267,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %346 = call %reflect.Value %__llgo_funcval_code45(ptr {{(nest|swiftself)}} %344, %"{{.*}}/runtime/internal/runtime.eface" %343) // CHECK-NEXT: store %reflect.Value %339, ptr %333, align 8 // CHECK-NEXT: store %reflect.Value %346, ptr %340, align 8 -// CHECK-NEXT: %347 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %1, i64 23 +// CHECK-NEXT: %347 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %1, i64 {{(21|23)}} // CHECK-NEXT: %348 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %347, i32 0, i32 0 // CHECK-NEXT: %349 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %350 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 4) @@ -2435,7 +2435,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %466 = call %reflect.Value %__llgo_funcval_code61(ptr {{(nest|swiftself)}} %464, %"{{.*}}/runtime/internal/runtime.eface" %463) // CHECK-NEXT: store %reflect.Value %459, ptr %453, align 8 // CHECK-NEXT: store %reflect.Value %466, ptr %460, align 8 -// CHECK-NEXT: %467 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %1, i64 31 +// CHECK-NEXT: %467 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %1, i64 {{(28|31)}} // CHECK-NEXT: %468 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %467, i32 0, i32 0 // CHECK-NEXT: %469 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %470 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 1) @@ -9415,7 +9415,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %5471 = call %reflect.Value %__llgo_funcval_code734(ptr {{(nest|swiftself)}} %5469, %"{{.*}}/runtime/internal/runtime.eface" %5468) // CHECK-NEXT: %5472 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %5464, i32 0, i32 1 // CHECK-NEXT: %5473 = call ptr @"{{.*}}/runtime/internal/runtime.AllocZ"(i64 40) -// CHECK-NEXT: %5474 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$uycIKA3bbxRhudEjW1hHKWKdLqHQsCVy8NdW1bkQmNw", ptr @"*_llgo_bytes.Buffer") +// CHECK-NEXT: %5474 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @"*_llgo_bytes.Buffer") // CHECK-NEXT: %5475 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %5474, 0 // CHECK-NEXT: %5476 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %5475, ptr %5473, 1 // CHECK-NEXT: %5477 = call %reflect.Value @main.ReaderV(%"{{.*}}/runtime/internal/runtime.iface" %5476) @@ -9424,13 +9424,13 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %5478 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %1, i64 369 // CHECK-NEXT: %5479 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %5478, i32 0, i32 0 // CHECK-NEXT: %5480 = call ptr @"{{.*}}/runtime/internal/runtime.AllocZ"(i64 40) -// CHECK-NEXT: %5481 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$Zutt7i_AwOTtBOIzyS7ZA5vhcNcbk0kRAoRC98HJDos", ptr @"*_llgo_bytes.Buffer") +// CHECK-NEXT: %5481 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @"*_llgo_bytes.Buffer") // CHECK-NEXT: %5482 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %5481, 0 // CHECK-NEXT: %5483 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %5482, ptr %5480, 1 // CHECK-NEXT: %5484 = call %reflect.Value @main.ReadWriterV(%"{{.*}}/runtime/internal/runtime.iface" %5483) // CHECK-NEXT: %5485 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %5478, i32 0, i32 1 // CHECK-NEXT: %5486 = call ptr @"{{.*}}/runtime/internal/runtime.AllocZ"(i64 40) -// CHECK-NEXT: %5487 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$uycIKA3bbxRhudEjW1hHKWKdLqHQsCVy8NdW1bkQmNw", ptr @"*_llgo_bytes.Buffer") +// CHECK-NEXT: %5487 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @"*_llgo_bytes.Buffer") // CHECK-NEXT: %5488 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %5487, 0 // CHECK-NEXT: %5489 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %5488, ptr %5486, 1 // CHECK-NEXT: %5490 = call %reflect.Value @main.ReaderV(%"{{.*}}/runtime/internal/runtime.iface" %5489) @@ -9447,7 +9447,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %5498 = call %reflect.Value %__llgo_funcval_code735(ptr {{(nest|swiftself)}} %5496, %"{{.*}}/runtime/internal/runtime.eface" %5495) // CHECK-NEXT: %5499 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %5491, i32 0, i32 1 // CHECK-NEXT: %5500 = call ptr @"{{.*}}/runtime/internal/runtime.AllocZ"(i64 40) -// CHECK-NEXT: %5501 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$Zutt7i_AwOTtBOIzyS7ZA5vhcNcbk0kRAoRC98HJDos", ptr @"*_llgo_bytes.Buffer") +// CHECK-NEXT: %5501 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @"*_llgo_bytes.Buffer") // CHECK-NEXT: %5502 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %5501, 0 // CHECK-NEXT: %5503 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %5502, ptr %5500, 1 // CHECK-NEXT: %5504 = call %reflect.Value @main.ReadWriterV(%"{{.*}}/runtime/internal/runtime.iface" %5503) @@ -9481,7 +9481,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: store ptr %2, ptr %4, align 8 // CHECK-NEXT: %5 = insertvalue { ptr, ptr } { ptr @"main.shouldPanic$1", ptr undef }, ptr %3, 1 // CHECK-NEXT: %6 = call ptr @"{{.*}}/runtime/internal/runtime.GetThreadDefer"() -// CHECK-NEXT: %7 = alloca i8 +// CHECK-NEXT: %7 = alloca i8, i64 {{.*}}, align 1 // CHECK-NEXT: %8 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 48) // CHECK-NEXT: %9 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %8, i32 0, i32 0 // CHECK-NEXT: store ptr %7, ptr %9, align 8 @@ -9547,136 +9547,141 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: store ptr %32, ptr %16, align 8 // CHECK-NEXT: %33 = extractvalue { ptr, i64, { ptr, ptr } } %31, 2 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.FreeDeferNode"(ptr %30) -// CHECK-NEXT: %34 = extractvalue { ptr, ptr } %33, 1 -// CHECK-NEXT: %35 = extractvalue { ptr, ptr } %33, 0 -// CHECK-NEXT: %__llgo_funcval_code1 = call ptr asm "", "=r,0"(ptr %35) -// CHECK-NEXT: call void %__llgo_funcval_code1(ptr {{(nest|swiftself)}} %34) +// CHECK-NEXT: %34 = extractvalue { ptr, ptr } %33, 0 +// CHECK-NEXT: %35 = call ptr @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr %34) +// CHECK-NEXT: %36 = extractvalue { ptr, ptr } %33, 1 +// CHECK-NEXT: %37 = extractvalue { ptr, ptr } %33, 0 +// CHECK-NEXT: %__llgo_funcval_code1 = call ptr asm "", "=r,0"(ptr %37) +// CHECK-NEXT: call void %__llgo_funcval_code1(ptr {{(nest|swiftself)}} %36) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %35) // CHECK-NEXT: br label %_llgo_8 // CHECK-EMPTY: // CHECK-NEXT: _llgo_8: ; preds = %_llgo_7, %_llgo_2 -// CHECK-NEXT: %36 = load %"{{.*}}/runtime/internal/runtime.Defer", ptr %8, align 8 -// CHECK-NEXT: %37 = extractvalue %"{{.*}}/runtime/internal/runtime.Defer" %36, 2 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.SetThreadDefer"(ptr %37) -// CHECK-NEXT: %38 = load ptr, ptr %15, align 8 -// CHECK-NEXT: indirectbr ptr %38, [label %_llgo_3, label %_llgo_6] +// CHECK-NEXT: %38 = load %"{{.*}}/runtime/internal/runtime.Defer", ptr %8, align 8 +// CHECK-NEXT: %39 = extractvalue %"{{.*}}/runtime/internal/runtime.Defer" %38, 2 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.SetThreadDefer"(ptr %39) +// CHECK-NEXT: %40 = load ptr, ptr %15, align 8 +// CHECK-NEXT: indirectbr ptr %40, [label %_llgo_3, label %_llgo_6] // CHECK-NEXT: } // CHECK-LABEL: define void @"main.shouldPanic$1"(ptr {{(nest|swiftself)}} %0){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %1 = load { ptr }, ptr %0, align 8 -// CHECK-NEXT: %2 = call %"{{.*}}/runtime/internal/runtime.eface" @"{{.*}}/runtime/internal/runtime.Recover"() -// CHECK-NEXT: %3 = call i1 @"{{.*}}/runtime/internal/runtime.EfaceEqual"(%"{{.*}}/runtime/internal/runtime.eface" %2, %"{{.*}}/runtime/internal/runtime.eface" zeroinitializer) -// CHECK-NEXT: br i1 %3, label %_llgo_1, label %_llgo_2 +// CHECK-NEXT: %2 = alloca i8, align 1 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.BindRecoverFrame"(ptr @"main.shouldPanic$1", ptr %2) +// CHECK-NEXT: %3 = call %"{{.*}}/runtime/internal/runtime.eface" @"{{.*}}/runtime/internal/runtime.Recover"(ptr %2) +// CHECK-NEXT: %4 = call i1 @"{{.*}}/runtime/internal/runtime.EfaceEqual"(%"{{.*}}/runtime/internal/runtime.eface" %3, %"{{.*}}/runtime/internal/runtime.eface" zeroinitializer) +// CHECK-NEXT: br i1 %4, label %_llgo_1, label %_llgo_2 // CHECK-EMPTY: // CHECK-NEXT: _llgo_1: ; preds = %_llgo_0 -// CHECK-NEXT: %4 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 13 }, ptr %4, align 8 -// CHECK-NEXT: %5 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %4, 1 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Panic"(%"{{.*}}/runtime/internal/runtime.eface" %5) +// CHECK-NEXT: %5 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 13 }, ptr %5, align 8 +// CHECK-NEXT: %6 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %5, 1 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Panic"(%"{{.*}}/runtime/internal/runtime.eface" %6) // CHECK-NEXT: unreachable // CHECK-EMPTY: // CHECK-NEXT: _llgo_2: ; preds = %_llgo_0 -// CHECK-NEXT: %6 = extractvalue { ptr } %1, 0 -// CHECK-NEXT: %7 = load %"{{.*}}/runtime/internal/runtime.String", ptr %6, align 8 -// CHECK-NEXT: %8 = call i1 @"{{.*}}/runtime/internal/runtime.StringEqual"(%"{{.*}}/runtime/internal/runtime.String" %7, %"{{.*}}/runtime/internal/runtime.String" zeroinitializer) -// CHECK-NEXT: %9 = xor i1 %8, true -// CHECK-NEXT: br i1 %9, label %_llgo_3, label %_llgo_4 +// CHECK-NEXT: %7 = extractvalue { ptr } %1, 0 +// CHECK-NEXT: %8 = load %"{{.*}}/runtime/internal/runtime.String", ptr %7, align 8 +// CHECK-NEXT: %9 = call i1 @"{{.*}}/runtime/internal/runtime.StringEqual"(%"{{.*}}/runtime/internal/runtime.String" %8, %"{{.*}}/runtime/internal/runtime.String" zeroinitializer) +// CHECK-NEXT: %10 = xor i1 %9, true +// CHECK-NEXT: br i1 %10, label %_llgo_3, label %_llgo_4 // CHECK-EMPTY: // CHECK-NEXT: _llgo_3: ; preds = %_llgo_2 -// CHECK-NEXT: %10 = extractvalue %"{{.*}}/runtime/internal/runtime.eface" %2, 0 -// CHECK-NEXT: %11 = icmp eq ptr %10, @_llgo_string -// CHECK-NEXT: br i1 %11, label %_llgo_13, label %_llgo_14 +// CHECK-NEXT: %11 = extractvalue %"{{.*}}/runtime/internal/runtime.eface" %3, 0 +// CHECK-NEXT: %12 = icmp eq ptr %11, @_llgo_string +// CHECK-NEXT: br i1 %12, label %_llgo_13, label %_llgo_14 // CHECK-EMPTY: // CHECK-NEXT: _llgo_4: ; preds = %_llgo_11, %_llgo_2 // CHECK-NEXT: ret void // CHECK-EMPTY: // CHECK-NEXT: _llgo_5: ; preds = %_llgo_8, %_llgo_6 -// CHECK-NEXT: %12 = phi %"{{.*}}/runtime/internal/runtime.String" [ %43, %_llgo_6 ], [ %16, %_llgo_8 ] -// CHECK-NEXT: %13 = call i1 @strings.HasPrefix(%"{{.*}}/runtime/internal/runtime.String" %12, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 7 }) -// CHECK-NEXT: br i1 %13, label %_llgo_11, label %_llgo_10 +// CHECK-NEXT: %13 = phi %"{{.*}}/runtime/internal/runtime.String" [ %44, %_llgo_6 ], [ %17, %_llgo_8 ] +// CHECK-NEXT: %14 = call i1 @strings.HasPrefix(%"{{.*}}/runtime/internal/runtime.String" %13, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 7 }) +// CHECK-NEXT: br i1 %14, label %_llgo_11, label %_llgo_10 // CHECK-EMPTY: // CHECK-NEXT: _llgo_6: ; preds = %_llgo_15 // CHECK-NEXT: br label %_llgo_5 // CHECK-EMPTY: // CHECK-NEXT: _llgo_7: ; preds = %_llgo_15 -// CHECK-NEXT: %14 = extractvalue %"{{.*}}/runtime/internal/runtime.eface" %2, 0 -// CHECK-NEXT: %15 = icmp eq ptr %14, @"*_llgo_reflect.ValueError" -// CHECK-NEXT: br i1 %15, label %_llgo_16, label %_llgo_17 +// CHECK-NEXT: %15 = extractvalue %"{{.*}}/runtime/internal/runtime.eface" %3, 0 +// CHECK-NEXT: %16 = icmp eq ptr %15, @"*_llgo_reflect.ValueError" +// CHECK-NEXT: br i1 %16, label %_llgo_16, label %_llgo_17 // CHECK-EMPTY: // CHECK-NEXT: _llgo_8: ; preds = %_llgo_18 -// CHECK-NEXT: %16 = call %"{{.*}}/runtime/internal/runtime.String" @"reflect.(*ValueError).Error"(ptr %49) +// CHECK-NEXT: %17 = call %"{{.*}}/runtime/internal/runtime.String" @"reflect.(*ValueError).Error"(ptr %50) // CHECK-NEXT: br label %_llgo_5 // CHECK-EMPTY: // CHECK-NEXT: _llgo_9: ; preds = %_llgo_18 -// CHECK-NEXT: %17 = call ptr @"{{.*}}/runtime/internal/runtime.AllocZ"(i64 16) -// CHECK-NEXT: %18 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.eface", ptr %17, i64 0 -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.eface" %2, ptr %18, align 8 -// CHECK-NEXT: %19 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" undef, ptr %17, 0 -// CHECK-NEXT: %20 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" %19, i64 1, 1 -// CHECK-NEXT: %21 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" %20, i64 1, 2 -// CHECK-NEXT: %22 = call %"{{.*}}/runtime/internal/runtime.String" @fmt.Sprintf(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 32 }, %"{{.*}}/runtime/internal/runtime.Slice" %21) -// CHECK-NEXT: %23 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" %22, ptr %23, align 8 -// CHECK-NEXT: %24 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %23, 1 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Panic"(%"{{.*}}/runtime/internal/runtime.eface" %24) +// CHECK-NEXT: %18 = call ptr @"{{.*}}/runtime/internal/runtime.AllocZ"(i64 16) +// CHECK-NEXT: %19 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.eface", ptr %18, i64 0 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.eface" %3, ptr %19, align 8 +// CHECK-NEXT: %20 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" undef, ptr %18, 0 +// CHECK-NEXT: %21 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" %20, i64 1, 1 +// CHECK-NEXT: %22 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" %21, i64 1, 2 +// CHECK-NEXT: %23 = call %"{{.*}}/runtime/internal/runtime.String" @fmt.Sprintf(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 32 }, %"{{.*}}/runtime/internal/runtime.Slice" %22) +// CHECK-NEXT: %24 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" %23, ptr %24, align 8 +// CHECK-NEXT: %25 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %24, 1 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Panic"(%"{{.*}}/runtime/internal/runtime.eface" %25) // CHECK-NEXT: unreachable // CHECK-EMPTY: // CHECK-NEXT: _llgo_10: ; preds = %_llgo_5 -// CHECK-NEXT: %25 = call %"{{.*}}/runtime/internal/runtime.String" @"{{.*}}/runtime/internal/runtime.StringCat"(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 44 }, %"{{.*}}/runtime/internal/runtime.String" %12) -// CHECK-NEXT: %26 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" %25, ptr %26, align 8 -// CHECK-NEXT: %27 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %26, 1 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Panic"(%"{{.*}}/runtime/internal/runtime.eface" %27) +// CHECK-NEXT: %26 = call %"{{.*}}/runtime/internal/runtime.String" @"{{.*}}/runtime/internal/runtime.StringCat"(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 44 }, %"{{.*}}/runtime/internal/runtime.String" %13) +// CHECK-NEXT: %27 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" %26, ptr %27, align 8 +// CHECK-NEXT: %28 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %27, 1 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Panic"(%"{{.*}}/runtime/internal/runtime.eface" %28) // CHECK-NEXT: unreachable // CHECK-EMPTY: // CHECK-NEXT: _llgo_11: ; preds = %_llgo_5 -// CHECK-NEXT: %28 = extractvalue { ptr } %1, 0 -// CHECK-NEXT: %29 = load %"{{.*}}/runtime/internal/runtime.String", ptr %28, align 8 -// CHECK-NEXT: %30 = call i1 @strings.Contains(%"{{.*}}/runtime/internal/runtime.String" %12, %"{{.*}}/runtime/internal/runtime.String" %29) -// CHECK-NEXT: br i1 %30, label %_llgo_4, label %_llgo_12 +// CHECK-NEXT: %29 = extractvalue { ptr } %1, 0 +// CHECK-NEXT: %30 = load %"{{.*}}/runtime/internal/runtime.String", ptr %29, align 8 +// CHECK-NEXT: %31 = call i1 @strings.Contains(%"{{.*}}/runtime/internal/runtime.String" %13, %"{{.*}}/runtime/internal/runtime.String" %30) +// CHECK-NEXT: br i1 %31, label %_llgo_4, label %_llgo_12 // CHECK-EMPTY: // CHECK-NEXT: _llgo_12: ; preds = %_llgo_11 -// CHECK-NEXT: %31 = extractvalue { ptr } %1, 0 -// CHECK-NEXT: %32 = load %"{{.*}}/runtime/internal/runtime.String", ptr %31, align 8 -// CHECK-NEXT: %33 = call %"{{.*}}/runtime/internal/runtime.String" @"{{.*}}/runtime/internal/runtime.StringCat"(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 31 }, %"{{.*}}/runtime/internal/runtime.String" %32) -// CHECK-NEXT: %34 = call %"{{.*}}/runtime/internal/runtime.String" @"{{.*}}/runtime/internal/runtime.StringCat"(%"{{.*}}/runtime/internal/runtime.String" %33, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 3 }) -// CHECK-NEXT: %35 = call %"{{.*}}/runtime/internal/runtime.String" @"{{.*}}/runtime/internal/runtime.StringCat"(%"{{.*}}/runtime/internal/runtime.String" %34, %"{{.*}}/runtime/internal/runtime.String" %12) -// CHECK-NEXT: %36 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" %35, ptr %36, align 8 -// CHECK-NEXT: %37 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %36, 1 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Panic"(%"{{.*}}/runtime/internal/runtime.eface" %37) +// CHECK-NEXT: %32 = extractvalue { ptr } %1, 0 +// CHECK-NEXT: %33 = load %"{{.*}}/runtime/internal/runtime.String", ptr %32, align 8 +// CHECK-NEXT: %34 = call %"{{.*}}/runtime/internal/runtime.String" @"{{.*}}/runtime/internal/runtime.StringCat"(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 31 }, %"{{.*}}/runtime/internal/runtime.String" %33) +// CHECK-NEXT: %35 = call %"{{.*}}/runtime/internal/runtime.String" @"{{.*}}/runtime/internal/runtime.StringCat"(%"{{.*}}/runtime/internal/runtime.String" %34, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 3 }) +// CHECK-NEXT: %36 = call %"{{.*}}/runtime/internal/runtime.String" @"{{.*}}/runtime/internal/runtime.StringCat"(%"{{.*}}/runtime/internal/runtime.String" %35, %"{{.*}}/runtime/internal/runtime.String" %13) +// CHECK-NEXT: %37 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" %36, ptr %37, align 8 +// CHECK-NEXT: %38 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %37, 1 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Panic"(%"{{.*}}/runtime/internal/runtime.eface" %38) // CHECK-NEXT: unreachable // CHECK-EMPTY: // CHECK-NEXT: _llgo_13: ; preds = %_llgo_3 -// CHECK-NEXT: %38 = extractvalue %"{{.*}}/runtime/internal/runtime.eface" %2, 1 -// CHECK-NEXT: %39 = load %"{{.*}}/runtime/internal/runtime.String", ptr %38, align 8 -// CHECK-NEXT: %40 = insertvalue { %"{{.*}}/runtime/internal/runtime.String", i1 } undef, %"{{.*}}/runtime/internal/runtime.String" %39, 0 -// CHECK-NEXT: %41 = insertvalue { %"{{.*}}/runtime/internal/runtime.String", i1 } %40, i1 true, 1 +// CHECK-NEXT: %39 = extractvalue %"{{.*}}/runtime/internal/runtime.eface" %3, 1 +// CHECK-NEXT: %40 = load %"{{.*}}/runtime/internal/runtime.String", ptr %39, align 8 +// CHECK-NEXT: %41 = insertvalue { %"{{.*}}/runtime/internal/runtime.String", i1 } undef, %"{{.*}}/runtime/internal/runtime.String" %40, 0 +// CHECK-NEXT: %42 = insertvalue { %"{{.*}}/runtime/internal/runtime.String", i1 } %41, i1 true, 1 // CHECK-NEXT: br label %_llgo_15 // CHECK-EMPTY: // CHECK-NEXT: _llgo_14: ; preds = %_llgo_3 // CHECK-NEXT: br label %_llgo_15 // CHECK-EMPTY: // CHECK-NEXT: _llgo_15: ; preds = %_llgo_14, %_llgo_13 -// CHECK-NEXT: %42 = phi { %"{{.*}}/runtime/internal/runtime.String", i1 } [ %41, %_llgo_13 ], [ zeroinitializer, %_llgo_14 ] -// CHECK-NEXT: %43 = extractvalue { %"{{.*}}/runtime/internal/runtime.String", i1 } %42, 0 -// CHECK-NEXT: %44 = extractvalue { %"{{.*}}/runtime/internal/runtime.String", i1 } %42, 1 -// CHECK-NEXT: br i1 %44, label %_llgo_6, label %_llgo_7 +// CHECK-NEXT: %43 = phi { %"{{.*}}/runtime/internal/runtime.String", i1 } [ %42, %_llgo_13 ], [ zeroinitializer, %_llgo_14 ] +// CHECK-NEXT: %44 = extractvalue { %"{{.*}}/runtime/internal/runtime.String", i1 } %43, 0 +// CHECK-NEXT: %45 = extractvalue { %"{{.*}}/runtime/internal/runtime.String", i1 } %43, 1 +// CHECK-NEXT: br i1 %45, label %_llgo_6, label %_llgo_7 // CHECK-EMPTY: // CHECK-NEXT: _llgo_16: ; preds = %_llgo_7 -// CHECK-NEXT: %45 = extractvalue %"{{.*}}/runtime/internal/runtime.eface" %2, 1 -// CHECK-NEXT: %46 = insertvalue { ptr, i1 } undef, ptr %45, 0 -// CHECK-NEXT: %47 = insertvalue { ptr, i1 } %46, i1 true, 1 +// CHECK-NEXT: %46 = extractvalue %"{{.*}}/runtime/internal/runtime.eface" %3, 1 +// CHECK-NEXT: %47 = insertvalue { ptr, i1 } undef, ptr %46, 0 +// CHECK-NEXT: %48 = insertvalue { ptr, i1 } %47, i1 true, 1 // CHECK-NEXT: br label %_llgo_18 // CHECK-EMPTY: // CHECK-NEXT: _llgo_17: ; preds = %_llgo_7 // CHECK-NEXT: br label %_llgo_18 // CHECK-EMPTY: // CHECK-NEXT: _llgo_18: ; preds = %_llgo_17, %_llgo_16 -// CHECK-NEXT: %48 = phi { ptr, i1 } [ %47, %_llgo_16 ], [ zeroinitializer, %_llgo_17 ] -// CHECK-NEXT: %49 = extractvalue { ptr, i1 } %48, 0 -// CHECK-NEXT: %50 = extractvalue { ptr, i1 } %48, 1 -// CHECK-NEXT: br i1 %50, label %_llgo_8, label %_llgo_9 +// CHECK-NEXT: %49 = phi { ptr, i1 } [ %48, %_llgo_16 ], [ zeroinitializer, %_llgo_17 ] +// CHECK-NEXT: %50 = extractvalue { ptr, i1 } %49, 0 +// CHECK-NEXT: %51 = extractvalue { ptr, i1 } %49, 1 +// CHECK-NEXT: br i1 %51, label %_llgo_8, label %_llgo_9 // CHECK-NEXT: } // CHECK-LABEL: define void @"main.(*testingT).Errorf"(ptr %0, %"{{.*}}/runtime/internal/runtime.String" %1, %"{{.*}}/runtime/internal/runtime.Slice" %2){{.*}} { From 1c873fe1218ed6e9f9c7a74068faa5130581e893 Mon Sep 17 00:00:00 2001 From: Li Jie Date: Mon, 10 Aug 2026 11:10:59 +0800 Subject: [PATCH 05/21] runtime: preserve type metadata in assertion panics --- cl/_testdata/vargs/in.go | 5 +- cl/_testgo/abimethod/in.go | 99 ++++-- cl/_testgo/closureall/in.go | 15 +- cl/_testgo/closureenv/in.go | 31 +- cl/_testgo/defer4/in.go | 41 ++- cl/_testgo/genericembediface/in.go | 27 +- cl/_testgo/ifaceprom/in.go | 33 +- cl/_testgo/invoke/in.go | 75 ++-- cl/_testgo/reader/in.go | 71 ++-- cl/_testgo/reflect/in.go | 279 ++++++++------- cl/_testgo/reflectconv/in.go | 365 ++++++++++---------- cl/_testgo/tpinst/main.go | 73 ++-- cl/_testrt/any/in.go | 38 +- cl/_testrt/funcdecl/in.go | 73 ++-- cl/_testrt/makemap/in.go | 197 ++++++----- cl/_testrt/tpabi/in.go | 62 ++-- cl/_testrt/typed/in.go | 33 +- runtime/internal/runtime/errors.go | 37 +- ssa/interface.go | 8 +- test/go/interface_type_assert_panic_test.go | 12 + test/goroot/xfail.yaml | 30 -- 21 files changed, 785 insertions(+), 819 deletions(-) diff --git a/cl/_testdata/vargs/in.go b/cl/_testdata/vargs/in.go index 8a9f6901ee..6ea206b10f 100644 --- a/cl/_testdata/vargs/in.go +++ b/cl/_testdata/vargs/in.go @@ -3,8 +3,7 @@ package main import "github.com/goplus/lib/c" -// CHECK: @0 = private unnamed_addr constant [3 x i8] c"int", align 1 -// CHECK: @1 = private unnamed_addr constant [4 x i8] c"%d\0A\00", align 1 +// CHECK: {{^}}@1 = private unnamed_addr constant [4 x i8] c"%d\0A\00", align 1{{$}} func main() { test(1, 2, 3) @@ -88,6 +87,6 @@ func test(a ...any) { // CHECK-NEXT: br label %_llgo_1 // CHECK-EMPTY: // CHECK-NEXT: _llgo_5: ; preds = %_llgo_2 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr %12, %"{{.*}}/runtime/internal/runtime.String" { ptr @0, i64 3 }, %"{{.*}}/runtime/internal/runtime.String" zeroinitializer) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr null, ptr %12, ptr @_llgo_int, %"{{.*}}/runtime/internal/runtime.String" zeroinitializer) // CHECK-NEXT: unreachable // CHECK-NEXT: } diff --git a/cl/_testgo/abimethod/in.go b/cl/_testgo/abimethod/in.go index 37d16f8c6d..725a53779b 100644 --- a/cl/_testgo/abimethod/in.go +++ b/cl/_testgo/abimethod/in.go @@ -10,10 +10,6 @@ import ( // CHECK: {{^}}@0 = private unnamed_addr constant [45 x i8] c"{{.*}}/cl/_testgo/abimethod.T", align 1{{$}} // CHECK: {{^}}@1 = private unnamed_addr constant [5 x i8] c"Demo1", align 1{{$}} -// CHECK: {{^}}@5 = private unnamed_addr constant [3 x i8] c"int", align 1{{$}} -// CHECK: {{^}}@7 = private unnamed_addr constant [6 x i8] c"main.T", align 1{{$}} -// CHECK-NOT: {{^}}@{{[0-9]+}} = private unnamed_addr constant [5 x i8] c"demo3", align 1{{$}} -// CHECK: {{^}}@11 = private unnamed_addr constant [10 x i8] c"main.demo3", align 1{{$}} // CHECK: {{^}}@13 = private unnamed_addr constant [20 x i8] c"testAnonymous1 error", align 1{{$}} // CHECK: {{^}}@15 = private unnamed_addr constant [20 x i8] c"testAnonymous2 error", align 1{{$}} // CHECK: {{^}}@17 = private unnamed_addr constant [20 x i8] c"testAnonymous3 error", align 1{{$}} @@ -23,26 +19,16 @@ import ( // CHECK: {{^}}@23 = private unnamed_addr constant [20 x i8] c"testAnonymous7 error", align 1{{$}} // CHECK: {{^}}@25 = private unnamed_addr constant [20 x i8] c"testAnonymous8 error", align 1{{$}} // CHECK: {{^}}@26 = private unnamed_addr constant [5 x i8] c"hello", align 1{{$}} -// CHECK: {{^}}@[[ANONBUF_ERR:[0-9]+]] = private unnamed_addr constant [25 x i8] c"testAnonymousBuffer error", align 1{{$}} -// CHECK: {{^}}@[[GENERIC_ERR:[0-9]+]] = private unnamed_addr constant [17 x i8] c"testGeneric error", align 1{{$}} -// CHECK: {{^}}@[[NAMED1_ERR:[0-9]+]] = private unnamed_addr constant [16 x i8] c"testNamed1 error", align 1{{$}} -// CHECK: {{^}}@[[NAMED2_ERR:[0-9]+]] = private unnamed_addr constant [16 x i8] c"testNamed2 error", align 1{{$}} -// CHECK: {{^}}@[[NAMED4_ERR:[0-9]+]] = private unnamed_addr constant [16 x i8] c"testNamed4 error", align 1{{$}} +// CHECK: {{^}}@94 = private unnamed_addr constant [25 x i8] c"testAnonymousBuffer error", align 1{{$}} +// CHECK: {{^}}@107 = private unnamed_addr constant [17 x i8] c"testGeneric error", align 1{{$}} +// CHECK: {{^}}@108 = private unnamed_addr constant [16 x i8] c"testNamed1 error", align 1{{$}} +// CHECK: {{^}}@109 = private unnamed_addr constant [16 x i8] c"testNamed2 error", align 1{{$}} +// CHECK: {{^}}@110 = private unnamed_addr constant [16 x i8] c"testNamed4 error", align 1{{$}} type T struct { n int } -// CHECK-LABEL: define i64 @main.T.Demo1(%main.T %0){{.*}} { -// CHECK-NEXT: _llgo_0: -// CHECK-NEXT: %1 = alloca %main.T, align 8 -// CHECK-NEXT: call void @llvm.memset.p0.i64(ptr %1, i8 0, i64 8, i1 false) -// CHECK-NEXT: store %main.T %0, ptr %1, align 8 -// CHECK-NEXT: %2 = getelementptr inbounds %main.T, ptr %1, i32 0, i32 0 -// CHECK-NEXT: %3 = load i64, ptr %2, align 8 -// CHECK-NEXT: ret i64 %3 -// CHECK-NEXT: } - func (t T) Demo1() int { return t.n } @@ -236,6 +222,16 @@ type I2 interface { Demo2() int } +// CHECK-LABEL: define i64 @main.T.Demo1(%main.T %0){{.*}} { +// CHECK-NEXT: _llgo_0: +// CHECK-NEXT: %1 = alloca %main.T, align 8 +// CHECK-NEXT: call void @llvm.memset.p0.i64(ptr %1, i8 0, i64 8, i1 false) +// CHECK-NEXT: store %main.T %0, ptr %1, align 8 +// CHECK-NEXT: %2 = getelementptr inbounds %main.T, ptr %1, i32 0, i32 0 +// CHECK-NEXT: %3 = load i64, ptr %2, align 8 +// CHECK-NEXT: ret i64 %3 +// CHECK-NEXT: } + // CHECK-LABEL: define i64 @"main.(*T).Demo1"(ptr %0){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %1 = icmp eq ptr %0, null @@ -303,7 +299,7 @@ type I2 interface { // CHECK-NEXT: store i64 100, ptr %4, align 8 // CHECK-NEXT: store i64 10, ptr %1, align 8 // CHECK-NEXT: store ptr %3, ptr %2, align 8 -// CHECK-NEXT: %5 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @"*{{.*}}/cl/_testgo/abimethod.struct${{[-A-Za-z0-9_]+}}") +// CHECK-NEXT: %5 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$WkyTd7mXEW0USaC6FIo7OG9IdUUyjAJl_h3PFrMEtHc", ptr @"*{{.*}}/cl/_testgo/abimethod.struct$uZOBdiU3hXPUbVo89Hd5Yu-O7H5aW05rvCsBARpyejU") // CHECK-NEXT: %6 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %5, 0 // CHECK-NEXT: %7 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %6, ptr %0, 1 // CHECK-NEXT: %8 = call ptr @"{{.*}}/runtime/internal/runtime.IfacePtrData"(%"{{.*}}/runtime/internal/runtime.iface" %7) @@ -343,7 +339,7 @@ type I2 interface { // CHECK-NEXT: %5 = load { i64, ptr }, ptr %0, align 8 // CHECK-NEXT: %6 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) // CHECK-NEXT: store { i64, ptr } %5, ptr %6, align 8 -// CHECK-NEXT: %7 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @"{{.*}}/cl/_testgo/abimethod.struct${{[-A-Za-z0-9_]+}}") +// CHECK-NEXT: %7 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$WkyTd7mXEW0USaC6FIo7OG9IdUUyjAJl_h3PFrMEtHc", ptr @"{{.*}}/cl/_testgo/abimethod.struct$uZOBdiU3hXPUbVo89Hd5Yu-O7H5aW05rvCsBARpyejU") // CHECK-NEXT: %8 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %7, 0 // CHECK-NEXT: %9 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %8, ptr %6, 1 // CHECK-NEXT: %10 = call ptr @"{{.*}}/runtime/internal/runtime.IfacePtrData"(%"{{.*}}/runtime/internal/runtime.iface" %9) @@ -381,7 +377,7 @@ type I2 interface { // CHECK-NEXT: %4 = load { i64, %main.T }, ptr %0, align 8 // CHECK-NEXT: %5 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) // CHECK-NEXT: store { i64, %main.T } %4, ptr %5, align 8 -// CHECK-NEXT: %6 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @"{{.*}}/cl/_testgo/abimethod.struct${{[-A-Za-z0-9_]+}}") +// CHECK-NEXT: %6 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$WkyTd7mXEW0USaC6FIo7OG9IdUUyjAJl_h3PFrMEtHc", ptr @"{{.*}}/cl/_testgo/abimethod.struct$wV1HLSFXt7Wv7h73sIB8bnWmKRl_W0D4YiEDGTV0x6E") // CHECK-NEXT: %7 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %6, 0 // CHECK-NEXT: %8 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %7, ptr %5, 1 // CHECK-NEXT: %9 = call ptr @"{{.*}}/runtime/internal/runtime.IfacePtrData"(%"{{.*}}/runtime/internal/runtime.iface" %8) @@ -415,7 +411,7 @@ type I2 interface { // CHECK-NEXT: %3 = getelementptr inbounds %main.T, ptr %2, i32 0, i32 0 // CHECK-NEXT: store i64 10, ptr %1, align 8 // CHECK-NEXT: store i64 100, ptr %3, align 8 -// CHECK-NEXT: %4 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @"*{{.*}}/cl/_testgo/abimethod.struct${{[-A-Za-z0-9_]+}}") +// CHECK-NEXT: %4 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$WkyTd7mXEW0USaC6FIo7OG9IdUUyjAJl_h3PFrMEtHc", ptr @"*{{.*}}/cl/_testgo/abimethod.struct$wV1HLSFXt7Wv7h73sIB8bnWmKRl_W0D4YiEDGTV0x6E") // CHECK-NEXT: %5 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %4, 0 // CHECK-NEXT: %6 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %5, ptr %0, 1 // CHECK-NEXT: %7 = call ptr @"{{.*}}/runtime/internal/runtime.IfacePtrData"(%"{{.*}}/runtime/internal/runtime.iface" %6) @@ -449,7 +445,7 @@ type I2 interface { // CHECK-NEXT: %3 = getelementptr inbounds %main.T, ptr %2, i32 0, i32 0 // CHECK-NEXT: store i64 10, ptr %1, align 8 // CHECK-NEXT: store i64 100, ptr %3, align 8 -// CHECK-NEXT: %4 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @"*{{.*}}/cl/_testgo/abimethod.struct${{[-A-Za-z0-9_]+}}") +// CHECK-NEXT: %4 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$GIQLduxo5T_xLwYbboAKy8LzikHgsGzb7WxrkOH3Lr4", ptr @"*{{.*}}/cl/_testgo/abimethod.struct$wV1HLSFXt7Wv7h73sIB8bnWmKRl_W0D4YiEDGTV0x6E") // CHECK-NEXT: %5 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %4, 0 // CHECK-NEXT: %6 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %5, ptr %0, 1 // CHECK-NEXT: %7 = call ptr @"{{.*}}/runtime/internal/runtime.IfacePtrData"(%"{{.*}}/runtime/internal/runtime.iface" %6) @@ -489,7 +485,7 @@ type I2 interface { // CHECK-NEXT: %5 = load { i64, ptr }, ptr %0, align 8 // CHECK-NEXT: %6 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) // CHECK-NEXT: store { i64, ptr } %5, ptr %6, align 8 -// CHECK-NEXT: %7 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @"{{.*}}/cl/_testgo/abimethod.struct${{[-A-Za-z0-9_]+}}") +// CHECK-NEXT: %7 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$GIQLduxo5T_xLwYbboAKy8LzikHgsGzb7WxrkOH3Lr4", ptr @"{{.*}}/cl/_testgo/abimethod.struct$uZOBdiU3hXPUbVo89Hd5Yu-O7H5aW05rvCsBARpyejU") // CHECK-NEXT: %8 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %7, 0 // CHECK-NEXT: %9 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %8, ptr %6, 1 // CHECK-NEXT: %10 = call ptr @"{{.*}}/runtime/internal/runtime.IfacePtrData"(%"{{.*}}/runtime/internal/runtime.iface" %9) @@ -529,7 +525,7 @@ type I2 interface { // CHECK-NEXT: %5 = load { i64, ptr }, ptr %0, align 8 // CHECK-NEXT: %6 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) // CHECK-NEXT: store { i64, ptr } %5, ptr %6, align 8 -// CHECK-NEXT: %7 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @"{{.*}}/cl/_testgo/abimethod.struct${{[-A-Za-z0-9_]+}}") +// CHECK-NEXT: %7 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$58AxoxqQ6sGUOM73FOqFrXsMlgxkU4HGd-S1Wl-ssYw", ptr @"{{.*}}/cl/_testgo/abimethod.struct$uZOBdiU3hXPUbVo89Hd5Yu-O7H5aW05rvCsBARpyejU") // CHECK-NEXT: %8 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %7, 0 // CHECK-NEXT: %9 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %8, ptr %6, 1 // CHECK-NEXT: %10 = call ptr @"{{.*}}/runtime/internal/runtime.IfacePtrData"(%"{{.*}}/runtime/internal/runtime.iface" %9) @@ -589,7 +585,7 @@ type I2 interface { // CHECK-NEXT: %5 = load { i64, ptr }, ptr %0, align 8 // CHECK-NEXT: %6 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) // CHECK-NEXT: store { i64, ptr } %5, ptr %6, align 8 -// CHECK-NEXT: %7 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"{{.*}}/cl/_testgo/abimethod.iface${{[-A-Za-z0-9_]+}}", ptr @"{{.*}}/cl/_testgo/abimethod.struct${{[-A-Za-z0-9_]+}}") +// CHECK-NEXT: %7 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"{{.*}}/cl/_testgo/abimethod.iface$kT5SIXt45Cspjl04Bof3DZVSOIltlDo-njpk6KqtZvA", ptr @"{{.*}}/cl/_testgo/abimethod.struct$uZOBdiU3hXPUbVo89Hd5Yu-O7H5aW05rvCsBARpyejU") // CHECK-NEXT: %8 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %7, 0 // CHECK-NEXT: %9 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %8, ptr %6, 1 // CHECK-NEXT: %10 = call ptr @"{{.*}}/runtime/internal/runtime.IfacePtrData"(%"{{.*}}/runtime/internal/runtime.iface" %9) @@ -663,7 +659,7 @@ type I2 interface { // CHECK-NEXT: %3 = call ptr @bytes.NewBufferString(%"{{.*}}/runtime/internal/runtime.String" { ptr @26, i64 5 }) // CHECK-NEXT: store i64 10, ptr %1, align 8 // CHECK-NEXT: store ptr %3, ptr %2, align 8 -// CHECK-NEXT: %4 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @"*{{.*}}/cl/_testgo/abimethod.struct${{[-A-Za-z0-9_]+}}") +// CHECK-NEXT: %4 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$O6rEVxIuA5O1E0KWpQBCgGx26X5gYhJ_nnJnHVL8_7U", ptr @"*{{.*}}/cl/_testgo/abimethod.struct$RGW016k7zllXgGPm1CvD5-IBe-9lphOOTCFtYyDGLjY") // CHECK-NEXT: %5 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %4, 0 // CHECK-NEXT: %6 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %5, ptr %0, 1 // CHECK-NEXT: %7 = call ptr @"{{.*}}/runtime/internal/runtime.IfacePtrData"(%"{{.*}}/runtime/internal/runtime.iface" %6) @@ -681,7 +677,7 @@ type I2 interface { // CHECK-EMPTY: // CHECK-NEXT: _llgo_1: ; preds = %_llgo_0 // CHECK-NEXT: %18 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @[[ANONBUF_ERR]], i64 25 }, ptr %18, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @94, i64 25 }, ptr %18, align 8 // CHECK-NEXT: %19 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %18, 1 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Panic"(%"{{.*}}/runtime/internal/runtime.eface" %19) // CHECK-NEXT: unreachable @@ -693,7 +689,7 @@ type I2 interface { // CHECK-LABEL: define void @main.testGeneric(){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %0 = call ptr @"{{.*}}/runtime/internal/runtime.AllocZ"(i64 8) -// CHECK-NEXT: %1 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @"*_llgo_main.Pointer[any]") +// CHECK-NEXT: %1 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$uinGjIxPTfzB5e5h5gH-0VIvLl5rQdJ_yx2UsrxQqds", ptr @"*_llgo_main.Pointer[any]") // CHECK-NEXT: %2 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %1, 0 // CHECK-NEXT: %3 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %2, ptr %0, 1 // CHECK-NEXT: %4 = call ptr @"main.testGeneric$1"() @@ -722,7 +718,7 @@ type I2 interface { // CHECK-EMPTY: // CHECK-NEXT: _llgo_1: ; preds = %_llgo_3 // CHECK-NEXT: %25 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @[[GENERIC_ERR]], i64 17 }, ptr %25, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @107, i64 17 }, ptr %25, align 8 // CHECK-NEXT: %26 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %25, 1 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Panic"(%"{{.*}}/runtime/internal/runtime.eface" %26) // CHECK-NEXT: unreachable @@ -737,7 +733,7 @@ type I2 interface { // CHECK-NEXT: br i1 %29, label %_llgo_1, label %_llgo_2 // CHECK-EMPTY: // CHECK-NEXT: _llgo_4: ; preds = %_llgo_0 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr %23, %"{{.*}}/runtime/internal/runtime.String" { ptr @5, i64 3 }, %"{{.*}}/runtime/internal/runtime.String" zeroinitializer) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr null, ptr %23, ptr @_llgo_int, %"{{.*}}/runtime/internal/runtime.String" zeroinitializer) // CHECK-NEXT: unreachable // CHECK-NEXT: } @@ -756,7 +752,7 @@ type I2 interface { // CHECK-NEXT: %0 = call ptr @"{{.*}}/runtime/internal/runtime.AllocZ"(i64 8) // CHECK-NEXT: %1 = getelementptr inbounds %main.T, ptr %0, i32 0, i32 0 // CHECK-NEXT: store i64 100, ptr %1, align 8 -// CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @"*_llgo_main.T") +// CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$WkyTd7mXEW0USaC6FIo7OG9IdUUyjAJl_h3PFrMEtHc", ptr @"*_llgo_main.T") // CHECK-NEXT: %3 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %2, 0 // CHECK-NEXT: %4 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %3, ptr %0, 1 // CHECK-NEXT: %5 = call ptr @"{{.*}}/runtime/internal/runtime.IfacePtrData"(%"{{.*}}/runtime/internal/runtime.iface" %4) @@ -773,7 +769,7 @@ type I2 interface { // CHECK-EMPTY: // CHECK-NEXT: _llgo_1: ; preds = %_llgo_0 // CHECK-NEXT: %15 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @[[NAMED1_ERR]], i64 16 }, ptr %15, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @108, i64 16 }, ptr %15, align 8 // CHECK-NEXT: %16 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %15, 1 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Panic"(%"{{.*}}/runtime/internal/runtime.eface" %16) // CHECK-NEXT: unreachable @@ -791,7 +787,7 @@ type I2 interface { // CHECK-NEXT: %2 = load %main.T, ptr %0, align 8 // CHECK-NEXT: %3 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 8) // CHECK-NEXT: store %main.T %2, ptr %3, align 8 -// CHECK-NEXT: %4 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @_llgo_main.T) +// CHECK-NEXT: %4 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$WkyTd7mXEW0USaC6FIo7OG9IdUUyjAJl_h3PFrMEtHc", ptr @_llgo_main.T) // CHECK-NEXT: %5 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %4, 0 // CHECK-NEXT: %6 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %5, ptr %3, 1 // CHECK-NEXT: %7 = call ptr @"{{.*}}/runtime/internal/runtime.IfacePtrData"(%"{{.*}}/runtime/internal/runtime.iface" %6) @@ -808,7 +804,7 @@ type I2 interface { // CHECK-EMPTY: // CHECK-NEXT: _llgo_1: ; preds = %_llgo_0 // CHECK-NEXT: %17 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @[[NAMED2_ERR]], i64 16 }, ptr %17, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @109, i64 16 }, ptr %17, align 8 // CHECK-NEXT: %18 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %17, 1 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Panic"(%"{{.*}}/runtime/internal/runtime.eface" %18) // CHECK-NEXT: unreachable @@ -822,7 +818,7 @@ type I2 interface { // CHECK-NEXT: %0 = call ptr @"{{.*}}/runtime/internal/runtime.AllocZ"(i64 8) // CHECK-NEXT: %1 = getelementptr inbounds %main.T, ptr %0, i32 0, i32 0 // CHECK-NEXT: store i64 100, ptr %1, align 8 -// CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @"*_llgo_main.T") +// CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$GIQLduxo5T_xLwYbboAKy8LzikHgsGzb7WxrkOH3Lr4", ptr @"*_llgo_main.T") // CHECK-NEXT: %3 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %2, 0 // CHECK-NEXT: %4 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %3, ptr %0, 1 // CHECK-NEXT: %5 = call ptr @"{{.*}}/runtime/internal/runtime.IfacePtrData"(%"{{.*}}/runtime/internal/runtime.iface" %4) @@ -839,7 +835,7 @@ type I2 interface { // CHECK-EMPTY: // CHECK-NEXT: _llgo_1: ; preds = %_llgo_0 // CHECK-NEXT: %15 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @[[NAMED4_ERR]], i64 16 }, ptr %15, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @110, i64 16 }, ptr %15, align 8 // CHECK-NEXT: %16 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %15, 1 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Panic"(%"{{.*}}/runtime/internal/runtime.eface" %16) // CHECK-NEXT: unreachable @@ -1005,6 +1001,18 @@ type I2 interface { // CHECK-NEXT: ret %"{{.*}}/runtime/internal/runtime.Slice" %4 // CHECK-NEXT: } +// CHECK-LABEL: define { %"{{.*}}/runtime/internal/runtime.Slice", %"{{.*}}/runtime/internal/runtime.iface" } @"main.*struct{m int; *bytes.Buffer}.Peek"(ptr %0, i64 %1){{.*}} { +// CHECK-NEXT: _llgo_0: +// CHECK-NEXT: %2 = getelementptr inbounds { i64, ptr }, ptr %0, i32 0, i32 1 +// CHECK-NEXT: %3 = load ptr, ptr %2, align 8 +// CHECK-NEXT: %4 = call { %"{{.*}}/runtime/internal/runtime.Slice", %"{{.*}}/runtime/internal/runtime.iface" } @"bytes.(*Buffer).Peek"(ptr %3, i64 %1) +// CHECK-NEXT: %5 = extractvalue { %"{{.*}}/runtime/internal/runtime.Slice", %"{{.*}}/runtime/internal/runtime.iface" } %4, 0 +// CHECK-NEXT: %6 = extractvalue { %"{{.*}}/runtime/internal/runtime.Slice", %"{{.*}}/runtime/internal/runtime.iface" } %4, 1 +// CHECK-NEXT: %7 = insertvalue { %"{{.*}}/runtime/internal/runtime.Slice", %"{{.*}}/runtime/internal/runtime.iface" } undef, %"{{.*}}/runtime/internal/runtime.Slice" %5, 0 +// CHECK-NEXT: %8 = insertvalue { %"{{.*}}/runtime/internal/runtime.Slice", %"{{.*}}/runtime/internal/runtime.iface" } %7, %"{{.*}}/runtime/internal/runtime.iface" %6, 1 +// CHECK-NEXT: ret { %"{{.*}}/runtime/internal/runtime.Slice", %"{{.*}}/runtime/internal/runtime.iface" } %8 +// CHECK-NEXT: } + // CHECK-LABEL: define { i64, %"{{.*}}/runtime/internal/runtime.iface" } @"main.*struct{m int; *bytes.Buffer}.Read"(ptr %0, %"{{.*}}/runtime/internal/runtime.Slice" %1){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %2 = getelementptr inbounds { i64, ptr }, ptr %0, i32 0, i32 1 @@ -1292,6 +1300,21 @@ type I2 interface { // CHECK-NEXT: ret %"{{.*}}/runtime/internal/runtime.Slice" %5 // CHECK-NEXT: } +// CHECK-LABEL: define { %"{{.*}}/runtime/internal/runtime.Slice", %"{{.*}}/runtime/internal/runtime.iface" } @"main.struct{m int; *bytes.Buffer}.Peek"({ i64, ptr } %0, i64 %1){{.*}} { +// CHECK-NEXT: _llgo_0: +// CHECK-NEXT: %2 = alloca { i64, ptr }, align 8 +// CHECK-NEXT: call void @llvm.memset.p0.i64(ptr %2, i8 0, i64 16, i1 false) +// CHECK-NEXT: store { i64, ptr } %0, ptr %2, align 8 +// CHECK-NEXT: %3 = getelementptr inbounds { i64, ptr }, ptr %2, i32 0, i32 1 +// CHECK-NEXT: %4 = load ptr, ptr %3, align 8 +// CHECK-NEXT: %5 = call { %"{{.*}}/runtime/internal/runtime.Slice", %"{{.*}}/runtime/internal/runtime.iface" } @"bytes.(*Buffer).Peek"(ptr %4, i64 %1) +// CHECK-NEXT: %6 = extractvalue { %"{{.*}}/runtime/internal/runtime.Slice", %"{{.*}}/runtime/internal/runtime.iface" } %5, 0 +// CHECK-NEXT: %7 = extractvalue { %"{{.*}}/runtime/internal/runtime.Slice", %"{{.*}}/runtime/internal/runtime.iface" } %5, 1 +// CHECK-NEXT: %8 = insertvalue { %"{{.*}}/runtime/internal/runtime.Slice", %"{{.*}}/runtime/internal/runtime.iface" } undef, %"{{.*}}/runtime/internal/runtime.Slice" %6, 0 +// CHECK-NEXT: %9 = insertvalue { %"{{.*}}/runtime/internal/runtime.Slice", %"{{.*}}/runtime/internal/runtime.iface" } %8, %"{{.*}}/runtime/internal/runtime.iface" %7, 1 +// CHECK-NEXT: ret { %"{{.*}}/runtime/internal/runtime.Slice", %"{{.*}}/runtime/internal/runtime.iface" } %9 +// CHECK-NEXT: } + // CHECK-LABEL: define { i64, %"{{.*}}/runtime/internal/runtime.iface" } @"main.struct{m int; *bytes.Buffer}.Read"({ i64, ptr } %0, %"{{.*}}/runtime/internal/runtime.Slice" %1){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %2 = alloca { i64, ptr }, align 8 diff --git a/cl/_testgo/closureall/in.go b/cl/_testgo/closureall/in.go index 10e445f318..cbe1038165 100644 --- a/cl/_testgo/closureall/in.go +++ b/cl/_testgo/closureall/in.go @@ -5,10 +5,9 @@ import _ "unsafe" // for go:linkname import "github.com/goplus/lib/c" -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [46 x i8] c"{{.*}}/cl/_testgo/closureall.S", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [3 x i8] c"Inc", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [3 x i8] c"Add", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [23 x i8] c"interface{Add(int) int}", align 1{{$}} +// CHECK: {{^}}@0 = private unnamed_addr constant [46 x i8] c"{{.*}}/cl/_testgo/closureall.S", align 1{{$}} +// CHECK: {{^}}@1 = private unnamed_addr constant [3 x i8] c"Inc", align 1{{$}} +// CHECK: {{^}}@7 = private unnamed_addr constant [3 x i8] c"Add", align 1{{$}} //go:linkname cSqrt C.sqrt func cSqrt(x c.Double) c.Double @@ -103,7 +102,7 @@ func makeWithFree(base int) Fn { // CHECK-LABEL: define i64 @"main.(*S).Inc"(ptr %0, i64 %1){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %2 = icmp eq ptr %0, null -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicWrapNilPointer"(i1 %2, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 46 }, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 3 }) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicWrapNilPointer"(i1 %2, %"{{.*}}/runtime/internal/runtime.String" { ptr @0, i64 46 }, %"{{.*}}/runtime/internal/runtime.String" { ptr @1, i64 3 }) // CHECK-NEXT: %3 = load %main.S, ptr %0, align 8 // CHECK-NEXT: %4 = call i64 @main.S.Inc(%main.S %3, i64 %1) // CHECK-NEXT: ret i64 %4 @@ -168,7 +167,7 @@ func makeWithFree(base int) Fn { // CHECK-NEXT: %__llgo_funcval_code2 = call ptr asm "", "=r,0"(ptr %15) // CHECK-NEXT: %16 = call i64 %__llgo_funcval_code2(ptr {{(nest|swiftself)}} %14, i64 7) // CHECK-NEXT: %17 = call i64 @"main.(*S).Add$thunk"(ptr %9, i64 8) -// CHECK-NEXT: %18 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @"*_llgo_main.S") +// CHECK-NEXT: %18 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$VdBKYV8-gcMjZtZfcf-u2oKoj9Lu3VXwuG8TGCW2S4A", ptr @"*_llgo_main.S") // CHECK-NEXT: %19 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %18, 0 // CHECK-NEXT: %20 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %19, ptr %9, 1 // CHECK-NEXT: %21 = call ptr @"{{.*}}/runtime/internal/runtime.IfaceType"(%"{{.*}}/runtime/internal/runtime.iface" %20) @@ -184,13 +183,13 @@ func makeWithFree(base int) Fn { // CHECK-NEXT: %27 = extractvalue { ptr, ptr } %25, 0 // CHECK-NEXT: %__llgo_funcval_code3 = call ptr asm "", "=r,0"(ptr %27) // CHECK-NEXT: %28 = call i64 %__llgo_funcval_code3(ptr {{(nest|swiftself)}} %26, i64 9) -// CHECK-NEXT: %29 = call double @{{(sqrt|main.cSqrt)}}(double 4.000000e+00) +// CHECK-NEXT: %29 = call double @sqrt(double 4.000000e+00) // CHECK-NEXT: %30 = call i32 @main.callCInt({ ptr, ptr } { ptr @abs, ptr null }, i32 -3) // CHECK-NEXT: %31 = call i32 @main.callCallback(ptr @"main.main$1", i32 7) // CHECK-NEXT: ret void // CHECK-EMPTY: // CHECK-NEXT: _llgo_2: ; preds = %_llgo_0 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr %21, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 23 }, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 3 }) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr @"_llgo_iface$VdBKYV8-gcMjZtZfcf-u2oKoj9Lu3VXwuG8TGCW2S4A", ptr %21, ptr @"_llgo_iface$VdBKYV8-gcMjZtZfcf-u2oKoj9Lu3VXwuG8TGCW2S4A", %"{{.*}}/runtime/internal/runtime.String" { ptr @7, i64 3 }) // CHECK-NEXT: unreachable // CHECK-NEXT: } diff --git a/cl/_testgo/closureenv/in.go b/cl/_testgo/closureenv/in.go index 0ab147b9ad..ca44567df8 100644 --- a/cl/_testgo/closureenv/in.go +++ b/cl/_testgo/closureenv/in.go @@ -1,14 +1,13 @@ // LITTEST package main -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [18 x i8] c"zero-sized capture", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [26 x i8] c"zero-sized capture address", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [26 x i8] c"zero-sized pointer capture", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [5 x i8] c"IsNil", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [23 x i8] c"interface{IsNil() bool}", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [25 x i8] c"nil receiver method value", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [2 x i8] c"ok", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [32 x i8] c"typed-nil interface method value", align 1{{$}} +// CHECK: {{^}}@0 = private unnamed_addr constant [18 x i8] c"zero-sized capture", align 1{{$}} +// CHECK: {{^}}@2 = private unnamed_addr constant [26 x i8] c"zero-sized capture address", align 1{{$}} +// CHECK: {{^}}@3 = private unnamed_addr constant [26 x i8] c"zero-sized pointer capture", align 1{{$}} +// CHECK: {{^}}@6 = private unnamed_addr constant [5 x i8] c"IsNil", align 1{{$}} +// CHECK: {{^}}@10 = private unnamed_addr constant [25 x i8] c"nil receiver method value", align 1{{$}} +// CHECK: {{^}}@11 = private unnamed_addr constant [2 x i8] c"ok", align 1{{$}} +// CHECK: {{^}}@12 = private unnamed_addr constant [32 x i8] c"typed-nil interface method value", align 1{{$}} type nilReceiver struct{} @@ -86,7 +85,7 @@ func main() { // CHECK-EMPTY: // CHECK-NEXT: _llgo_1: ; preds = %_llgo_0 // CHECK-NEXT: %5 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 18 }, ptr %5, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @0, i64 18 }, ptr %5, align 8 // CHECK-NEXT: %6 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %5, 1 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Panic"(%"{{.*}}/runtime/internal/runtime.eface" %6) // CHECK-NEXT: unreachable @@ -104,7 +103,7 @@ func main() { // CHECK-EMPTY: // CHECK-NEXT: _llgo_3: ; preds = %_llgo_2 // CHECK-NEXT: %14 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 26 }, ptr %14, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @2, i64 26 }, ptr %14, align 8 // CHECK-NEXT: %15 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %14, 1 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Panic"(%"{{.*}}/runtime/internal/runtime.eface" %15) // CHECK-NEXT: unreachable @@ -119,7 +118,7 @@ func main() { // CHECK-EMPTY: // CHECK-NEXT: _llgo_5: ; preds = %_llgo_4 // CHECK-NEXT: %20 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 26 }, ptr %20, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @3, i64 26 }, ptr %20, align 8 // CHECK-NEXT: %21 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %20, 1 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Panic"(%"{{.*}}/runtime/internal/runtime.eface" %21) // CHECK-NEXT: unreachable @@ -137,13 +136,13 @@ func main() { // CHECK-EMPTY: // CHECK-NEXT: _llgo_7: ; preds = %_llgo_6 // CHECK-NEXT: %28 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 25 }, ptr %28, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @10, i64 25 }, ptr %28, align 8 // CHECK-NEXT: %29 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %28, 1 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Panic"(%"{{.*}}/runtime/internal/runtime.eface" %29) // CHECK-NEXT: unreachable // CHECK-EMPTY: // CHECK-NEXT: _llgo_8: ; preds = %_llgo_6 -// CHECK-NEXT: %30 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @"*_llgo_main.nilReceiver") +// CHECK-NEXT: %30 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$36psrSzSiKQuwmDQNUwPgWt23w6DHhlw0KM1_Hu7IbY", ptr @"*_llgo_main.nilReceiver") // CHECK-NEXT: %31 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %30, 0 // CHECK-NEXT: %32 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %31, ptr null, 1 // CHECK-NEXT: %33 = call ptr @"{{.*}}/runtime/internal/runtime.IfaceType"(%"{{.*}}/runtime/internal/runtime.iface" %32) @@ -152,13 +151,13 @@ func main() { // CHECK-EMPTY: // CHECK-NEXT: _llgo_9: ; preds = %_llgo_11 // CHECK-NEXT: %35 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 32 }, ptr %35, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @12, i64 32 }, ptr %35, align 8 // CHECK-NEXT: %36 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %35, 1 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Panic"(%"{{.*}}/runtime/internal/runtime.eface" %36) // CHECK-NEXT: unreachable // CHECK-EMPTY: // CHECK-NEXT: _llgo_10: ; preds = %_llgo_11 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintString"(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 2 }) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintString"(%"{{.*}}/runtime/internal/runtime.String" { ptr @11, i64 2 }) // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintByte"(i8 10) // CHECK-NEXT: ret void // CHECK-EMPTY: @@ -174,7 +173,7 @@ func main() { // CHECK-NEXT: br i1 %42, label %_llgo_10, label %_llgo_9 // CHECK-EMPTY: // CHECK-NEXT: _llgo_12: ; preds = %_llgo_8 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr %33, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 23 }, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 5 }) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr @"_llgo_iface$36psrSzSiKQuwmDQNUwPgWt23w6DHhlw0KM1_Hu7IbY", ptr %33, ptr @"_llgo_iface$36psrSzSiKQuwmDQNUwPgWt23w6DHhlw0KM1_Hu7IbY", %"{{.*}}/runtime/internal/runtime.String" { ptr @6, i64 5 }) // CHECK-NEXT: unreachable // CHECK-NEXT: } diff --git a/cl/_testgo/defer4/in.go b/cl/_testgo/defer4/in.go index c9dbafee92..f4151f6920 100644 --- a/cl/_testgo/defer4/in.go +++ b/cl/_testgo/defer4/in.go @@ -1,14 +1,13 @@ // LITTEST package main -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [3 x i8] c"bye", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [13 x i8] c"panic message", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [6 x i8] c"string", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [8 x i8] c"recover:", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [5 x i8] c"hello", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [9 x i8] c"reachable", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [5 x i8] c"world", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [2 x i8] c"hi", align 1{{$}} +// CHECK: {{^}}@0 = private unnamed_addr constant [3 x i8] c"bye", align 1{{$}} +// CHECK: {{^}}@1 = private unnamed_addr constant [13 x i8] c"panic message", align 1{{$}} +// CHECK: {{^}}@3 = private unnamed_addr constant [8 x i8] c"recover:", align 1{{$}} +// CHECK: {{^}}@4 = private unnamed_addr constant [5 x i8] c"hello", align 1{{$}} +// CHECK: {{^}}@5 = private unnamed_addr constant [9 x i8] c"reachable", align 1{{$}} +// CHECK: {{^}}@6 = private unnamed_addr constant [5 x i8] c"world", align 1{{$}} +// CHECK: {{^}}@7 = private unnamed_addr constant [2 x i8] c"hi", align 1{{$}} func f(s string) bool { return len(s) > 2 @@ -48,7 +47,7 @@ func main() { // CHECK-LABEL: define void @main.fail(){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %0 = call ptr @"{{.*}}/runtime/internal/runtime.GetThreadDefer"() -// CHECK-NEXT: %1 = alloca i8, i64 {{.*}}, align 1 +// CHECK-NEXT: %1 = alloca i8, i64 {{[0-9]+}}, align 1 // CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 48) // CHECK-NEXT: %3 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, i32 0, i32 0 // CHECK-NEXT: store ptr %1, ptr %3, align 8 @@ -64,7 +63,7 @@ func main() { // CHECK-NEXT: %9 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, i32 0, i32 4 // CHECK-NEXT: %10 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, i32 0, i32 5 // CHECK-NEXT: store ptr null, ptr %10, align 8 -// CHECK-NEXT: %11 = call i32 @{{(__)?}}sigsetjmp(ptr %1, i32 0) +// CHECK-NEXT: %11 = call i32 @{{(__)?sigsetjmp}}(ptr %1, i32 0) // CHECK-NEXT: %12 = icmp eq i32 %11, 0 // CHECK-NEXT: br i1 %12, label %_llgo_4, label %_llgo_5 // CHECK-EMPTY: @@ -91,10 +90,10 @@ func main() { // CHECK-NEXT: %18 = getelementptr inbounds { ptr, i64, %"{{.*}}/runtime/internal/runtime.String" }, ptr %16, i32 0, i32 1 // CHECK-NEXT: store i64 0, ptr %18, align 8 // CHECK-NEXT: %19 = getelementptr inbounds { ptr, i64, %"{{.*}}/runtime/internal/runtime.String" }, ptr %16, i32 0, i32 2 -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 3 }, ptr %19, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @0, i64 3 }, ptr %19, align 8 // CHECK-NEXT: store ptr %16, ptr %10, align 8 // CHECK-NEXT: %20 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 13 }, ptr %20, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @1, i64 13 }, ptr %20, align 8 // CHECK-NEXT: %21 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %20, 1 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Panic"(%"{{.*}}/runtime/internal/runtime.eface" %21) // CHECK-NEXT: unreachable @@ -150,14 +149,14 @@ func main() { // CHECK-NEXT: _llgo_3: ; preds = %_llgo_1 // CHECK-NEXT: %6 = extractvalue %"{{.*}}/runtime/internal/runtime.eface" %1, 1 // CHECK-NEXT: %7 = load %"{{.*}}/runtime/internal/runtime.String", ptr %6, align 8 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintString"(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 8 }) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintString"(%"{{.*}}/runtime/internal/runtime.String" { ptr @3, i64 8 }) // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintByte"(i8 32) // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintString"(%"{{.*}}/runtime/internal/runtime.String" %7) // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintByte"(i8 10) // CHECK-NEXT: br label %_llgo_2 // CHECK-EMPTY: // CHECK-NEXT: _llgo_4: ; preds = %_llgo_1 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr %4, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 6 }, %"{{.*}}/runtime/internal/runtime.String" zeroinitializer) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr null, ptr %4, ptr @_llgo_string, %"{{.*}}/runtime/internal/runtime.String" zeroinitializer) // CHECK-NEXT: unreachable // CHECK-NEXT: } @@ -177,7 +176,7 @@ func main() { // CHECK-LABEL: define void @main.main(){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %0 = call ptr @"{{.*}}/runtime/internal/runtime.GetThreadDefer"() -// CHECK-NEXT: %1 = alloca i8, i64 {{.*}}, align 1 +// CHECK-NEXT: %1 = alloca i8, i64 {{[0-9]+}}, align 1 // CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 48) // CHECK-NEXT: %3 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, i32 0, i32 0 // CHECK-NEXT: store ptr %1, ptr %3, align 8 @@ -193,7 +192,7 @@ func main() { // CHECK-NEXT: %9 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, i32 0, i32 4 // CHECK-NEXT: %10 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, i32 0, i32 5 // CHECK-NEXT: store ptr null, ptr %10, align 8 -// CHECK-NEXT: %11 = call i32 @{{(__)?}}sigsetjmp(ptr %1, i32 0) +// CHECK-NEXT: %11 = call i32 @{{(__)?sigsetjmp}}(ptr %1, i32 0) // CHECK-NEXT: %12 = icmp eq i32 %11, 0 // CHECK-NEXT: br i1 %12, label %_llgo_6, label %_llgo_7 // CHECK-EMPTY: @@ -211,10 +210,10 @@ func main() { // CHECK-NEXT: %18 = getelementptr inbounds { ptr, i64, %"{{.*}}/runtime/internal/runtime.String" }, ptr %16, i32 0, i32 1 // CHECK-NEXT: store i64 1, ptr %18, align 8 // CHECK-NEXT: %19 = getelementptr inbounds { ptr, i64, %"{{.*}}/runtime/internal/runtime.String" }, ptr %16, i32 0, i32 2 -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 5 }, ptr %19, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @4, i64 5 }, ptr %19, align 8 // CHECK-NEXT: store ptr %16, ptr %10, align 8 // CHECK-NEXT: call void @main.fail() -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintString"(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 9 }) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintString"(%"{{.*}}/runtime/internal/runtime.String" { ptr @5, i64 9 }) // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintByte"(i8 10) // CHECK-NEXT: store ptr blockaddress(@main.main, %_llgo_8), ptr %9, align 8 // CHECK-NEXT: br label %_llgo_4 @@ -230,7 +229,7 @@ func main() { // CHECK-NEXT: %25 = getelementptr inbounds { ptr, i64, %"{{.*}}/runtime/internal/runtime.String" }, ptr %23, i32 0, i32 1 // CHECK-NEXT: store i64 2, ptr %25, align 8 // CHECK-NEXT: %26 = getelementptr inbounds { ptr, i64, %"{{.*}}/runtime/internal/runtime.String" }, ptr %23, i32 0, i32 2 -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 5 }, ptr %26, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @6, i64 5 }, ptr %26, align 8 // CHECK-NEXT: store ptr %23, ptr %10, align 8 // CHECK-NEXT: store ptr blockaddress(@main.main, %_llgo_9), ptr %9, align 8 // CHECK-NEXT: br label %_llgo_4 @@ -247,7 +246,7 @@ func main() { // CHECK-NEXT: br label %_llgo_1 // CHECK-EMPTY: // CHECK-NEXT: _llgo_6: ; preds = %_llgo_0 -// CHECK-NEXT: %30 = call i1 @main.f(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 5 }) +// CHECK-NEXT: %30 = call i1 @main.f(%"{{.*}}/runtime/internal/runtime.String" { ptr @4, i64 5 }) // CHECK-NEXT: br i1 %30, label %_llgo_2, label %_llgo_3 // CHECK-EMPTY: // CHECK-NEXT: _llgo_7: ; preds = %_llgo_0 @@ -325,7 +324,7 @@ func main() { // CHECK-LABEL: define void @"main.main$1"(){{.*}} { // CHECK-NEXT: _llgo_0: -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintString"(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 2 }) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintString"(%"{{.*}}/runtime/internal/runtime.String" { ptr @7, i64 2 }) // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintByte"(i8 10) // CHECK-NEXT: ret void // CHECK-NEXT: } diff --git a/cl/_testgo/genericembediface/in.go b/cl/_testgo/genericembediface/in.go index 95472a2c13..8d040f984e 100644 --- a/cl/_testgo/genericembediface/in.go +++ b/cl/_testgo/genericembediface/in.go @@ -5,12 +5,11 @@ import ( "github.com/goplus/llgo/cl/_testgo/genericembediface/streamlib" ) -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [20 x i8] c"ServerReflectionInfo", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [7 x i8] c"Context", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [68 x i8] c"{{.*}}/cl/_testgo/genericembediface.ReflectionServer", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [4 x i8] c"pass", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [58 x i8] c"{{.*}}/cl/_testgo/genericembediface.server", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [58 x i8] c"{{.*}}/cl/_testgo/genericembediface.stream", align 1{{$}} +// CHECK: {{^}}@2 = private unnamed_addr constant [20 x i8] c"ServerReflectionInfo", align 1{{$}} +// CHECK: {{^}}@5 = private unnamed_addr constant [7 x i8] c"Context", align 1{{$}} +// CHECK: {{^}}@18 = private unnamed_addr constant [4 x i8] c"pass", align 1{{$}} +// CHECK: {{^}}@19 = private unnamed_addr constant [58 x i8] c"{{.*}}/cl/_testgo/genericembediface.server", align 1{{$}} +// CHECK: {{^}}@20 = private unnamed_addr constant [58 x i8] c"{{.*}}/cl/_testgo/genericembediface.stream", align 1{{$}} type Request struct{} type Response struct{} @@ -48,13 +47,13 @@ func main() { // CHECK-EMPTY: // CHECK-NEXT: _llgo_1: ; preds = %_llgo_0 // CHECK-NEXT: %4 = extractvalue %"{{.*}}/runtime/internal/runtime.eface" %0, 1 -// CHECK-NEXT: %5 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr %2) +// CHECK-NEXT: %5 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$BvNBaULAPv8d6dMcw84Vo_vBubLQ8fAehPBYVHY6m7g", ptr %2) // CHECK-NEXT: %6 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %5, 0 // CHECK-NEXT: %7 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %6, ptr %4, 1 // CHECK-NEXT: %8 = call ptr @"{{.*}}/runtime/internal/runtime.AllocZ"(i64 16) // CHECK-NEXT: %9 = getelementptr inbounds %"{{.*}}/cl/_testgo/genericembediface/streamlib.GenericServerStream[main.Request,main.Response]", ptr %8, i32 0, i32 0 // CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.iface" %1, ptr %9, align 8 -// CHECK-NEXT: %10 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @"*_llgo_{{.*}}/cl/_testgo/genericembediface/streamlib.GenericServerStream[main.Request,main.Response]") +// CHECK-NEXT: %10 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$v_XV1q3uiNvAZy1sSF5r_9UE2XfxcttHV0UKe3XpAeo", ptr @"*_llgo_{{.*}}/cl/_testgo/genericembediface/streamlib.GenericServerStream[main.Request,main.Response]") // CHECK-NEXT: %11 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %10, 0 // CHECK-NEXT: %12 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %11, ptr %8, 1 // CHECK-NEXT: %13 = call ptr @"{{.*}}/runtime/internal/runtime.IfacePtrData"(%"{{.*}}/runtime/internal/runtime.iface" %7) @@ -69,7 +68,7 @@ func main() { // CHECK-NEXT: ret %"{{.*}}/runtime/internal/runtime.iface" %21 // CHECK-EMPTY: // CHECK-NEXT: _llgo_2: ; preds = %_llgo_0 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr %2, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 68 }, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 20 }) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr null, ptr %2, ptr @_llgo_main.ReflectionServer, %"{{.*}}/runtime/internal/runtime.String" { ptr @2, i64 20 }) // CHECK-NEXT: unreachable // CHECK-NEXT: } @@ -94,11 +93,11 @@ func main() { // CHECK-NEXT: %1 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_main.server, ptr undef }, ptr %0, 1 // CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 0) // CHECK-NEXT: store %main.stream zeroinitializer, ptr %2, align 1 -// CHECK-NEXT: %3 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @_llgo_main.stream) +// CHECK-NEXT: %3 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$v_XV1q3uiNvAZy1sSF5r_9UE2XfxcttHV0UKe3XpAeo", ptr @_llgo_main.stream) // CHECK-NEXT: %4 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %3, 0 // CHECK-NEXT: %5 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %4, ptr %2, 1 // CHECK-NEXT: %6 = call %"{{.*}}/runtime/internal/runtime.iface" @main.handler(%"{{.*}}/runtime/internal/runtime.eface" %1, %"{{.*}}/runtime/internal/runtime.iface" %5) -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintString"(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 4 }) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintString"(%"{{.*}}/runtime/internal/runtime.String" { ptr @18, i64 4 }) // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintByte"(i8 10) // CHECK-NEXT: ret void // CHECK-NEXT: } @@ -111,7 +110,7 @@ func main() { // CHECK-LABEL: define %"{{.*}}/runtime/internal/runtime.iface" @"main.(*server).ServerReflectionInfo"(ptr %0, %"{{.*}}/runtime/internal/runtime.iface" %1){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %2 = icmp eq ptr %0, null -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicWrapNilPointer"(i1 %2, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 58 }, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 20 }) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicWrapNilPointer"(i1 %2, %"{{.*}}/runtime/internal/runtime.String" { ptr @19, i64 58 }, %"{{.*}}/runtime/internal/runtime.String" { ptr @2, i64 20 }) // CHECK-NEXT: %3 = icmp eq ptr %0, null // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.AssertNilDeref"(i1 %3) // CHECK-NEXT: %4 = call %"{{.*}}/runtime/internal/runtime.iface" @main.server.ServerReflectionInfo(%main.server zeroinitializer, %"{{.*}}/runtime/internal/runtime.iface" %1) @@ -120,13 +119,13 @@ func main() { // CHECK-LABEL: define %"{{.*}}/runtime/internal/runtime.String" @main.stream.Context(%main.stream %0){{.*}} { // CHECK-NEXT: _llgo_0: -// CHECK-NEXT: ret %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 7 } +// CHECK-NEXT: ret %"{{.*}}/runtime/internal/runtime.String" { ptr @5, i64 7 } // CHECK-NEXT: } // CHECK-LABEL: define %"{{.*}}/runtime/internal/runtime.String" @"main.(*stream).Context"(ptr %0){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %1 = icmp eq ptr %0, null -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicWrapNilPointer"(i1 %1, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 58 }, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 7 }) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicWrapNilPointer"(i1 %1, %"{{.*}}/runtime/internal/runtime.String" { ptr @20, i64 58 }, %"{{.*}}/runtime/internal/runtime.String" { ptr @5, i64 7 }) // CHECK-NEXT: %2 = icmp eq ptr %0, null // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.AssertNilDeref"(i1 %2) // CHECK-NEXT: %3 = call %"{{.*}}/runtime/internal/runtime.String" @main.stream.Context(%main.stream zeroinitializer) diff --git a/cl/_testgo/ifaceprom/in.go b/cl/_testgo/ifaceprom/in.go index dedb859701..29bc00c9ca 100644 --- a/cl/_testgo/ifaceprom/in.go +++ b/cl/_testgo/ifaceprom/in.go @@ -5,11 +5,10 @@ package main // struct. In particular, this test exercises that the correct // method is called. -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [3 x i8] c"two", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [48 x i8] c"{{.*}}/cl/_testgo/ifaceprom.impl", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [3 x i8] c"one", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [45 x i8] c"{{.*}}/cl/_testgo/ifaceprom.I", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [4 x i8] c"pass", align 1{{$}} +// CHECK: {{^}}@0 = private unnamed_addr constant [3 x i8] c"two", align 1{{$}} +// CHECK: {{^}}@1 = private unnamed_addr constant [48 x i8] c"{{.*}}/cl/_testgo/ifaceprom.impl", align 1{{$}} +// CHECK: {{^}}@2 = private unnamed_addr constant [3 x i8] c"one", align 1{{$}} +// CHECK: {{^}}@13 = private unnamed_addr constant [4 x i8] c"pass", align 1{{$}} type I interface { one() int @@ -155,13 +154,13 @@ func main() { // CHECK-LABEL: define %"{{.*}}/runtime/internal/runtime.String" @main.impl.two(%main.impl %0){{.*}} { // CHECK-NEXT: _llgo_0: -// CHECK-NEXT: ret %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 3 } +// CHECK-NEXT: ret %"{{.*}}/runtime/internal/runtime.String" { ptr @0, i64 3 } // CHECK-NEXT: } // CHECK-LABEL: define i64 @"main.(*impl).one"(ptr %0){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %1 = icmp eq ptr %0, null -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicWrapNilPointer"(i1 %1, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 48 }, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 3 }) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicWrapNilPointer"(i1 %1, %"{{.*}}/runtime/internal/runtime.String" { ptr @1, i64 48 }, %"{{.*}}/runtime/internal/runtime.String" { ptr @2, i64 3 }) // CHECK-NEXT: %2 = icmp eq ptr %0, null // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.AssertNilDeref"(i1 %2) // CHECK-NEXT: %3 = call i64 @main.impl.one(%main.impl zeroinitializer) @@ -171,7 +170,7 @@ func main() { // CHECK-LABEL: define %"{{.*}}/runtime/internal/runtime.String" @"main.(*impl).two"(ptr %0){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %1 = icmp eq ptr %0, null -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicWrapNilPointer"(i1 %1, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 48 }, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 3 }) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicWrapNilPointer"(i1 %1, %"{{.*}}/runtime/internal/runtime.String" { ptr @1, i64 48 }, %"{{.*}}/runtime/internal/runtime.String" { ptr @0, i64 3 }) // CHECK-NEXT: %2 = icmp eq ptr %0, null // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.AssertNilDeref"(i1 %2) // CHECK-NEXT: %3 = call %"{{.*}}/runtime/internal/runtime.String" @main.impl.two(%main.impl zeroinitializer) @@ -285,7 +284,7 @@ func main() { // CHECK-NEXT: %54 = extractvalue { ptr, ptr } %53, 1 // CHECK-NEXT: %55 = extractvalue { ptr, ptr } %53, 0 // CHECK-NEXT: %56 = call %"{{.*}}/runtime/internal/runtime.String" %55(ptr %54) -// CHECK-NEXT: %57 = call i1 @"{{.*}}/runtime/internal/runtime.StringEqual"(%"{{.*}}/runtime/internal/runtime.String" %56, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 3 }) +// CHECK-NEXT: %57 = call i1 @"{{.*}}/runtime/internal/runtime.StringEqual"(%"{{.*}}/runtime/internal/runtime.String" %56, %"{{.*}}/runtime/internal/runtime.String" { ptr @0, i64 3 }) // CHECK-NEXT: %58 = xor i1 %57, true // CHECK-NEXT: br i1 %58, label %_llgo_9, label %_llgo_10 // CHECK-EMPTY: @@ -308,7 +307,7 @@ func main() { // CHECK-NEXT: %69 = extractvalue { ptr, ptr } %68, 1 // CHECK-NEXT: %70 = extractvalue { ptr, ptr } %68, 0 // CHECK-NEXT: %71 = call %"{{.*}}/runtime/internal/runtime.String" %70(ptr %69) -// CHECK-NEXT: %72 = call i1 @"{{.*}}/runtime/internal/runtime.StringEqual"(%"{{.*}}/runtime/internal/runtime.String" %71, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 3 }) +// CHECK-NEXT: %72 = call i1 @"{{.*}}/runtime/internal/runtime.StringEqual"(%"{{.*}}/runtime/internal/runtime.String" %71, %"{{.*}}/runtime/internal/runtime.String" { ptr @0, i64 3 }) // CHECK-NEXT: %73 = xor i1 %72, true // CHECK-NEXT: br i1 %73, label %_llgo_11, label %_llgo_12 // CHECK-EMPTY: @@ -348,7 +347,7 @@ func main() { // CHECK-NEXT: unreachable // CHECK-EMPTY: // CHECK-NEXT: _llgo_16: ; preds = %_llgo_23 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintString"(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 4 }) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintString"(%"{{.*}}/runtime/internal/runtime.String" { ptr @13, i64 4 }) // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintByte"(i8 10) // CHECK-NEXT: ret void // CHECK-EMPTY: @@ -365,7 +364,7 @@ func main() { // CHECK-NEXT: br i1 %94, label %_llgo_5, label %_llgo_6 // CHECK-EMPTY: // CHECK-NEXT: _llgo_18: ; preds = %_llgo_4 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr %36, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 45 }, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 3 }) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr @_llgo_main.I, ptr %36, ptr @_llgo_main.I, %"{{.*}}/runtime/internal/runtime.String" { ptr @2, i64 3 }) // CHECK-NEXT: unreachable // CHECK-EMPTY: // CHECK-NEXT: _llgo_19: ; preds = %_llgo_6 @@ -381,7 +380,7 @@ func main() { // CHECK-NEXT: br i1 %101, label %_llgo_7, label %_llgo_8 // CHECK-EMPTY: // CHECK-NEXT: _llgo_20: ; preds = %_llgo_6 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr %42, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 45 }, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 3 }) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr @_llgo_main.I, ptr %42, ptr @_llgo_main.I, %"{{.*}}/runtime/internal/runtime.String" { ptr @2, i64 3 }) // CHECK-NEXT: unreachable // CHECK-EMPTY: // CHECK-NEXT: _llgo_21: ; preds = %_llgo_12 @@ -393,12 +392,12 @@ func main() { // CHECK-NEXT: %106 = extractvalue { ptr, ptr } %104, 0 // CHECK-NEXT: %__llgo_funcval_code2 = call ptr asm "", "=r,0"(ptr %106) // CHECK-NEXT: %107 = call %"{{.*}}/runtime/internal/runtime.String" %__llgo_funcval_code2(ptr {{(nest|swiftself)}} %105) -// CHECK-NEXT: %108 = call i1 @"{{.*}}/runtime/internal/runtime.StringEqual"(%"{{.*}}/runtime/internal/runtime.String" %107, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 3 }) +// CHECK-NEXT: %108 = call i1 @"{{.*}}/runtime/internal/runtime.StringEqual"(%"{{.*}}/runtime/internal/runtime.String" %107, %"{{.*}}/runtime/internal/runtime.String" { ptr @0, i64 3 }) // CHECK-NEXT: %109 = xor i1 %108, true // CHECK-NEXT: br i1 %109, label %_llgo_13, label %_llgo_14 // CHECK-EMPTY: // CHECK-NEXT: _llgo_22: ; preds = %_llgo_12 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr %78, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 45 }, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 3 }) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr @_llgo_main.I, ptr %78, ptr @_llgo_main.I, %"{{.*}}/runtime/internal/runtime.String" { ptr @2, i64 3 }) // CHECK-NEXT: unreachable // CHECK-EMPTY: // CHECK-NEXT: _llgo_23: ; preds = %_llgo_14 @@ -410,12 +409,12 @@ func main() { // CHECK-NEXT: %114 = extractvalue { ptr, ptr } %112, 0 // CHECK-NEXT: %__llgo_funcval_code3 = call ptr asm "", "=r,0"(ptr %114) // CHECK-NEXT: %115 = call %"{{.*}}/runtime/internal/runtime.String" %__llgo_funcval_code3(ptr {{(nest|swiftself)}} %113) -// CHECK-NEXT: %116 = call i1 @"{{.*}}/runtime/internal/runtime.StringEqual"(%"{{.*}}/runtime/internal/runtime.String" %115, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 3 }) +// CHECK-NEXT: %116 = call i1 @"{{.*}}/runtime/internal/runtime.StringEqual"(%"{{.*}}/runtime/internal/runtime.String" %115, %"{{.*}}/runtime/internal/runtime.String" { ptr @0, i64 3 }) // CHECK-NEXT: %117 = xor i1 %116, true // CHECK-NEXT: br i1 %117, label %_llgo_15, label %_llgo_16 // CHECK-EMPTY: // CHECK-NEXT: _llgo_24: ; preds = %_llgo_14 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr %84, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 45 }, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 3 }) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr @_llgo_main.I, ptr %84, ptr @_llgo_main.I, %"{{.*}}/runtime/internal/runtime.String" { ptr @2, i64 3 }) // CHECK-NEXT: unreachable // CHECK-NEXT: } diff --git a/cl/_testgo/invoke/in.go b/cl/_testgo/invoke/in.go index 22cbccef4e..f9c29180f1 100644 --- a/cl/_testgo/invoke/in.go +++ b/cl/_testgo/invoke/in.go @@ -17,28 +17,11 @@ package main // CHECK: {{^}}@13 = private unnamed_addr constant [43 x i8] c"{{.*}}/cl/_testgo/invoke.T6", align 1{{$}} // CHECK: {{^}}@14 = private unnamed_addr constant [5 x i8] c"hello", align 1{{$}} // CHECK: {{^}}@36 = private unnamed_addr constant [5 x i8] c"world", align 1{{$}} -// CHECK: {{^}}@38 = private unnamed_addr constant [42 x i8] c"{{.*}}/cl/_testgo/invoke.I", align 1{{$}} -// CHECK: {{^}}@40 = private unnamed_addr constant [3 x i8] c"any", align 1{{$}} -// CHECK: {{^}}@41 = private unnamed_addr constant [23 x i8] c"interface{Invoke() int}", align 1{{$}} type T struct { s string } -// CHECK-LABEL: define i64 @main.T.Invoke(%main.T %0){{.*}} { -// CHECK-NEXT: _llgo_0: -// CHECK-NEXT: %1 = alloca %main.T, align 8 -// CHECK-NEXT: call void @llvm.memset.p0.i64(ptr %1, i8 0, i64 16, i1 false) -// CHECK-NEXT: store %main.T %0, ptr %1, align 8 -// CHECK-NEXT: %2 = getelementptr inbounds %main.T, ptr %1, i32 0, i32 0 -// CHECK-NEXT: %3 = load %"{{.*}}/runtime/internal/runtime.String", ptr %2, align 8 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintString"(%"{{.*}}/runtime/internal/runtime.String" { ptr @0, i64 6 }) -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintByte"(i8 32) -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintString"(%"{{.*}}/runtime/internal/runtime.String" %3) -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintByte"(i8 10) -// CHECK-NEXT: ret i64 0 -// CHECK-NEXT: } - func (t T) Invoke() int { println("invoke", t.s) return 0 @@ -157,6 +140,20 @@ type M interface { Method() } +// CHECK-LABEL: define i64 @main.T.Invoke(%main.T %0){{.*}} { +// CHECK-NEXT: _llgo_0: +// CHECK-NEXT: %1 = alloca %main.T, align 8 +// CHECK-NEXT: call void @llvm.memset.p0.i64(ptr %1, i8 0, i64 16, i1 false) +// CHECK-NEXT: store %main.T %0, ptr %1, align 8 +// CHECK-NEXT: %2 = getelementptr inbounds %main.T, ptr %1, i32 0, i32 0 +// CHECK-NEXT: %3 = load %"{{.*}}/runtime/internal/runtime.String", ptr %2, align 8 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintString"(%"{{.*}}/runtime/internal/runtime.String" { ptr @0, i64 6 }) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintByte"(i8 32) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintString"(%"{{.*}}/runtime/internal/runtime.String" %3) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintByte"(i8 10) +// CHECK-NEXT: ret i64 0 +// CHECK-NEXT: } + // CHECK-LABEL: define i64 @"main.(*T).Invoke"(ptr %0){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %1 = icmp eq ptr %0, null @@ -339,87 +336,87 @@ type M interface { // CHECK-NEXT: %10 = load %main.T, ptr %0, align 8 // CHECK-NEXT: %11 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) // CHECK-NEXT: store %main.T %10, ptr %11, align 8 -// CHECK-NEXT: %12 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @_llgo_main.T) +// CHECK-NEXT: %12 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$uRUteI7wmSy7y7ODhGzk0FdDaxGKMhVSSu6HZEv9aa0", ptr @_llgo_main.T) // CHECK-NEXT: %13 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %12, 0 // CHECK-NEXT: %14 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %13, ptr %11, 1 // CHECK-NEXT: call void @main.invoke(%"{{.*}}/runtime/internal/runtime.iface" %14) -// CHECK-NEXT: %15 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @"*_llgo_main.T") +// CHECK-NEXT: %15 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$uRUteI7wmSy7y7ODhGzk0FdDaxGKMhVSSu6HZEv9aa0", ptr @"*_llgo_main.T") // CHECK-NEXT: %16 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %15, 0 // CHECK-NEXT: %17 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %16, ptr %0, 1 // CHECK-NEXT: call void @main.invoke(%"{{.*}}/runtime/internal/runtime.iface" %17) // CHECK-NEXT: %18 = load i64, ptr %2, align 8 // CHECK-NEXT: %19 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 8) // CHECK-NEXT: store i64 %18, ptr %19, align 8 -// CHECK-NEXT: %20 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @_llgo_main.T1) +// CHECK-NEXT: %20 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$uRUteI7wmSy7y7ODhGzk0FdDaxGKMhVSSu6HZEv9aa0", ptr @_llgo_main.T1) // CHECK-NEXT: %21 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %20, 0 // CHECK-NEXT: %22 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %21, ptr %19, 1 // CHECK-NEXT: call void @main.invoke(%"{{.*}}/runtime/internal/runtime.iface" %22) -// CHECK-NEXT: %23 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @"*_llgo_main.T1") +// CHECK-NEXT: %23 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$uRUteI7wmSy7y7ODhGzk0FdDaxGKMhVSSu6HZEv9aa0", ptr @"*_llgo_main.T1") // CHECK-NEXT: %24 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %23, 0 // CHECK-NEXT: %25 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %24, ptr %2, 1 // CHECK-NEXT: call void @main.invoke(%"{{.*}}/runtime/internal/runtime.iface" %25) // CHECK-NEXT: %26 = load double, ptr %3, align 8 // CHECK-NEXT: %27 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 8) // CHECK-NEXT: store double %26, ptr %27, align 8 -// CHECK-NEXT: %28 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @_llgo_main.T2) +// CHECK-NEXT: %28 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$uRUteI7wmSy7y7ODhGzk0FdDaxGKMhVSSu6HZEv9aa0", ptr @_llgo_main.T2) // CHECK-NEXT: %29 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %28, 0 // CHECK-NEXT: %30 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %29, ptr %27, 1 // CHECK-NEXT: call void @main.invoke(%"{{.*}}/runtime/internal/runtime.iface" %30) -// CHECK-NEXT: %31 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @"*_llgo_main.T2") +// CHECK-NEXT: %31 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$uRUteI7wmSy7y7ODhGzk0FdDaxGKMhVSSu6HZEv9aa0", ptr @"*_llgo_main.T2") // CHECK-NEXT: %32 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %31, 0 // CHECK-NEXT: %33 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %32, ptr %3, 1 // CHECK-NEXT: call void @main.invoke(%"{{.*}}/runtime/internal/runtime.iface" %33) -// CHECK-NEXT: %34 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @"*_llgo_main.T3") +// CHECK-NEXT: %34 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$uRUteI7wmSy7y7ODhGzk0FdDaxGKMhVSSu6HZEv9aa0", ptr @"*_llgo_main.T3") // CHECK-NEXT: %35 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %34, 0 // CHECK-NEXT: %36 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %35, ptr %4, 1 // CHECK-NEXT: call void @main.invoke(%"{{.*}}/runtime/internal/runtime.iface" %36) // CHECK-NEXT: %37 = load [1 x i64], ptr %5, align 8 // CHECK-NEXT: %38 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 8) // CHECK-NEXT: store [1 x i64] %37, ptr %38, align 8 -// CHECK-NEXT: %39 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @_llgo_main.T4) +// CHECK-NEXT: %39 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$uRUteI7wmSy7y7ODhGzk0FdDaxGKMhVSSu6HZEv9aa0", ptr @_llgo_main.T4) // CHECK-NEXT: %40 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %39, 0 // CHECK-NEXT: %41 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %40, ptr %38, 1 // CHECK-NEXT: call void @main.invoke(%"{{.*}}/runtime/internal/runtime.iface" %41) -// CHECK-NEXT: %42 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @"*_llgo_main.T4") +// CHECK-NEXT: %42 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$uRUteI7wmSy7y7ODhGzk0FdDaxGKMhVSSu6HZEv9aa0", ptr @"*_llgo_main.T4") // CHECK-NEXT: %43 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %42, 0 // CHECK-NEXT: %44 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %43, ptr %5, 1 // CHECK-NEXT: call void @main.invoke(%"{{.*}}/runtime/internal/runtime.iface" %44) // CHECK-NEXT: %45 = load %main.T5, ptr %7, align 8 // CHECK-NEXT: %46 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 8) // CHECK-NEXT: store %main.T5 %45, ptr %46, align 8 -// CHECK-NEXT: %47 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @_llgo_main.T5) +// CHECK-NEXT: %47 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$uRUteI7wmSy7y7ODhGzk0FdDaxGKMhVSSu6HZEv9aa0", ptr @_llgo_main.T5) // CHECK-NEXT: %48 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %47, 0 // CHECK-NEXT: %49 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %48, ptr %46, 1 // CHECK-NEXT: call void @main.invoke(%"{{.*}}/runtime/internal/runtime.iface" %49) -// CHECK-NEXT: %50 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @"*_llgo_main.T5") +// CHECK-NEXT: %50 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$uRUteI7wmSy7y7ODhGzk0FdDaxGKMhVSSu6HZEv9aa0", ptr @"*_llgo_main.T5") // CHECK-NEXT: %51 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %50, 0 // CHECK-NEXT: %52 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %51, ptr %7, 1 // CHECK-NEXT: call void @main.invoke(%"{{.*}}/runtime/internal/runtime.iface" %52) // CHECK-NEXT: %53 = load %main.T6, ptr %9, align 8 // CHECK-NEXT: %54 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) // CHECK-NEXT: store %main.T6 %53, ptr %54, align 8 -// CHECK-NEXT: %55 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @_llgo_main.T6) +// CHECK-NEXT: %55 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$uRUteI7wmSy7y7ODhGzk0FdDaxGKMhVSSu6HZEv9aa0", ptr @_llgo_main.T6) // CHECK-NEXT: %56 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %55, 0 // CHECK-NEXT: %57 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %56, ptr %54, 1 // CHECK-NEXT: call void @main.invoke(%"{{.*}}/runtime/internal/runtime.iface" %57) -// CHECK-NEXT: %58 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @"*_llgo_main.T6") +// CHECK-NEXT: %58 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$uRUteI7wmSy7y7ODhGzk0FdDaxGKMhVSSu6HZEv9aa0", ptr @"*_llgo_main.T6") // CHECK-NEXT: %59 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %58, 0 // CHECK-NEXT: %60 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %59, ptr %9, 1 // CHECK-NEXT: call void @main.invoke(%"{{.*}}/runtime/internal/runtime.iface" %60) // CHECK-NEXT: %61 = call ptr @"{{.*}}/runtime/internal/runtime.IfaceType"(%"{{.*}}/runtime/internal/runtime.iface" zeroinitializer) -// CHECK-NEXT: %62 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr %61) +// CHECK-NEXT: %62 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$uRUteI7wmSy7y7ODhGzk0FdDaxGKMhVSSu6HZEv9aa0", ptr %61) // CHECK-NEXT: %63 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %62, 0 // CHECK-NEXT: %64 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %63, ptr null, 1 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintIface"(%"{{.*}}/runtime/internal/runtime.iface" %64) // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintByte"(i8 32) // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintIface"(%"{{.*}}/runtime/internal/runtime.iface" zeroinitializer) // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintByte"(i8 10) -// CHECK-NEXT: %65 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @"*_llgo_main.T") +// CHECK-NEXT: %65 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$jwmSdgh1zvY_TDIgLzCkvkbiyrdwl9N806DH0JGcyMI", ptr @"*_llgo_main.T") // CHECK-NEXT: %66 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %65, 0 // CHECK-NEXT: %67 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %66, ptr %0, 1 // CHECK-NEXT: %68 = call ptr @"{{.*}}/runtime/internal/runtime.IfaceType"(%"{{.*}}/runtime/internal/runtime.iface" %67) // CHECK-NEXT: %69 = extractvalue %"{{.*}}/runtime/internal/runtime.iface" %67, 1 -// CHECK-NEXT: %70 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr %68) +// CHECK-NEXT: %70 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$uRUteI7wmSy7y7ODhGzk0FdDaxGKMhVSSu6HZEv9aa0", ptr %68) // CHECK-NEXT: %71 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %70, 0 // CHECK-NEXT: %72 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %71, ptr %69, 1 // CHECK-NEXT: call void @main.invoke(%"{{.*}}/runtime/internal/runtime.iface" %72) @@ -437,7 +434,7 @@ type M interface { // CHECK-EMPTY: // CHECK-NEXT: _llgo_1: ; preds = %_llgo_0 // CHECK-NEXT: %80 = extractvalue %"{{.*}}/runtime/internal/runtime.eface" %77, 1 -// CHECK-NEXT: %81 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr %78) +// CHECK-NEXT: %81 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$uRUteI7wmSy7y7ODhGzk0FdDaxGKMhVSSu6HZEv9aa0", ptr %78) // CHECK-NEXT: %82 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %81, 0 // CHECK-NEXT: %83 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %82, ptr %80, 1 // CHECK-NEXT: call void @main.invoke(%"{{.*}}/runtime/internal/runtime.iface" %83) @@ -446,28 +443,28 @@ type M interface { // CHECK-NEXT: br i1 %85, label %_llgo_3, label %_llgo_4 // CHECK-EMPTY: // CHECK-NEXT: _llgo_2: ; preds = %_llgo_0 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr %78, %"{{.*}}/runtime/internal/runtime.String" { ptr @38, i64 42 }, %"{{.*}}/runtime/internal/runtime.String" { ptr @2, i64 6 }) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr null, ptr %78, ptr @_llgo_main.I, %"{{.*}}/runtime/internal/runtime.String" { ptr @2, i64 6 }) // CHECK-NEXT: unreachable // CHECK-EMPTY: // CHECK-NEXT: _llgo_3: ; preds = %_llgo_1 // CHECK-NEXT: %86 = extractvalue %"{{.*}}/runtime/internal/runtime.eface" %77, 0 -// CHECK-NEXT: %87 = call i1 @"{{.*}}/runtime/internal/runtime.Implements"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr %86) +// CHECK-NEXT: %87 = call i1 @"{{.*}}/runtime/internal/runtime.Implements"(ptr @"_llgo_iface$uRUteI7wmSy7y7ODhGzk0FdDaxGKMhVSSu6HZEv9aa0", ptr %86) // CHECK-NEXT: br i1 %87, label %_llgo_5, label %_llgo_6 // CHECK-EMPTY: // CHECK-NEXT: _llgo_4: ; preds = %_llgo_1 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr %84, %"{{.*}}/runtime/internal/runtime.String" { ptr @40, i64 3 }, %"{{.*}}/runtime/internal/runtime.String" zeroinitializer) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr null, ptr %84, ptr @_llgo_any, %"{{.*}}/runtime/internal/runtime.String" zeroinitializer) // CHECK-NEXT: unreachable // CHECK-EMPTY: // CHECK-NEXT: _llgo_5: ; preds = %_llgo_3 // CHECK-NEXT: %88 = extractvalue %"{{.*}}/runtime/internal/runtime.eface" %77, 1 -// CHECK-NEXT: %89 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr %86) +// CHECK-NEXT: %89 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$uRUteI7wmSy7y7ODhGzk0FdDaxGKMhVSSu6HZEv9aa0", ptr %86) // CHECK-NEXT: %90 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %89, 0 // CHECK-NEXT: %91 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %90, ptr %88, 1 // CHECK-NEXT: call void @main.invoke(%"{{.*}}/runtime/internal/runtime.iface" %91) // CHECK-NEXT: ret void // CHECK-EMPTY: // CHECK-NEXT: _llgo_6: ; preds = %_llgo_3 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr %86, %"{{.*}}/runtime/internal/runtime.String" { ptr @41, i64 23 }, %"{{.*}}/runtime/internal/runtime.String" { ptr @2, i64 6 }) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr null, ptr %86, ptr @"_llgo_iface$uRUteI7wmSy7y7ODhGzk0FdDaxGKMhVSSu6HZEv9aa0", %"{{.*}}/runtime/internal/runtime.String" { ptr @2, i64 6 }) // CHECK-NEXT: unreachable // CHECK-NEXT: } diff --git a/cl/_testgo/reader/in.go b/cl/_testgo/reader/in.go index 79e7b6a5a3..151fdcdab6 100644 --- a/cl/_testgo/reader/in.go +++ b/cl/_testgo/reader/in.go @@ -5,21 +5,20 @@ import ( "unicode/utf8" ) -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [7 x i8] c"WriteTo", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [5 x i8] c"Close", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [3 x i8] c"EOF", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [11 x i8] c"short write", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [11 x i8] c"hello world", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [50 x i8] c"{{.*}}/cl/_testgo/reader.nopCloser", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [49 x i8] c"{{.*}}/cl/_testgo/reader.WriterTo", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [58 x i8] c"{{.*}}/cl/_testgo/reader.nopCloserWriterTo", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [37 x i8] c"stringsReader.ReadAt: negative offset", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [34 x i8] c"stringsReader.Seek: invalid whence", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [37 x i8] c"stringsReader.Seek: negative position", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [48 x i8] c"stringsReader.UnreadByte: at beginning of string", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [49 x i8] c"strings.Reader.UnreadRune: at beginning of string", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [62 x i8] c"strings.Reader.UnreadRune: previous operation was not ReadRune", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [48 x i8] c"stringsReader.WriteTo: invalid WriteString count", align 1{{$}} +// CHECK: {{^}}@2 = private unnamed_addr constant [7 x i8] c"WriteTo", align 1{{$}} +// CHECK: {{^}}@17 = private unnamed_addr constant [5 x i8] c"Close", align 1{{$}} +// CHECK: {{^}}@28 = private unnamed_addr constant [3 x i8] c"EOF", align 1{{$}} +// CHECK: {{^}}@29 = private unnamed_addr constant [11 x i8] c"short write", align 1{{$}} +// CHECK: {{^}}@30 = private unnamed_addr constant [11 x i8] c"hello world", align 1{{$}} +// CHECK: {{^}}@53 = private unnamed_addr constant [50 x i8] c"{{.*}}/cl/_testgo/reader.nopCloser", align 1{{$}} +// CHECK: {{^}}@54 = private unnamed_addr constant [58 x i8] c"{{.*}}/cl/_testgo/reader.nopCloserWriterTo", align 1{{$}} +// CHECK: {{^}}@55 = private unnamed_addr constant [37 x i8] c"stringsReader.ReadAt: negative offset", align 1{{$}} +// CHECK: {{^}}@56 = private unnamed_addr constant [34 x i8] c"stringsReader.Seek: invalid whence", align 1{{$}} +// CHECK: {{^}}@57 = private unnamed_addr constant [37 x i8] c"stringsReader.Seek: negative position", align 1{{$}} +// CHECK: {{^}}@58 = private unnamed_addr constant [48 x i8] c"stringsReader.UnreadByte: at beginning of string", align 1{{$}} +// CHECK: {{^}}@59 = private unnamed_addr constant [49 x i8] c"strings.Reader.UnreadRune: at beginning of string", align 1{{$}} +// CHECK: {{^}}@60 = private unnamed_addr constant [62 x i8] c"strings.Reader.UnreadRune: previous operation was not ReadRune", align 1{{$}} +// CHECK: {{^}}@61 = private unnamed_addr constant [48 x i8] c"stringsReader.WriteTo: invalid WriteString count", align 1{{$}} type Reader interface { Read(p []byte) (n int, err error) @@ -337,7 +336,7 @@ func main() { // CHECK-NEXT: %5 = load %main.nopCloserWriterTo, ptr %3, align 8 // CHECK-NEXT: %6 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) // CHECK-NEXT: store %main.nopCloserWriterTo %5, ptr %6, align 8 -// CHECK-NEXT: %7 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @_llgo_main.nopCloserWriterTo) +// CHECK-NEXT: %7 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$2bmbYDBStAIdmbXPPn7qIaCcpVcj2I5k6AqgqwAfh84", ptr @_llgo_main.nopCloserWriterTo) // CHECK-NEXT: %8 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %7, 0 // CHECK-NEXT: %9 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %8, ptr %6, 1 // CHECK-NEXT: ret %"{{.*}}/runtime/internal/runtime.iface" %9 @@ -350,14 +349,14 @@ func main() { // CHECK-NEXT: %12 = load %main.nopCloser, ptr %10, align 8 // CHECK-NEXT: %13 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) // CHECK-NEXT: store %main.nopCloser %12, ptr %13, align 8 -// CHECK-NEXT: %14 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @_llgo_main.nopCloser) +// CHECK-NEXT: %14 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$2bmbYDBStAIdmbXPPn7qIaCcpVcj2I5k6AqgqwAfh84", ptr @_llgo_main.nopCloser) // CHECK-NEXT: %15 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %14, 0 // CHECK-NEXT: %16 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %15, ptr %13, 1 // CHECK-NEXT: ret %"{{.*}}/runtime/internal/runtime.iface" %16 // CHECK-EMPTY: // CHECK-NEXT: _llgo_3: ; preds = %_llgo_0 // CHECK-NEXT: %17 = extractvalue %"{{.*}}/runtime/internal/runtime.iface" %0, 1 -// CHECK-NEXT: %18 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr %1) +// CHECK-NEXT: %18 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$eN81k1zqixGTyagHw_4nqH4mGfwwehTOCTXUlbT9kzk", ptr %1) // CHECK-NEXT: %19 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %18, 0 // CHECK-NEXT: %20 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %19, ptr %17, 1 // CHECK-NEXT: %21 = insertvalue { %"{{.*}}/runtime/internal/runtime.iface", i1 } undef, %"{{.*}}/runtime/internal/runtime.iface" %20, 0 @@ -500,7 +499,7 @@ func main() { // CHECK-EMPTY: // CHECK-NEXT: _llgo_3: ; preds = %_llgo_0 // CHECK-NEXT: %31 = extractvalue %"{{.*}}/runtime/internal/runtime.iface" %0, 1 -// CHECK-NEXT: %32 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr %2) +// CHECK-NEXT: %32 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$Ly4zXiUMEac-hYAMw6b6miJ1JEhGfLyBWyBOhpsRZcU", ptr %2) // CHECK-NEXT: %33 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %32, 0 // CHECK-NEXT: %34 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %33, ptr %31, 1 // CHECK-NEXT: %35 = insertvalue { %"{{.*}}/runtime/internal/runtime.iface", i1 } undef, %"{{.*}}/runtime/internal/runtime.iface" %34, 0 @@ -532,9 +531,9 @@ func main() { // CHECK-NEXT: _llgo_1: ; preds = %_llgo_0 // CHECK-NEXT: store i1 true, ptr @"main.init$guard", align 1 // CHECK-NEXT: call void @"unicode/utf8.init"() -// CHECK-NEXT: %1 = call %"{{.*}}/runtime/internal/runtime.iface" @main.newError(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 3 }) +// CHECK-NEXT: %1 = call %"{{.*}}/runtime/internal/runtime.iface" @main.newError(%"{{.*}}/runtime/internal/runtime.String" { ptr @28, i64 3 }) // CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.iface" %1, ptr @main.EOF, align 8 -// CHECK-NEXT: %2 = call %"{{.*}}/runtime/internal/runtime.iface" @main.newError(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 11 }) +// CHECK-NEXT: %2 = call %"{{.*}}/runtime/internal/runtime.iface" @main.newError(%"{{.*}}/runtime/internal/runtime.String" { ptr @29, i64 11 }) // CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.iface" %2, ptr @main.ErrShortWrite, align 8 // CHECK-NEXT: br label %_llgo_2 // CHECK-EMPTY: @@ -546,8 +545,8 @@ func main() { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %0 = call ptr @"{{.*}}/runtime/internal/runtime.AllocZ"(i64 32) // CHECK-NEXT: %1 = getelementptr inbounds %main.stringReader, ptr %0, i32 0, i32 0 -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 11 }, ptr %1, align 8 -// CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @"*_llgo_main.stringReader") +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @30, i64 11 }, ptr %1, align 8 +// CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$uycIKA3bbxRhudEjW1hHKWKdLqHQsCVy8NdW1bkQmNw", ptr @"*_llgo_main.stringReader") // CHECK-NEXT: %3 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %2, 0 // CHECK-NEXT: %4 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %3, ptr %0, 1 // CHECK-NEXT: %5 = call { %"{{.*}}/runtime/internal/runtime.Slice", %"{{.*}}/runtime/internal/runtime.iface" } @main.ReadAll(%"{{.*}}/runtime/internal/runtime.iface" %4) @@ -566,7 +565,7 @@ func main() { // CHECK-NEXT: %1 = call ptr @"{{.*}}/runtime/internal/runtime.AllocZ"(i64 16) // CHECK-NEXT: %2 = getelementptr inbounds %main.errorString, ptr %1, i32 0, i32 0 // CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" %0, ptr %2, align 8 -// CHECK-NEXT: %3 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @"*_llgo_main.errorString") +// CHECK-NEXT: %3 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$Fh8eUJ-Gw4e6TYuajcFIOSCuqSPKAt5nS4ow7xeGXEU", ptr @"*_llgo_main.errorString") // CHECK-NEXT: %4 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %3, 0 // CHECK-NEXT: %5 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %4, ptr %1, 1 // CHECK-NEXT: ret %"{{.*}}/runtime/internal/runtime.iface" %5 @@ -606,7 +605,7 @@ func main() { // CHECK-LABEL: define %"{{.*}}/runtime/internal/runtime.iface" @"main.(*nopCloser).Close"(ptr %0){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %1 = icmp eq ptr %0, null -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicWrapNilPointer"(i1 %1, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 50 }, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 5 }) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicWrapNilPointer"(i1 %1, %"{{.*}}/runtime/internal/runtime.String" { ptr @53, i64 50 }, %"{{.*}}/runtime/internal/runtime.String" { ptr @17, i64 5 }) // CHECK-NEXT: %2 = load %main.nopCloser, ptr %0, align 8 // CHECK-NEXT: %3 = call %"{{.*}}/runtime/internal/runtime.iface" @main.nopCloser.Close(%main.nopCloser %2) // CHECK-NEXT: ret %"{{.*}}/runtime/internal/runtime.iface" %3 @@ -679,7 +678,7 @@ func main() { // CHECK-EMPTY: // CHECK-NEXT: _llgo_1: ; preds = %_llgo_0 // CHECK-NEXT: %7 = extractvalue %"{{.*}}/runtime/internal/runtime.iface" %4, 1 -// CHECK-NEXT: %8 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr %5) +// CHECK-NEXT: %8 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$eN81k1zqixGTyagHw_4nqH4mGfwwehTOCTXUlbT9kzk", ptr %5) // CHECK-NEXT: %9 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %8, 0 // CHECK-NEXT: %10 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %9, ptr %7, 1 // CHECK-NEXT: %11 = call ptr @"{{.*}}/runtime/internal/runtime.IfacePtrData"(%"{{.*}}/runtime/internal/runtime.iface" %10) @@ -698,14 +697,14 @@ func main() { // CHECK-NEXT: ret { i64, %"{{.*}}/runtime/internal/runtime.iface" } %23 // CHECK-EMPTY: // CHECK-NEXT: _llgo_2: ; preds = %_llgo_0 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr %5, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 49 }, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 7 }) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr @_llgo_main.Reader, ptr %5, ptr @_llgo_main.WriterTo, %"{{.*}}/runtime/internal/runtime.String" { ptr @2, i64 7 }) // CHECK-NEXT: unreachable // CHECK-NEXT: } // CHECK-LABEL: define %"{{.*}}/runtime/internal/runtime.iface" @"main.(*nopCloserWriterTo).Close"(ptr %0){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %1 = icmp eq ptr %0, null -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicWrapNilPointer"(i1 %1, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 58 }, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 5 }) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicWrapNilPointer"(i1 %1, %"{{.*}}/runtime/internal/runtime.String" { ptr @54, i64 58 }, %"{{.*}}/runtime/internal/runtime.String" { ptr @17, i64 5 }) // CHECK-NEXT: %2 = load %main.nopCloserWriterTo, ptr %0, align 8 // CHECK-NEXT: %3 = call %"{{.*}}/runtime/internal/runtime.iface" @main.nopCloserWriterTo.Close(%main.nopCloserWriterTo %2) // CHECK-NEXT: ret %"{{.*}}/runtime/internal/runtime.iface" %3 @@ -737,7 +736,7 @@ func main() { // CHECK-LABEL: define { i64, %"{{.*}}/runtime/internal/runtime.iface" } @"main.(*nopCloserWriterTo).WriteTo"(ptr %0, %"{{.*}}/runtime/internal/runtime.iface" %1){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %2 = icmp eq ptr %0, null -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicWrapNilPointer"(i1 %2, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 58 }, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 7 }) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicWrapNilPointer"(i1 %2, %"{{.*}}/runtime/internal/runtime.String" { ptr @54, i64 58 }, %"{{.*}}/runtime/internal/runtime.String" { ptr @2, i64 7 }) // CHECK-NEXT: %3 = load %main.nopCloserWriterTo, ptr %0, align 8 // CHECK-NEXT: %4 = call { i64, %"{{.*}}/runtime/internal/runtime.iface" } @main.nopCloserWriterTo.WriteTo(%main.nopCloserWriterTo %3, %"{{.*}}/runtime/internal/runtime.iface" %1) // CHECK-NEXT: %5 = extractvalue { i64, %"{{.*}}/runtime/internal/runtime.iface" } %4, 0 @@ -813,7 +812,7 @@ func main() { // CHECK-NEXT: br i1 %3, label %_llgo_1, label %_llgo_2 // CHECK-EMPTY: // CHECK-NEXT: _llgo_1: ; preds = %_llgo_0 -// CHECK-NEXT: %4 = call %"{{.*}}/runtime/internal/runtime.iface" @main.newError(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 37 }) +// CHECK-NEXT: %4 = call %"{{.*}}/runtime/internal/runtime.iface" @main.newError(%"{{.*}}/runtime/internal/runtime.String" { ptr @55, i64 37 }) // CHECK-NEXT: %5 = insertvalue { i64, %"{{.*}}/runtime/internal/runtime.iface" } { i64 0, %"{{.*}}/runtime/internal/runtime.iface" undef }, %"{{.*}}/runtime/internal/runtime.iface" %4, 1 // CHECK-NEXT: ret { i64, %"{{.*}}/runtime/internal/runtime.iface" } %5 // CHECK-EMPTY: @@ -999,12 +998,12 @@ func main() { // CHECK-NEXT: br i1 %15, label %_llgo_5, label %_llgo_7 // CHECK-EMPTY: // CHECK-NEXT: _llgo_7: ; preds = %_llgo_6 -// CHECK-NEXT: %16 = call %"{{.*}}/runtime/internal/runtime.iface" @main.newError(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 34 }) +// CHECK-NEXT: %16 = call %"{{.*}}/runtime/internal/runtime.iface" @main.newError(%"{{.*}}/runtime/internal/runtime.String" { ptr @56, i64 34 }) // CHECK-NEXT: %17 = insertvalue { i64, %"{{.*}}/runtime/internal/runtime.iface" } { i64 0, %"{{.*}}/runtime/internal/runtime.iface" undef }, %"{{.*}}/runtime/internal/runtime.iface" %16, 1 // CHECK-NEXT: ret { i64, %"{{.*}}/runtime/internal/runtime.iface" } %17 // CHECK-EMPTY: // CHECK-NEXT: _llgo_8: ; preds = %_llgo_1 -// CHECK-NEXT: %18 = call %"{{.*}}/runtime/internal/runtime.iface" @main.newError(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 37 }) +// CHECK-NEXT: %18 = call %"{{.*}}/runtime/internal/runtime.iface" @main.newError(%"{{.*}}/runtime/internal/runtime.String" { ptr @57, i64 37 }) // CHECK-NEXT: %19 = insertvalue { i64, %"{{.*}}/runtime/internal/runtime.iface" } { i64 0, %"{{.*}}/runtime/internal/runtime.iface" undef }, %"{{.*}}/runtime/internal/runtime.iface" %18, 1 // CHECK-NEXT: ret { i64, %"{{.*}}/runtime/internal/runtime.iface" } %19 // CHECK-EMPTY: @@ -1032,7 +1031,7 @@ func main() { // CHECK-NEXT: br i1 %3, label %_llgo_1, label %_llgo_2 // CHECK-EMPTY: // CHECK-NEXT: _llgo_1: ; preds = %_llgo_0 -// CHECK-NEXT: %4 = call %"{{.*}}/runtime/internal/runtime.iface" @main.newError(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 48 }) +// CHECK-NEXT: %4 = call %"{{.*}}/runtime/internal/runtime.iface" @main.newError(%"{{.*}}/runtime/internal/runtime.String" { ptr @58, i64 48 }) // CHECK-NEXT: ret %"{{.*}}/runtime/internal/runtime.iface" %4 // CHECK-EMPTY: // CHECK-NEXT: _llgo_2: ; preds = %_llgo_0 @@ -1054,7 +1053,7 @@ func main() { // CHECK-NEXT: br i1 %3, label %_llgo_1, label %_llgo_2 // CHECK-EMPTY: // CHECK-NEXT: _llgo_1: ; preds = %_llgo_0 -// CHECK-NEXT: %4 = call %"{{.*}}/runtime/internal/runtime.iface" @main.newError(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 49 }) +// CHECK-NEXT: %4 = call %"{{.*}}/runtime/internal/runtime.iface" @main.newError(%"{{.*}}/runtime/internal/runtime.String" { ptr @59, i64 49 }) // CHECK-NEXT: ret %"{{.*}}/runtime/internal/runtime.iface" %4 // CHECK-EMPTY: // CHECK-NEXT: _llgo_2: ; preds = %_llgo_0 @@ -1064,7 +1063,7 @@ func main() { // CHECK-NEXT: br i1 %7, label %_llgo_3, label %_llgo_4 // CHECK-EMPTY: // CHECK-NEXT: _llgo_3: ; preds = %_llgo_2 -// CHECK-NEXT: %8 = call %"{{.*}}/runtime/internal/runtime.iface" @main.newError(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 62 }) +// CHECK-NEXT: %8 = call %"{{.*}}/runtime/internal/runtime.iface" @main.newError(%"{{.*}}/runtime/internal/runtime.String" { ptr @60, i64 62 }) // CHECK-NEXT: ret %"{{.*}}/runtime/internal/runtime.iface" %8 // CHECK-EMPTY: // CHECK-NEXT: _llgo_4: ; preds = %_llgo_2 @@ -1108,7 +1107,7 @@ func main() { // CHECK-EMPTY: // CHECK-NEXT: _llgo_3: ; preds = %_llgo_2 // CHECK-NEXT: %20 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 48 }, ptr %20, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @61, i64 48 }, ptr %20, align 8 // CHECK-NEXT: %21 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %20, 1 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Panic"(%"{{.*}}/runtime/internal/runtime.eface" %21) // CHECK-NEXT: unreachable diff --git a/cl/_testgo/reflect/in.go b/cl/_testgo/reflect/in.go index 8110cc7a0f..cdf7c84549 100644 --- a/cl/_testgo/reflect/in.go +++ b/cl/_testgo/reflect/in.go @@ -6,22 +6,21 @@ import ( "unsafe" ) -// CHECK: @0 = private unnamed_addr constant [11 x i8] c"call.method", align 1 -// CHECK: @2 = private unnamed_addr constant [3 x i8] c"int", align 1 -// CHECK: @6 = private unnamed_addr constant [7 x i8] c"closure", align 1 -// CHECK: @7 = private unnamed_addr constant [5 x i8] c"error", align 1 -// CHECK: @9 = private unnamed_addr constant [12 x i8] c"call.closure", align 1 -// CHECK: @10 = private unnamed_addr constant [4 x i8] c"func", align 1 -// CHECK: @11 = private unnamed_addr constant [9 x i8] c"call.func", align 1 -// CHECK: @17 = private unnamed_addr constant [7 x i8] c"imethod", align 1 -// CHECK: @18 = private unnamed_addr constant [6 x i8] c"method", align 1 -// CHECK: @22 = private unnamed_addr constant [10 x i8] c"call.slice", align 1 -// CHECK: @36 = private unnamed_addr constant [5 x i8] c"hello", align 1 -// CHECK: @37 = private unnamed_addr constant [5 x i8] c"world", align 1 -// CHECK: @38 = private unnamed_addr constant [14 x i8] c"MapIndex error", align 1 -// CHECK: @39 = private unnamed_addr constant [4 x i8] c"todo", align 1 -// CHECK: @40 = private unnamed_addr constant [12 x i8] c"must invalid", align 1 -// CHECK: @41 = private unnamed_addr constant [13 x i8] c"MapIter error", align 1 +// CHECK: {{^}}@0 = private unnamed_addr constant [11 x i8] c"call.method", align 1{{$}} +// CHECK: {{^}}@6 = private unnamed_addr constant [7 x i8] c"closure", align 1{{$}} +// CHECK: {{^}}@7 = private unnamed_addr constant [5 x i8] c"error", align 1{{$}} +// CHECK: {{^}}@9 = private unnamed_addr constant [12 x i8] c"call.closure", align 1{{$}} +// CHECK: {{^}}@10 = private unnamed_addr constant [4 x i8] c"func", align 1{{$}} +// CHECK: {{^}}@11 = private unnamed_addr constant [9 x i8] c"call.func", align 1{{$}} +// CHECK: {{^}}@17 = private unnamed_addr constant [7 x i8] c"imethod", align 1{{$}} +// CHECK: {{^}}@18 = private unnamed_addr constant [6 x i8] c"method", align 1{{$}} +// CHECK: {{^}}@22 = private unnamed_addr constant [10 x i8] c"call.slice", align 1{{$}} +// CHECK: {{^}}@36 = private unnamed_addr constant [5 x i8] c"hello", align 1{{$}} +// CHECK: {{^}}@37 = private unnamed_addr constant [5 x i8] c"world", align 1{{$}} +// CHECK: {{^}}@38 = private unnamed_addr constant [14 x i8] c"MapIndex error", align 1{{$}} +// CHECK: {{^}}@39 = private unnamed_addr constant [4 x i8] c"todo", align 1{{$}} +// CHECK: {{^}}@40 = private unnamed_addr constant [12 x i8] c"must invalid", align 1{{$}} +// CHECK: {{^}}@41 = private unnamed_addr constant [13 x i8] c"MapIter error", align 1{{$}} func main() { callSlice() @@ -89,6 +88,115 @@ type T struct { n int } +func (t *T) Add(n int) int { + println("call.method") + t.n += n + return t.n +} + +type I interface { + Add(n int) int +} + +type abi struct { + typ unsafe.Pointer + data unsafe.Pointer +} + +func callMethod() { + t := &T{1} + v := reflect.ValueOf(t) + fn := v.Method(0) + println("method", fn.Kind(), fn.Type().String()) + r := fn.Call([]reflect.Value{reflect.ValueOf(100)}) + println(r[0].Int()) + ifn, ok := fn.Interface().(func(int) int) + if !ok { + panic("error") + } + ifn(1) + v2 := reflect.ValueOf(fn.Interface()) + r2 := v2.Call([]reflect.Value{reflect.ValueOf(100)}) + println(r2[0].Int()) +} + +func callIMethod() { + var i I = &T{1} + v := reflect.ValueOf(i) + fn := v.Method(0) + println("imethod", fn.Kind(), fn.Type().String()) + r := fn.Call([]reflect.Value{reflect.ValueOf(100)}) + println(r[0].Int()) + ifn, ok := fn.Interface().(func(int) int) + if !ok { + panic("error") + } + ifn(1) + v2 := reflect.ValueOf(fn.Interface()) + r2 := v2.Call([]reflect.Value{reflect.ValueOf(100)}) + println(r2[0].Int()) +} + +func mapDemo1() { + m := map[int]string{ + 1: "hello", + 2: "world", + } + v := reflect.ValueOf(m) + if v.Len() != 2 || len(v.MapKeys()) != 2 { + panic("error") + } + if v.MapIndex(reflect.ValueOf(2)).String() != "world" { + panic("MapIndex error") + } + v.SetMapIndex(reflect.ValueOf(2), reflect.ValueOf("todo")) + if v.MapIndex(reflect.ValueOf(2)).String() != "todo" { + panic("MapIndex error") + } + if v.MapIndex(reflect.ValueOf(0)).IsValid() { + println("must invalid") + } + key := reflect.New(v.Type().Key()).Elem() + value := reflect.New(v.Type().Elem()).Elem() + iter := v.MapRange() + for iter.Next() { + key.SetIterKey(iter) + value.SetIterValue(iter) + if key.Int() != iter.Key().Int() || value.String() != iter.Value().String() { + panic("MapIter error") + } + } +} + +func mapDemo2() { + v := reflect.MakeMap(reflect.MapOf(reflect.TypeOf(0), reflect.TypeOf(""))) + v.SetMapIndex(reflect.ValueOf(1), reflect.ValueOf("hello")) + v.SetMapIndex(reflect.ValueOf(2), reflect.ValueOf("world")) + if v.Len() != 2 || len(v.MapKeys()) != 2 { + panic("error") + } + if v.MapIndex(reflect.ValueOf(2)).String() != "world" { + panic("MapIndex error") + } + v.SetMapIndex(reflect.ValueOf(2), reflect.ValueOf("todo")) + if v.MapIndex(reflect.ValueOf(2)).String() != "todo" { + panic("MapIndex error") + } + if v.MapIndex(reflect.ValueOf(0)).IsValid() { + println("must invalid") + } + key := reflect.New(v.Type().Key()).Elem() + value := reflect.New(v.Type().Elem()).Elem() + iter := v.MapRange() + for iter.Next() { + key.SetIterKey(iter) + value.SetIterValue(iter) + if key.Int() != iter.Key().Int() || value.String() != iter.Value().String() { + panic("MapIter error") + } + } +} + // CHECK-LABEL: define i64 @"main.(*T).Add"(ptr %0, i64 %1){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintString"(%"{{.*}}/runtime/internal/runtime.String" { ptr @0, i64 11 }) @@ -113,13 +221,13 @@ type T struct { // CHECK-NEXT: %3 = insertvalue { ptr, ptr } { ptr @"main.callClosure$1", ptr undef }, ptr %1, 1 // CHECK-NEXT: %4 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) // CHECK-NEXT: store { ptr, ptr } %3, ptr %4, align 8 -// CHECK-NEXT: %5 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @"_llgo_closure${{[-A-Za-z0-9_]+}}", ptr undef }, ptr %4, 1 +// CHECK-NEXT: %5 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @"_llgo_closure$QIHBTaw1IFobr8yvWpq-2AJFm3xBNhdW_aNBicqUBGk", ptr undef }, ptr %4, 1 // CHECK-NEXT: %6 = call %reflect.Value @reflect.ValueOf(%"{{.*}}/runtime/internal/runtime.eface" %5) // CHECK-NEXT: %7 = call i64 @reflect.Value.Kind(%reflect.Value %6) // CHECK-NEXT: %8 = call %"{{.*}}/runtime/internal/runtime.iface" @reflect.Value.Type(%reflect.Value %6) // CHECK-NEXT: %9 = call ptr @"{{.*}}/runtime/internal/runtime.IfacePtrData"(%"{{.*}}/runtime/internal/runtime.iface" %8) // CHECK-NEXT: %10 = extractvalue %"{{.*}}/runtime/internal/runtime.iface" %8, 0 -// CHECK-NEXT: %11 = getelementptr ptr, ptr %10, i64 {{(37|41)}} +// CHECK-NEXT: %11 = getelementptr ptr, ptr %10, i64 41 // CHECK-NEXT: %12 = load ptr, ptr %11, align 8 // CHECK-NEXT: %13 = insertvalue { ptr, ptr } undef, ptr %12, 0 // CHECK-NEXT: %14 = insertvalue { ptr, ptr } %13, ptr %9, 1 @@ -155,7 +263,7 @@ type T struct { // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintByte"(i8 10) // CHECK-NEXT: %34 = call %"{{.*}}/runtime/internal/runtime.eface" @reflect.Value.Interface(%reflect.Value %6) // CHECK-NEXT: %35 = extractvalue %"{{.*}}/runtime/internal/runtime.eface" %34, 0 -// CHECK-NEXT: %36 = call i1 @"{{.*}}/runtime/internal/runtime.MatchesClosure"(ptr @"_llgo_closure${{[-A-Za-z0-9_]+}}", ptr %35) +// CHECK-NEXT: %36 = call i1 @"{{.*}}/runtime/internal/runtime.MatchesClosure"(ptr @"_llgo_closure$QIHBTaw1IFobr8yvWpq-2AJFm3xBNhdW_aNBicqUBGk", ptr %35) // CHECK-NEXT: br i1 %36, label %_llgo_3, label %_llgo_4 // CHECK-EMPTY: // CHECK-NEXT: _llgo_1: ; preds = %_llgo_5 @@ -205,13 +313,13 @@ type T struct { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %0 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) // CHECK-NEXT: store { ptr, ptr } { ptr @"main.callFunc$1", ptr null }, ptr %0, align 8 -// CHECK-NEXT: %1 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @"_llgo_closure${{[-A-Za-z0-9_]+}}", ptr undef }, ptr %0, 1 +// CHECK-NEXT: %1 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @"_llgo_closure$QIHBTaw1IFobr8yvWpq-2AJFm3xBNhdW_aNBicqUBGk", ptr undef }, ptr %0, 1 // CHECK-NEXT: %2 = call %reflect.Value @reflect.ValueOf(%"{{.*}}/runtime/internal/runtime.eface" %1) // CHECK-NEXT: %3 = call i64 @reflect.Value.Kind(%reflect.Value %2) // CHECK-NEXT: %4 = call %"{{.*}}/runtime/internal/runtime.iface" @reflect.Value.Type(%reflect.Value %2) // CHECK-NEXT: %5 = call ptr @"{{.*}}/runtime/internal/runtime.IfacePtrData"(%"{{.*}}/runtime/internal/runtime.iface" %4) // CHECK-NEXT: %6 = extractvalue %"{{.*}}/runtime/internal/runtime.iface" %4, 0 -// CHECK-NEXT: %7 = getelementptr ptr, ptr %6, i64 {{(37|41)}} +// CHECK-NEXT: %7 = getelementptr ptr, ptr %6, i64 41 // CHECK-NEXT: %8 = load ptr, ptr %7, align 8 // CHECK-NEXT: %9 = insertvalue { ptr, ptr } undef, ptr %8, 0 // CHECK-NEXT: %10 = insertvalue { ptr, ptr } %9, ptr %5, 1 @@ -247,7 +355,7 @@ type T struct { // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintByte"(i8 10) // CHECK-NEXT: %30 = call %"{{.*}}/runtime/internal/runtime.eface" @reflect.Value.Interface(%reflect.Value %2) // CHECK-NEXT: %31 = extractvalue %"{{.*}}/runtime/internal/runtime.eface" %30, 0 -// CHECK-NEXT: %32 = call i1 @"{{.*}}/runtime/internal/runtime.MatchesClosure"(ptr @"_llgo_closure${{[-A-Za-z0-9_]+}}", ptr %31) +// CHECK-NEXT: %32 = call i1 @"{{.*}}/runtime/internal/runtime.MatchesClosure"(ptr @"_llgo_closure$QIHBTaw1IFobr8yvWpq-2AJFm3xBNhdW_aNBicqUBGk", ptr %31) // CHECK-NEXT: br i1 %32, label %_llgo_3, label %_llgo_4 // CHECK-EMPTY: // CHECK-NEXT: _llgo_1: ; preds = %_llgo_5 @@ -289,44 +397,12 @@ type T struct { // CHECK-NEXT: ret i64 %1 // CHECK-NEXT: } -func (t *T) Add(n int) int { - println("call.method") - t.n += n - return t.n -} - -type I interface { - Add(n int) int -} - -type abi struct { - typ unsafe.Pointer - data unsafe.Pointer -} - -func callMethod() { - t := &T{1} - v := reflect.ValueOf(t) - fn := v.Method(0) - println("method", fn.Kind(), fn.Type().String()) - r := fn.Call([]reflect.Value{reflect.ValueOf(100)}) - println(r[0].Int()) - ifn, ok := fn.Interface().(func(int) int) - if !ok { - panic("error") - } - ifn(1) - v2 := reflect.ValueOf(fn.Interface()) - r2 := v2.Call([]reflect.Value{reflect.ValueOf(100)}) - println(r2[0].Int()) -} - // CHECK-LABEL: define void @main.callIMethod(){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %0 = call ptr @"{{.*}}/runtime/internal/runtime.AllocZ"(i64 8) // CHECK-NEXT: %1 = getelementptr inbounds %main.T, ptr %0, i32 0, i32 0 // CHECK-NEXT: store i64 1, ptr %1, align 8 -// CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @"*_llgo_main.T") +// CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$VdBKYV8-gcMjZtZfcf-u2oKoj9Lu3VXwuG8TGCW2S4A", ptr @"*_llgo_main.T") // CHECK-NEXT: %3 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %2, 0 // CHECK-NEXT: %4 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %3, ptr %0, 1 // CHECK-NEXT: %5 = call ptr @"{{.*}}/runtime/internal/runtime.IfaceType"(%"{{.*}}/runtime/internal/runtime.iface" %4) @@ -339,7 +415,7 @@ func callMethod() { // CHECK-NEXT: %12 = call %"{{.*}}/runtime/internal/runtime.iface" @reflect.Value.Type(%reflect.Value %10) // CHECK-NEXT: %13 = call ptr @"{{.*}}/runtime/internal/runtime.IfacePtrData"(%"{{.*}}/runtime/internal/runtime.iface" %12) // CHECK-NEXT: %14 = extractvalue %"{{.*}}/runtime/internal/runtime.iface" %12, 0 -// CHECK-NEXT: %15 = getelementptr ptr, ptr %14, i64 {{(37|41)}} +// CHECK-NEXT: %15 = getelementptr ptr, ptr %14, i64 41 // CHECK-NEXT: %16 = load ptr, ptr %15, align 8 // CHECK-NEXT: %17 = insertvalue { ptr, ptr } undef, ptr %16, 0 // CHECK-NEXT: %18 = insertvalue { ptr, ptr } %17, ptr %13, 1 @@ -375,7 +451,7 @@ func callMethod() { // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintByte"(i8 10) // CHECK-NEXT: %38 = call %"{{.*}}/runtime/internal/runtime.eface" @reflect.Value.Interface(%reflect.Value %10) // CHECK-NEXT: %39 = extractvalue %"{{.*}}/runtime/internal/runtime.eface" %38, 0 -// CHECK-NEXT: %40 = call i1 @"{{.*}}/runtime/internal/runtime.MatchesClosure"(ptr @"_llgo_closure${{[-A-Za-z0-9_]+}}", ptr %39) +// CHECK-NEXT: %40 = call i1 @"{{.*}}/runtime/internal/runtime.MatchesClosure"(ptr @"_llgo_closure$QIHBTaw1IFobr8yvWpq-2AJFm3xBNhdW_aNBicqUBGk", ptr %39) // CHECK-NEXT: br i1 %40, label %_llgo_3, label %_llgo_4 // CHECK-EMPTY: // CHECK-NEXT: _llgo_1: ; preds = %_llgo_5 @@ -444,7 +520,7 @@ func callMethod() { // CHECK-NEXT: %6 = call %"{{.*}}/runtime/internal/runtime.iface" @reflect.Value.Type(%reflect.Value %4) // CHECK-NEXT: %7 = call ptr @"{{.*}}/runtime/internal/runtime.IfacePtrData"(%"{{.*}}/runtime/internal/runtime.iface" %6) // CHECK-NEXT: %8 = extractvalue %"{{.*}}/runtime/internal/runtime.iface" %6, 0 -// CHECK-NEXT: %9 = getelementptr ptr, ptr %8, i64 {{(37|41)}} +// CHECK-NEXT: %9 = getelementptr ptr, ptr %8, i64 41 // CHECK-NEXT: %10 = load ptr, ptr %9, align 8 // CHECK-NEXT: %11 = insertvalue { ptr, ptr } undef, ptr %10, 0 // CHECK-NEXT: %12 = insertvalue { ptr, ptr } %11, ptr %7, 1 @@ -480,7 +556,7 @@ func callMethod() { // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintByte"(i8 10) // CHECK-NEXT: %32 = call %"{{.*}}/runtime/internal/runtime.eface" @reflect.Value.Interface(%reflect.Value %4) // CHECK-NEXT: %33 = extractvalue %"{{.*}}/runtime/internal/runtime.eface" %32, 0 -// CHECK-NEXT: %34 = call i1 @"{{.*}}/runtime/internal/runtime.MatchesClosure"(ptr @"_llgo_closure${{[-A-Za-z0-9_]+}}", ptr %33) +// CHECK-NEXT: %34 = call i1 @"{{.*}}/runtime/internal/runtime.MatchesClosure"(ptr @"_llgo_closure$QIHBTaw1IFobr8yvWpq-2AJFm3xBNhdW_aNBicqUBGk", ptr %33) // CHECK-NEXT: br i1 %34, label %_llgo_3, label %_llgo_4 // CHECK-EMPTY: // CHECK-NEXT: _llgo_1: ; preds = %_llgo_5 @@ -541,7 +617,7 @@ func callMethod() { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %0 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) // CHECK-NEXT: store { ptr, ptr } { ptr @main.demo, ptr null }, ptr %0, align 8 -// CHECK-NEXT: %1 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @"_llgo_closure${{[-A-Za-z0-9_]+}}", ptr undef }, ptr %0, 1 +// CHECK-NEXT: %1 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @"_llgo_closure$FjMjjQr3-2iTiWyZP1IIQFOz0hUCa0OS6pEm5uVV6Pk", ptr undef }, ptr %0, 1 // CHECK-NEXT: %2 = call %reflect.Value @reflect.ValueOf(%"{{.*}}/runtime/internal/runtime.eface" %1) // CHECK-NEXT: %3 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 8) // CHECK-NEXT: store i64 1, ptr %3, align 8 @@ -728,7 +804,7 @@ func callMethod() { // CHECK-NEXT: br label %_llgo_1 // CHECK-EMPTY: // CHECK-NEXT: _llgo_5: ; preds = %_llgo_2 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr %22, %"{{.*}}/runtime/internal/runtime.String" { ptr @2, i64 3 }, %"{{.*}}/runtime/internal/runtime.String" zeroinitializer) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr null, ptr %22, ptr @_llgo_int, %"{{.*}}/runtime/internal/runtime.String" zeroinitializer) // CHECK-NEXT: unreachable // CHECK-NEXT: } @@ -758,23 +834,6 @@ func callMethod() { // CHECK-NEXT: ret void // CHECK-NEXT: } -func callIMethod() { - var i I = &T{1} - v := reflect.ValueOf(i) - fn := v.Method(0) - println("imethod", fn.Kind(), fn.Type().String()) - r := fn.Call([]reflect.Value{reflect.ValueOf(100)}) - println(r[0].Int()) - ifn, ok := fn.Interface().(func(int) int) - if !ok { - panic("error") - } - ifn(1) - v2 := reflect.ValueOf(fn.Interface()) - r2 := v2.Call([]reflect.Value{reflect.ValueOf(100)}) - println(r2[0].Int()) -} - // CHECK-LABEL: define void @main.mapDemo1(){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %0 = call ptr @"{{.*}}/runtime/internal/runtime.MakeMap"(ptr @"map[_llgo_int]_llgo_string", i64 2) @@ -868,7 +927,7 @@ func callIMethod() { // CHECK-NEXT: %43 = call %"{{.*}}/runtime/internal/runtime.iface" @reflect.Value.Type(%reflect.Value %6) // CHECK-NEXT: %44 = call ptr @"{{.*}}/runtime/internal/runtime.IfacePtrData"(%"{{.*}}/runtime/internal/runtime.iface" %43) // CHECK-NEXT: %45 = extractvalue %"{{.*}}/runtime/internal/runtime.iface" %43, 0 -// CHECK-NEXT: %46 = getelementptr ptr, ptr %45, i64 {{(20|22)}} +// CHECK-NEXT: %46 = getelementptr ptr, ptr %45, i64 22 // CHECK-NEXT: %47 = load ptr, ptr %46, align 8 // CHECK-NEXT: %48 = insertvalue { ptr, ptr } undef, ptr %47, 0 // CHECK-NEXT: %49 = insertvalue { ptr, ptr } %48, ptr %44, 1 @@ -924,37 +983,6 @@ func callIMethod() { // CHECK-NEXT: br i1 %79, label %_llgo_13, label %_llgo_12 // CHECK-NEXT: } -func mapDemo1() { - m := map[int]string{ - 1: "hello", - 2: "world", - } - v := reflect.ValueOf(m) - if v.Len() != 2 || len(v.MapKeys()) != 2 { - panic("error") - } - if v.MapIndex(reflect.ValueOf(2)).String() != "world" { - panic("MapIndex error") - } - v.SetMapIndex(reflect.ValueOf(2), reflect.ValueOf("todo")) - if v.MapIndex(reflect.ValueOf(2)).String() != "todo" { - panic("MapIndex error") - } - if v.MapIndex(reflect.ValueOf(0)).IsValid() { - println("must invalid") - } - key := reflect.New(v.Type().Key()).Elem() - value := reflect.New(v.Type().Elem()).Elem() - iter := v.MapRange() - for iter.Next() { - key.SetIterKey(iter) - value.SetIterValue(iter) - if key.Int() != iter.Key().Int() || value.String() != iter.Value().String() { - panic("MapIter error") - } - } -} - // CHECK-LABEL: define void @main.mapDemo2(){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %0 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 8) @@ -1065,7 +1093,7 @@ func mapDemo1() { // CHECK-NEXT: %56 = call %"{{.*}}/runtime/internal/runtime.iface" @reflect.Value.Type(%reflect.Value %7) // CHECK-NEXT: %57 = call ptr @"{{.*}}/runtime/internal/runtime.IfacePtrData"(%"{{.*}}/runtime/internal/runtime.iface" %56) // CHECK-NEXT: %58 = extractvalue %"{{.*}}/runtime/internal/runtime.iface" %56, 0 -// CHECK-NEXT: %59 = getelementptr ptr, ptr %58, i64 {{(20|22)}} +// CHECK-NEXT: %59 = getelementptr ptr, ptr %58, i64 22 // CHECK-NEXT: %60 = load ptr, ptr %59, align 8 // CHECK-NEXT: %61 = insertvalue { ptr, ptr } undef, ptr %60, 0 // CHECK-NEXT: %62 = insertvalue { ptr, ptr } %61, ptr %57, 1 @@ -1120,32 +1148,3 @@ func mapDemo1() { // CHECK-NEXT: %92 = xor i1 %91, true // CHECK-NEXT: br i1 %92, label %_llgo_13, label %_llgo_12 // CHECK-NEXT: } - -func mapDemo2() { - v := reflect.MakeMap(reflect.MapOf(reflect.TypeOf(0), reflect.TypeOf(""))) - v.SetMapIndex(reflect.ValueOf(1), reflect.ValueOf("hello")) - v.SetMapIndex(reflect.ValueOf(2), reflect.ValueOf("world")) - if v.Len() != 2 || len(v.MapKeys()) != 2 { - panic("error") - } - if v.MapIndex(reflect.ValueOf(2)).String() != "world" { - panic("MapIndex error") - } - v.SetMapIndex(reflect.ValueOf(2), reflect.ValueOf("todo")) - if v.MapIndex(reflect.ValueOf(2)).String() != "todo" { - panic("MapIndex error") - } - if v.MapIndex(reflect.ValueOf(0)).IsValid() { - println("must invalid") - } - key := reflect.New(v.Type().Key()).Elem() - value := reflect.New(v.Type().Elem()).Elem() - iter := v.MapRange() - for iter.Next() { - key.SetIterKey(iter) - value.SetIterValue(iter) - if key.Int() != iter.Key().Int() || value.String() != iter.Value().String() { - panic("MapIter error") - } - } -} diff --git a/cl/_testgo/reflectconv/in.go b/cl/_testgo/reflectconv/in.go index fd98e51395..369c55c1a5 100644 --- a/cl/_testgo/reflectconv/in.go +++ b/cl/_testgo/reflectconv/in.go @@ -11,44 +11,43 @@ import ( "unsafe" ) -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [7 x i8] c"reflect", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [58 x i8] c"ValueOf(%T(%[1]v)).Convert(%s) = %T(%[3]v), want %T(%[4]v)", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [59 x i8] c"ValueOf(%T(%[1]v)).Convert(%s) has internal kind %v want %v", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [63 x i8] c"Set(ValueOf(%T(%[1]v)).Convert(%s)) = %T(%[3]v), want %T(%[4]v)", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [35 x i8] c"table entry %v is RO, should not be", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [46 x i8] c"self-conversion output %v is RO, should not be", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [41 x i8] c"conversion output %v is RO, should not be", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [46 x i8] c"set(conversion output) %v is RO, should not be", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [41 x i8] c"(%s).ConvertibleTo(%s) = false, want true", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [52 x i8] c"ValueOf(%T(%[1]v)).CanConvert(%s) = false, want true", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [53 x i8] c" ValueOf(%T(%[1]v)).CanConvert(%s) = false, want true", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [49 x i8] c"RO self-conversion output %v is not RO, should be", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [44 x i8] c"RO conversion output %v is not RO, should be", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [41 x i8] c"@(%s).ConvertibleTo(%s) = %v, want %v: %v", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [47 x i8] c"store/load of sNaN not faithful, got %x want %x", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [7 x i8] c"float32", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [40 x i8] c"signaling nan conversion got %x, want %x", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [40 x i8] c"[]byte should be convertible to *[8]byte", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [57 x i8] c"slice with length 4 should not be convertible to *[8]byte", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [77 x i8] c"reflect: cannot convert slice with length 4 to pointer to array with length 8", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [56 x i8] c"slice with length 4 should not be convertible to [8]byte", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [66 x i8] c"reflect: cannot convert slice with length 4 to array with length 8", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [65 x i8] c"convert slice to non-empty array returns a addressable copy array", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [52 x i8] c"slice (%v) mutation visible in converted result (%v)", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [5 x i8] c"hello", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [6 x i8] c"bytes1", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [6 x i8] c"bytes2", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [6 x i8] c"bytes3", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [8 x i8] c"runes\E2\99\9D", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [8 x i8] c"runes\E2\99\95", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [17 x i8] c"runes\F0\9F\99\88\F0\9F\99\89\F0\9F\99\8A", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [1 x i8] c"a", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [3 x i8] c"\EF\BF\BD", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [13 x i8] c"did not panic", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [32 x i8] c"panicked with unexpected type %T", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [44 x i8] c"panic string does not start with \22reflect\22: ", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [31 x i8] c"panic string does not contain \22", align 1{{$}} -// CHECK: {{^}}@{{[0-9]+}} = private unnamed_addr constant [3 x i8] c"\22: ", align 1{{$}} +// CHECK: {{^}}@30 = private unnamed_addr constant [7 x i8] c"reflect", align 1{{$}} +// CHECK: {{^}}@391 = private unnamed_addr constant [58 x i8] c"ValueOf(%T(%[1]v)).Convert(%s) = %T(%[3]v), want %T(%[4]v)", align 1{{$}} +// CHECK: {{^}}@392 = private unnamed_addr constant [59 x i8] c"ValueOf(%T(%[1]v)).Convert(%s) has internal kind %v want %v", align 1{{$}} +// CHECK: {{^}}@393 = private unnamed_addr constant [63 x i8] c"Set(ValueOf(%T(%[1]v)).Convert(%s)) = %T(%[3]v), want %T(%[4]v)", align 1{{$}} +// CHECK: {{^}}@394 = private unnamed_addr constant [35 x i8] c"table entry %v is RO, should not be", align 1{{$}} +// CHECK: {{^}}@395 = private unnamed_addr constant [46 x i8] c"self-conversion output %v is RO, should not be", align 1{{$}} +// CHECK: {{^}}@396 = private unnamed_addr constant [41 x i8] c"conversion output %v is RO, should not be", align 1{{$}} +// CHECK: {{^}}@397 = private unnamed_addr constant [46 x i8] c"set(conversion output) %v is RO, should not be", align 1{{$}} +// CHECK: {{^}}@398 = private unnamed_addr constant [41 x i8] c"(%s).ConvertibleTo(%s) = false, want true", align 1{{$}} +// CHECK: {{^}}@399 = private unnamed_addr constant [52 x i8] c"ValueOf(%T(%[1]v)).CanConvert(%s) = false, want true", align 1{{$}} +// CHECK: {{^}}@400 = private unnamed_addr constant [53 x i8] c" ValueOf(%T(%[1]v)).CanConvert(%s) = false, want true", align 1{{$}} +// CHECK: {{^}}@401 = private unnamed_addr constant [49 x i8] c"RO self-conversion output %v is not RO, should be", align 1{{$}} +// CHECK: {{^}}@402 = private unnamed_addr constant [44 x i8] c"RO conversion output %v is not RO, should be", align 1{{$}} +// CHECK: {{^}}@403 = private unnamed_addr constant [41 x i8] c"@(%s).ConvertibleTo(%s) = %v, want %v: %v", align 1{{$}} +// CHECK: {{^}}@404 = private unnamed_addr constant [47 x i8] c"store/load of sNaN not faithful, got %x want %x", align 1{{$}} +// CHECK: {{^}}@407 = private unnamed_addr constant [40 x i8] c"signaling nan conversion got %x, want %x", align 1{{$}} +// CHECK: {{^}}@408 = private unnamed_addr constant [40 x i8] c"[]byte should be convertible to *[8]byte", align 1{{$}} +// CHECK: {{^}}@409 = private unnamed_addr constant [57 x i8] c"slice with length 4 should not be convertible to *[8]byte", align 1{{$}} +// CHECK: {{^}}@410 = private unnamed_addr constant [77 x i8] c"reflect: cannot convert slice with length 4 to pointer to array with length 8", align 1{{$}} +// CHECK: {{^}}@411 = private unnamed_addr constant [56 x i8] c"slice with length 4 should not be convertible to [8]byte", align 1{{$}} +// CHECK: {{^}}@412 = private unnamed_addr constant [66 x i8] c"reflect: cannot convert slice with length 4 to array with length 8", align 1{{$}} +// CHECK: {{^}}@414 = private unnamed_addr constant [65 x i8] c"convert slice to non-empty array returns a addressable copy array", align 1{{$}} +// CHECK: {{^}}@415 = private unnamed_addr constant [52 x i8] c"slice (%v) mutation visible in converted result (%v)", align 1{{$}} +// CHECK: {{^}}@420 = private unnamed_addr constant [5 x i8] c"hello", align 1{{$}} +// CHECK: {{^}}@421 = private unnamed_addr constant [6 x i8] c"bytes1", align 1{{$}} +// CHECK: {{^}}@422 = private unnamed_addr constant [6 x i8] c"bytes2", align 1{{$}} +// CHECK: {{^}}@423 = private unnamed_addr constant [6 x i8] c"bytes3", align 1{{$}} +// CHECK: {{^}}@424 = private unnamed_addr constant [8 x i8] c"runes\E2\99\9D", align 1{{$}} +// CHECK: {{^}}@425 = private unnamed_addr constant [8 x i8] c"runes\E2\99\95", align 1{{$}} +// CHECK: {{^}}@426 = private unnamed_addr constant [17 x i8] c"runes\F0\9F\99\88\F0\9F\99\89\F0\9F\99\8A", align 1{{$}} +// CHECK: {{^}}@427 = private unnamed_addr constant [1 x i8] c"a", align 1{{$}} +// CHECK: {{^}}@428 = private unnamed_addr constant [3 x i8] c"\EF\BF\BD", align 1{{$}} +// CHECK: {{^}}@535 = private unnamed_addr constant [13 x i8] c"did not panic", align 1{{$}} +// CHECK: {{^}}@537 = private unnamed_addr constant [32 x i8] c"panicked with unexpected type %T", align 1{{$}} +// CHECK: {{^}}@538 = private unnamed_addr constant [44 x i8] c"panic string does not start with \22reflect\22: ", align 1{{$}} +// CHECK: {{^}}@539 = private unnamed_addr constant [31 x i8] c"panic string does not contain \22", align 1{{$}} +// CHECK: {{^}}@540 = private unnamed_addr constant [3 x i8] c"\22: ", align 1{{$}} type Value struct { typ_ unsafe.Pointer @@ -915,7 +914,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %40 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" undef, ptr %29, 0 // CHECK-NEXT: %41 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" %40, i64 2, 1 // CHECK-NEXT: %42 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" %41, i64 2, 2 -// CHECK-NEXT: call void @"main.(*testingT).Errorf"(ptr %0, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 41 }, %"{{.*}}/runtime/internal/runtime.Slice" %42) +// CHECK-NEXT: call void @"main.(*testingT).Errorf"(ptr %0, %"{{.*}}/runtime/internal/runtime.String" { ptr @398, i64 41 }, %"{{.*}}/runtime/internal/runtime.Slice" %42) // CHECK-NEXT: br label %_llgo_1 // CHECK-EMPTY: // CHECK-NEXT: _llgo_5: ; preds = %_llgo_2 @@ -950,7 +949,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %66 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" undef, ptr %55, 0 // CHECK-NEXT: %67 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" %66, i64 2, 1 // CHECK-NEXT: %68 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" %67, i64 2, 2 -// CHECK-NEXT: call void @"main.(*testingT).Errorf"(ptr %0, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 41 }, %"{{.*}}/runtime/internal/runtime.Slice" %68) +// CHECK-NEXT: call void @"main.(*testingT).Errorf"(ptr %0, %"{{.*}}/runtime/internal/runtime.String" { ptr @398, i64 41 }, %"{{.*}}/runtime/internal/runtime.Slice" %68) // CHECK-NEXT: br label %_llgo_1 // CHECK-EMPTY: // CHECK-NEXT: _llgo_7: ; preds = %_llgo_5 @@ -994,7 +993,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %92 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" undef, ptr %85, 0 // CHECK-NEXT: %93 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" %92, i64 2, 1 // CHECK-NEXT: %94 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" %93, i64 2, 2 -// CHECK-NEXT: call void @"main.(*testingT).Errorf"(ptr %0, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 52 }, %"{{.*}}/runtime/internal/runtime.Slice" %94) +// CHECK-NEXT: call void @"main.(*testingT).Errorf"(ptr %0, %"{{.*}}/runtime/internal/runtime.String" { ptr @399, i64 52 }, %"{{.*}}/runtime/internal/runtime.Slice" %94) // CHECK-NEXT: br label %_llgo_9 // CHECK-EMPTY: // CHECK-NEXT: _llgo_9: ; preds = %_llgo_8, %_llgo_7 @@ -1039,7 +1038,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %126 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" undef, ptr %117, 0 // CHECK-NEXT: %127 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" %126, i64 4, 1 // CHECK-NEXT: %128 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" %127, i64 4, 2 -// CHECK-NEXT: call void @"main.(*testingT).Errorf"(ptr %0, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 58 }, %"{{.*}}/runtime/internal/runtime.Slice" %128) +// CHECK-NEXT: call void @"main.(*testingT).Errorf"(ptr %0, %"{{.*}}/runtime/internal/runtime.String" { ptr @391, i64 58 }, %"{{.*}}/runtime/internal/runtime.Slice" %128) // CHECK-NEXT: br label %_llgo_11 // CHECK-EMPTY: // CHECK-NEXT: _llgo_11: ; preds = %_llgo_12, %_llgo_10 @@ -1069,7 +1068,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %144 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" undef, ptr %137, 0 // CHECK-NEXT: %145 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" %144, i64 2, 1 // CHECK-NEXT: %146 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" %145, i64 2, 2 -// CHECK-NEXT: call void @"main.(*testingT).Errorf"(ptr %0, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 53 }, %"{{.*}}/runtime/internal/runtime.Slice" %146) +// CHECK-NEXT: call void @"main.(*testingT).Errorf"(ptr %0, %"{{.*}}/runtime/internal/runtime.String" { ptr @400, i64 53 }, %"{{.*}}/runtime/internal/runtime.Slice" %146) // CHECK-NEXT: br label %_llgo_14 // CHECK-EMPTY: // CHECK-NEXT: _llgo_14: ; preds = %_llgo_13, %_llgo_11 @@ -1114,7 +1113,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %178 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" undef, ptr %169, 0 // CHECK-NEXT: %179 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" %178, i64 4, 1 // CHECK-NEXT: %180 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" %179, i64 4, 2 -// CHECK-NEXT: call void @"main.(*testingT).Errorf"(ptr %0, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 58 }, %"{{.*}}/runtime/internal/runtime.Slice" %180) +// CHECK-NEXT: call void @"main.(*testingT).Errorf"(ptr %0, %"{{.*}}/runtime/internal/runtime.String" { ptr @391, i64 58 }, %"{{.*}}/runtime/internal/runtime.Slice" %180) // CHECK-NEXT: br label %_llgo_16 // CHECK-EMPTY: // CHECK-NEXT: _llgo_16: ; preds = %_llgo_17, %_llgo_15 @@ -1122,7 +1121,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %182 = call %"{{.*}}/runtime/internal/runtime.iface" @reflect.Value.Type(%reflect.Value %147) // CHECK-NEXT: %183 = call ptr @"{{.*}}/runtime/internal/runtime.IfacePtrData"(%"{{.*}}/runtime/internal/runtime.iface" %182) // CHECK-NEXT: %184 = extractvalue %"{{.*}}/runtime/internal/runtime.iface" %182, 0 -// CHECK-NEXT: %185 = getelementptr ptr, ptr %184, i64 {{(21|23)}} +// CHECK-NEXT: %185 = getelementptr ptr, ptr %184, i64 23 // CHECK-NEXT: %186 = load ptr, ptr %185, align 8 // CHECK-NEXT: %187 = insertvalue { ptr, ptr } undef, ptr %186, 0 // CHECK-NEXT: %188 = insertvalue { ptr, ptr } %187, ptr %183, 1 @@ -1165,7 +1164,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %213 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" undef, ptr %200, 0 // CHECK-NEXT: %214 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" %213, i64 4, 1 // CHECK-NEXT: %215 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" %214, i64 4, 2 -// CHECK-NEXT: call void @"main.(*testingT).Errorf"(ptr %0, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 59 }, %"{{.*}}/runtime/internal/runtime.Slice" %215) +// CHECK-NEXT: call void @"main.(*testingT).Errorf"(ptr %0, %"{{.*}}/runtime/internal/runtime.String" { ptr @392, i64 59 }, %"{{.*}}/runtime/internal/runtime.Slice" %215) // CHECK-NEXT: br label %_llgo_19 // CHECK-EMPTY: // CHECK-NEXT: _llgo_19: ; preds = %_llgo_18, %_llgo_16 @@ -1212,7 +1211,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %248 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" undef, ptr %239, 0 // CHECK-NEXT: %249 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" %248, i64 4, 1 // CHECK-NEXT: %250 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" %249, i64 4, 2 -// CHECK-NEXT: call void @"main.(*testingT).Errorf"(ptr %0, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 63 }, %"{{.*}}/runtime/internal/runtime.Slice" %250) +// CHECK-NEXT: call void @"main.(*testingT).Errorf"(ptr %0, %"{{.*}}/runtime/internal/runtime.String" { ptr @393, i64 63 }, %"{{.*}}/runtime/internal/runtime.Slice" %250) // CHECK-NEXT: br label %_llgo_21 // CHECK-EMPTY: // CHECK-NEXT: _llgo_21: ; preds = %_llgo_22, %_llgo_20 @@ -1236,7 +1235,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %260 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" undef, ptr %256, 0 // CHECK-NEXT: %261 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" %260, i64 1, 1 // CHECK-NEXT: %262 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" %261, i64 1, 2 -// CHECK-NEXT: call void @"main.(*testingT).Errorf"(ptr %0, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 35 }, %"{{.*}}/runtime/internal/runtime.Slice" %262) +// CHECK-NEXT: call void @"main.(*testingT).Errorf"(ptr %0, %"{{.*}}/runtime/internal/runtime.String" { ptr @394, i64 35 }, %"{{.*}}/runtime/internal/runtime.Slice" %262) // CHECK-NEXT: br label %_llgo_24 // CHECK-EMPTY: // CHECK-NEXT: _llgo_24: ; preds = %_llgo_23, %_llgo_21 @@ -1253,7 +1252,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %268 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" undef, ptr %264, 0 // CHECK-NEXT: %269 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" %268, i64 1, 1 // CHECK-NEXT: %270 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" %269, i64 1, 2 -// CHECK-NEXT: call void @"main.(*testingT).Errorf"(ptr %0, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 46 }, %"{{.*}}/runtime/internal/runtime.Slice" %270) +// CHECK-NEXT: call void @"main.(*testingT).Errorf"(ptr %0, %"{{.*}}/runtime/internal/runtime.String" { ptr @395, i64 46 }, %"{{.*}}/runtime/internal/runtime.Slice" %270) // CHECK-NEXT: br label %_llgo_26 // CHECK-EMPTY: // CHECK-NEXT: _llgo_26: ; preds = %_llgo_25, %_llgo_24 @@ -1270,7 +1269,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %276 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" undef, ptr %272, 0 // CHECK-NEXT: %277 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" %276, i64 1, 1 // CHECK-NEXT: %278 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" %277, i64 1, 2 -// CHECK-NEXT: call void @"main.(*testingT).Errorf"(ptr %0, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 41 }, %"{{.*}}/runtime/internal/runtime.Slice" %278) +// CHECK-NEXT: call void @"main.(*testingT).Errorf"(ptr %0, %"{{.*}}/runtime/internal/runtime.String" { ptr @396, i64 41 }, %"{{.*}}/runtime/internal/runtime.Slice" %278) // CHECK-NEXT: br label %_llgo_28 // CHECK-EMPTY: // CHECK-NEXT: _llgo_28: ; preds = %_llgo_27, %_llgo_26 @@ -1287,7 +1286,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %284 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" undef, ptr %280, 0 // CHECK-NEXT: %285 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" %284, i64 1, 1 // CHECK-NEXT: %286 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" %285, i64 1, 2 -// CHECK-NEXT: call void @"main.(*testingT).Errorf"(ptr %0, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 46 }, %"{{.*}}/runtime/internal/runtime.Slice" %286) +// CHECK-NEXT: call void @"main.(*testingT).Errorf"(ptr %0, %"{{.*}}/runtime/internal/runtime.String" { ptr @397, i64 46 }, %"{{.*}}/runtime/internal/runtime.Slice" %286) // CHECK-NEXT: br label %_llgo_30 // CHECK-EMPTY: // CHECK-NEXT: _llgo_30: ; preds = %_llgo_29, %_llgo_28 @@ -1306,7 +1305,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %294 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" undef, ptr %290, 0 // CHECK-NEXT: %295 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" %294, i64 1, 1 // CHECK-NEXT: %296 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" %295, i64 1, 2 -// CHECK-NEXT: call void @"main.(*testingT).Errorf"(ptr %0, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 49 }, %"{{.*}}/runtime/internal/runtime.Slice" %296) +// CHECK-NEXT: call void @"main.(*testingT).Errorf"(ptr %0, %"{{.*}}/runtime/internal/runtime.String" { ptr @401, i64 49 }, %"{{.*}}/runtime/internal/runtime.Slice" %296) // CHECK-NEXT: br label %_llgo_32 // CHECK-EMPTY: // CHECK-NEXT: _llgo_32: ; preds = %_llgo_31, %_llgo_30 @@ -1325,7 +1324,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %304 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" undef, ptr %300, 0 // CHECK-NEXT: %305 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" %304, i64 1, 1 // CHECK-NEXT: %306 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" %305, i64 1, 2 -// CHECK-NEXT: call void @"main.(*testingT).Errorf"(ptr %0, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 44 }, %"{{.*}}/runtime/internal/runtime.Slice" %306) +// CHECK-NEXT: call void @"main.(*testingT).Errorf"(ptr %0, %"{{.*}}/runtime/internal/runtime.String" { ptr @402, i64 44 }, %"{{.*}}/runtime/internal/runtime.Slice" %306) // CHECK-NEXT: br label %_llgo_1 // CHECK-EMPTY: // CHECK-NEXT: _llgo_34: ; preds = %_llgo_50, %_llgo_3 @@ -1362,7 +1361,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: _llgo_39: ; preds = %_llgo_41 // CHECK-NEXT: %323 = call ptr @"{{.*}}/runtime/internal/runtime.IfacePtrData"(%"{{.*}}/runtime/internal/runtime.iface" %313) // CHECK-NEXT: %324 = extractvalue %"{{.*}}/runtime/internal/runtime.iface" %313, 0 -// CHECK-NEXT: %325 = getelementptr ptr, ptr %324, i64 {{(21|23)}} +// CHECK-NEXT: %325 = getelementptr ptr, ptr %324, i64 23 // CHECK-NEXT: %326 = load ptr, ptr %325, align 8 // CHECK-NEXT: %327 = insertvalue { ptr, ptr } undef, ptr %326, 0 // CHECK-NEXT: %328 = insertvalue { ptr, ptr } %327, ptr %323, 1 @@ -1403,7 +1402,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: _llgo_42: ; preds = %_llgo_39 // CHECK-NEXT: %351 = call ptr @"{{.*}}/runtime/internal/runtime.IfacePtrData"(%"{{.*}}/runtime/internal/runtime.iface" %313) // CHECK-NEXT: %352 = extractvalue %"{{.*}}/runtime/internal/runtime.iface" %313, 0 -// CHECK-NEXT: %353 = getelementptr ptr, ptr %352, i64 {{(28|31)}} +// CHECK-NEXT: %353 = getelementptr ptr, ptr %352, i64 31 // CHECK-NEXT: %354 = load ptr, ptr %353, align 8 // CHECK-NEXT: %355 = insertvalue { ptr, ptr } undef, ptr %354, 0 // CHECK-NEXT: %356 = insertvalue { ptr, ptr } %355, ptr %351, 1 @@ -1460,7 +1459,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %389 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" undef, ptr %369, 0 // CHECK-NEXT: %390 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" %389, i64 5, 1 // CHECK-NEXT: %391 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" %390, i64 5, 2 -// CHECK-NEXT: call void @"main.(*testingT).Errorf"(ptr %0, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 41 }, %"{{.*}}/runtime/internal/runtime.Slice" %391) +// CHECK-NEXT: call void @"main.(*testingT).Errorf"(ptr %0, %"{{.*}}/runtime/internal/runtime.String" { ptr @403, i64 41 }, %"{{.*}}/runtime/internal/runtime.Slice" %391) // CHECK-NEXT: br label %_llgo_37 // CHECK-EMPTY: // CHECK-NEXT: _llgo_45: ; preds = %_llgo_34 @@ -1522,7 +1521,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %12 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" undef, ptr %5, 0 // CHECK-NEXT: %13 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" %12, i64 2, 1 // CHECK-NEXT: %14 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" %13, i64 2, 2 -// CHECK-NEXT: call void @"main.(*testingT).Errorf"(ptr %0, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 47 }, %"{{.*}}/runtime/internal/runtime.Slice" %14) +// CHECK-NEXT: call void @"main.(*testingT).Errorf"(ptr %0, %"{{.*}}/runtime/internal/runtime.String" { ptr @404, i64 47 }, %"{{.*}}/runtime/internal/runtime.Slice" %14) // CHECK-NEXT: br label %_llgo_2 // CHECK-EMPTY: // CHECK-NEXT: _llgo_2: ; preds = %_llgo_1, %_llgo_0 @@ -1560,7 +1559,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %36 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" undef, ptr %29, 0 // CHECK-NEXT: %37 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" %36, i64 2, 1 // CHECK-NEXT: %38 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" %37, i64 2, 2 -// CHECK-NEXT: call void @"main.(*testingT).Errorf"(ptr %0, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 40 }, %"{{.*}}/runtime/internal/runtime.Slice" %38) +// CHECK-NEXT: call void @"main.(*testingT).Errorf"(ptr %0, %"{{.*}}/runtime/internal/runtime.String" { ptr @407, i64 40 }, %"{{.*}}/runtime/internal/runtime.Slice" %38) // CHECK-NEXT: br label %_llgo_4 // CHECK-EMPTY: // CHECK-NEXT: _llgo_4: ; preds = %_llgo_3, %_llgo_5 @@ -1574,7 +1573,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: br i1 %42, label %_llgo_3, label %_llgo_4 // CHECK-EMPTY: // CHECK-NEXT: _llgo_6: ; preds = %_llgo_2 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr %27, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 7 }, %"{{.*}}/runtime/internal/runtime.String" zeroinitializer) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr null, ptr %27, ptr @_llgo_float32, %"{{.*}}/runtime/internal/runtime.String" zeroinitializer) // CHECK-NEXT: unreachable // CHECK-NEXT: } @@ -1608,7 +1607,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: br i1 %22, label %_llgo_2, label %_llgo_1 // CHECK-EMPTY: // CHECK-NEXT: _llgo_1: ; preds = %_llgo_0 -// CHECK-NEXT: call void @"main.(*testingT).Errorf"(ptr %0, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 40 }, %"{{.*}}/runtime/internal/runtime.Slice" zeroinitializer) +// CHECK-NEXT: call void @"main.(*testingT).Errorf"(ptr %0, %"{{.*}}/runtime/internal/runtime.String" { ptr @408, i64 40 }, %"{{.*}}/runtime/internal/runtime.Slice" zeroinitializer) // CHECK-NEXT: br label %_llgo_2 // CHECK-EMPTY: // CHECK-NEXT: _llgo_2: ; preds = %_llgo_1, %_llgo_0 @@ -1618,7 +1617,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: br i1 %25, label %_llgo_3, label %_llgo_4 // CHECK-EMPTY: // CHECK-NEXT: _llgo_3: ; preds = %_llgo_2 -// CHECK-NEXT: call void @"main.(*testingT).Errorf"(ptr %0, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 57 }, %"{{.*}}/runtime/internal/runtime.Slice" zeroinitializer) +// CHECK-NEXT: call void @"main.(*testingT).Errorf"(ptr %0, %"{{.*}}/runtime/internal/runtime.String" { ptr @409, i64 57 }, %"{{.*}}/runtime/internal/runtime.Slice" zeroinitializer) // CHECK-NEXT: br label %_llgo_4 // CHECK-EMPTY: // CHECK-NEXT: _llgo_4: ; preds = %_llgo_3, %_llgo_2 @@ -1628,7 +1627,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %28 = getelementptr inbounds { ptr, ptr }, ptr %26, i32 0, i32 1 // CHECK-NEXT: store ptr %8, ptr %28, align 8 // CHECK-NEXT: %29 = insertvalue { ptr, ptr } { ptr @"main.TestConvertPanic$1", ptr undef }, ptr %26, 1 -// CHECK-NEXT: call void @main.shouldPanic(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 77 }, { ptr, ptr } %29) +// CHECK-NEXT: call void @main.shouldPanic(%"{{.*}}/runtime/internal/runtime.String" { ptr @410, i64 77 }, { ptr, ptr } %29) // CHECK-NEXT: %30 = load %reflect.Value, ptr %4, align 8 // CHECK-NEXT: %31 = load %"{{.*}}/runtime/internal/runtime.iface", ptr %8, align 8 // CHECK-NEXT: %32 = call ptr @"{{.*}}/runtime/internal/runtime.IfacePtrData"(%"{{.*}}/runtime/internal/runtime.iface" %31) @@ -1644,7 +1643,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: br i1 %41, label %_llgo_5, label %_llgo_6 // CHECK-EMPTY: // CHECK-NEXT: _llgo_5: ; preds = %_llgo_4 -// CHECK-NEXT: call void @"main.(*testingT).Errorf"(ptr %0, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 56 }, %"{{.*}}/runtime/internal/runtime.Slice" zeroinitializer) +// CHECK-NEXT: call void @"main.(*testingT).Errorf"(ptr %0, %"{{.*}}/runtime/internal/runtime.String" { ptr @411, i64 56 }, %"{{.*}}/runtime/internal/runtime.Slice" zeroinitializer) // CHECK-NEXT: br label %_llgo_6 // CHECK-EMPTY: // CHECK-NEXT: _llgo_6: ; preds = %_llgo_5, %_llgo_4 @@ -1654,7 +1653,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %44 = getelementptr inbounds { ptr, ptr }, ptr %42, i32 0, i32 1 // CHECK-NEXT: store ptr %8, ptr %44, align 8 // CHECK-NEXT: %45 = insertvalue { ptr, ptr } { ptr @"main.TestConvertPanic$2", ptr undef }, ptr %42, 1 -// CHECK-NEXT: call void @main.shouldPanic(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 66 }, { ptr, ptr } %45) +// CHECK-NEXT: call void @main.shouldPanic(%"{{.*}}/runtime/internal/runtime.String" { ptr @412, i64 66 }, { ptr, ptr } %45) // CHECK-NEXT: ret void // CHECK-NEXT: } @@ -1708,7 +1707,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: br i1 %10, label %_llgo_1, label %_llgo_2 // CHECK-EMPTY: // CHECK-NEXT: _llgo_1: ; preds = %_llgo_0 -// CHECK-NEXT: call void @"main.(*testingT).Fatalf"(ptr %0, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 65 }, %"{{.*}}/runtime/internal/runtime.Slice" zeroinitializer) +// CHECK-NEXT: call void @"main.(*testingT).Fatalf"(ptr %0, %"{{.*}}/runtime/internal/runtime.String" { ptr @414, i64 65 }, %"{{.*}}/runtime/internal/runtime.Slice" zeroinitializer) // CHECK-NEXT: br label %_llgo_2 // CHECK-EMPTY: // CHECK-NEXT: _llgo_2: ; preds = %_llgo_1, %_llgo_0 @@ -1765,7 +1764,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %34 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" undef, ptr %27, 0 // CHECK-NEXT: %35 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" %34, i64 2, 1 // CHECK-NEXT: %36 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" %35, i64 2, 2 -// CHECK-NEXT: call void @"main.(*testingT).Fatalf"(ptr %0, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 52 }, %"{{.*}}/runtime/internal/runtime.Slice" %36) +// CHECK-NEXT: call void @"main.(*testingT).Fatalf"(ptr %0, %"{{.*}}/runtime/internal/runtime.String" { ptr @415, i64 52 }, %"{{.*}}/runtime/internal/runtime.Slice" %36) // CHECK-NEXT: br label %_llgo_6 // CHECK-NEXT: } @@ -2267,7 +2266,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %346 = call %reflect.Value %__llgo_funcval_code45(ptr {{(nest|swiftself)}} %344, %"{{.*}}/runtime/internal/runtime.eface" %343) // CHECK-NEXT: store %reflect.Value %339, ptr %333, align 8 // CHECK-NEXT: store %reflect.Value %346, ptr %340, align 8 -// CHECK-NEXT: %347 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %1, i64 {{(21|23)}} +// CHECK-NEXT: %347 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %1, i64 23 // CHECK-NEXT: %348 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %347, i32 0, i32 0 // CHECK-NEXT: %349 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %350 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 4) @@ -2435,7 +2434,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %466 = call %reflect.Value %__llgo_funcval_code61(ptr {{(nest|swiftself)}} %464, %"{{.*}}/runtime/internal/runtime.eface" %463) // CHECK-NEXT: store %reflect.Value %459, ptr %453, align 8 // CHECK-NEXT: store %reflect.Value %466, ptr %460, align 8 -// CHECK-NEXT: %467 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %1, i64 {{(28|31)}} +// CHECK-NEXT: %467 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %1, i64 31 // CHECK-NEXT: %468 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %467, i32 0, i32 0 // CHECK-NEXT: %469 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %470 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 1) @@ -5463,7 +5462,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %2628 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %2627, i32 0, i32 0 // CHECK-NEXT: %2629 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %2630 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 5 }, ptr %2630, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @420, i64 5 }, ptr %2630, align 8 // CHECK-NEXT: %2631 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %2630, 1 // CHECK-NEXT: %2632 = extractvalue { ptr, ptr } %2629, 1 // CHECK-NEXT: %2633 = extractvalue { ptr, ptr } %2629, 0 @@ -5472,7 +5471,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %2635 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %2627, i32 0, i32 1 // CHECK-NEXT: %2636 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %2637 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 5 }, ptr %2637, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @420, i64 5 }, ptr %2637, align 8 // CHECK-NEXT: %2638 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %2637, 1 // CHECK-NEXT: %2639 = extractvalue { ptr, ptr } %2636, 1 // CHECK-NEXT: %2640 = extractvalue { ptr, ptr } %2636, 0 @@ -5484,7 +5483,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %2643 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %2642, i32 0, i32 0 // CHECK-NEXT: %2644 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %2645 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 6 }, ptr %2645, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @421, i64 6 }, ptr %2645, align 8 // CHECK-NEXT: %2646 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %2645, 1 // CHECK-NEXT: %2647 = extractvalue { ptr, ptr } %2644, 1 // CHECK-NEXT: %2648 = extractvalue { ptr, ptr } %2644, 0 @@ -5492,7 +5491,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %2649 = call %reflect.Value %__llgo_funcval_code352(ptr {{(nest|swiftself)}} %2647, %"{{.*}}/runtime/internal/runtime.eface" %2646) // CHECK-NEXT: %2650 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %2642, i32 0, i32 1 // CHECK-NEXT: %2651 = load { ptr, ptr }, ptr @main.V, align 8 -// CHECK-NEXT: %2652 = call %"{{.*}}/runtime/internal/runtime.Slice" @"{{.*}}/runtime/internal/runtime.StringToBytes"(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 6 }) +// CHECK-NEXT: %2652 = call %"{{.*}}/runtime/internal/runtime.Slice" @"{{.*}}/runtime/internal/runtime.StringToBytes"(%"{{.*}}/runtime/internal/runtime.String" { ptr @421, i64 6 }) // CHECK-NEXT: %2653 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 24) // CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.Slice" %2652, ptr %2653, align 8 // CHECK-NEXT: %2654 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @"[]_llgo_uint8", ptr undef }, ptr %2653, 1 @@ -5505,7 +5504,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %2658 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %1, i64 177 // CHECK-NEXT: %2659 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %2658, i32 0, i32 0 // CHECK-NEXT: %2660 = load { ptr, ptr }, ptr @main.V, align 8 -// CHECK-NEXT: %2661 = call %"{{.*}}/runtime/internal/runtime.Slice" @"{{.*}}/runtime/internal/runtime.StringToBytes"(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 6 }) +// CHECK-NEXT: %2661 = call %"{{.*}}/runtime/internal/runtime.Slice" @"{{.*}}/runtime/internal/runtime.StringToBytes"(%"{{.*}}/runtime/internal/runtime.String" { ptr @422, i64 6 }) // CHECK-NEXT: %2662 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 24) // CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.Slice" %2661, ptr %2662, align 8 // CHECK-NEXT: %2663 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @"[]_llgo_uint8", ptr undef }, ptr %2662, 1 @@ -5516,7 +5515,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %2667 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %2658, i32 0, i32 1 // CHECK-NEXT: %2668 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %2669 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 6 }, ptr %2669, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @422, i64 6 }, ptr %2669, align 8 // CHECK-NEXT: %2670 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %2669, 1 // CHECK-NEXT: %2671 = extractvalue { ptr, ptr } %2668, 1 // CHECK-NEXT: %2672 = extractvalue { ptr, ptr } %2668, 0 @@ -5527,7 +5526,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %2674 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %1, i64 178 // CHECK-NEXT: %2675 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %2674, i32 0, i32 0 // CHECK-NEXT: %2676 = load { ptr, ptr }, ptr @main.V, align 8 -// CHECK-NEXT: %2677 = call %"{{.*}}/runtime/internal/runtime.Slice" @"{{.*}}/runtime/internal/runtime.StringToBytes"(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 6 }) +// CHECK-NEXT: %2677 = call %"{{.*}}/runtime/internal/runtime.Slice" @"{{.*}}/runtime/internal/runtime.StringToBytes"(%"{{.*}}/runtime/internal/runtime.String" { ptr @423, i64 6 }) // CHECK-NEXT: %2678 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 24) // CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.Slice" %2677, ptr %2678, align 8 // CHECK-NEXT: %2679 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @"[]_llgo_uint8", ptr undef }, ptr %2678, 1 @@ -5537,7 +5536,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %2682 = call %reflect.Value %__llgo_funcval_code356(ptr {{(nest|swiftself)}} %2680, %"{{.*}}/runtime/internal/runtime.eface" %2679) // CHECK-NEXT: %2683 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %2674, i32 0, i32 1 // CHECK-NEXT: %2684 = load { ptr, ptr }, ptr @main.V, align 8 -// CHECK-NEXT: %2685 = call %"{{.*}}/runtime/internal/runtime.Slice" @"{{.*}}/runtime/internal/runtime.StringToBytes"(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 6 }) +// CHECK-NEXT: %2685 = call %"{{.*}}/runtime/internal/runtime.Slice" @"{{.*}}/runtime/internal/runtime.StringToBytes"(%"{{.*}}/runtime/internal/runtime.String" { ptr @423, i64 6 }) // CHECK-NEXT: %2686 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 24) // CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.Slice" %2685, ptr %2686, align 8 // CHECK-NEXT: %2687 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @"[]_llgo_uint8", ptr undef }, ptr %2686, 1 @@ -5551,7 +5550,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %2692 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %2691, i32 0, i32 0 // CHECK-NEXT: %2693 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %2694 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 8 }, ptr %2694, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @424, i64 8 }, ptr %2694, align 8 // CHECK-NEXT: %2695 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %2694, 1 // CHECK-NEXT: %2696 = extractvalue { ptr, ptr } %2693, 1 // CHECK-NEXT: %2697 = extractvalue { ptr, ptr } %2693, 0 @@ -5559,7 +5558,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %2698 = call %reflect.Value %__llgo_funcval_code358(ptr {{(nest|swiftself)}} %2696, %"{{.*}}/runtime/internal/runtime.eface" %2695) // CHECK-NEXT: %2699 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %2691, i32 0, i32 1 // CHECK-NEXT: %2700 = load { ptr, ptr }, ptr @main.V, align 8 -// CHECK-NEXT: %2701 = call %"{{.*}}/runtime/internal/runtime.Slice" @"{{.*}}/runtime/internal/runtime.StringToRunes"(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 8 }) +// CHECK-NEXT: %2701 = call %"{{.*}}/runtime/internal/runtime.Slice" @"{{.*}}/runtime/internal/runtime.StringToRunes"(%"{{.*}}/runtime/internal/runtime.String" { ptr @424, i64 8 }) // CHECK-NEXT: %2702 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 24) // CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.Slice" %2701, ptr %2702, align 8 // CHECK-NEXT: %2703 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @"[]_llgo_int32", ptr undef }, ptr %2702, 1 @@ -5572,7 +5571,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %2707 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %1, i64 180 // CHECK-NEXT: %2708 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %2707, i32 0, i32 0 // CHECK-NEXT: %2709 = load { ptr, ptr }, ptr @main.V, align 8 -// CHECK-NEXT: %2710 = call %"{{.*}}/runtime/internal/runtime.Slice" @"{{.*}}/runtime/internal/runtime.StringToRunes"(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 8 }) +// CHECK-NEXT: %2710 = call %"{{.*}}/runtime/internal/runtime.Slice" @"{{.*}}/runtime/internal/runtime.StringToRunes"(%"{{.*}}/runtime/internal/runtime.String" { ptr @425, i64 8 }) // CHECK-NEXT: %2711 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 24) // CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.Slice" %2710, ptr %2711, align 8 // CHECK-NEXT: %2712 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @"[]_llgo_int32", ptr undef }, ptr %2711, 1 @@ -5583,7 +5582,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %2716 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %2707, i32 0, i32 1 // CHECK-NEXT: %2717 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %2718 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 8 }, ptr %2718, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @425, i64 8 }, ptr %2718, align 8 // CHECK-NEXT: %2719 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %2718, 1 // CHECK-NEXT: %2720 = extractvalue { ptr, ptr } %2717, 1 // CHECK-NEXT: %2721 = extractvalue { ptr, ptr } %2717, 0 @@ -5594,7 +5593,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %2723 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %1, i64 181 // CHECK-NEXT: %2724 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %2723, i32 0, i32 0 // CHECK-NEXT: %2725 = load { ptr, ptr }, ptr @main.V, align 8 -// CHECK-NEXT: %2726 = call %"{{.*}}/runtime/internal/runtime.Slice" @"{{.*}}/runtime/internal/runtime.StringToRunes"(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 17 }) +// CHECK-NEXT: %2726 = call %"{{.*}}/runtime/internal/runtime.Slice" @"{{.*}}/runtime/internal/runtime.StringToRunes"(%"{{.*}}/runtime/internal/runtime.String" { ptr @426, i64 17 }) // CHECK-NEXT: %2727 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 24) // CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.Slice" %2726, ptr %2727, align 8 // CHECK-NEXT: %2728 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @"[]_llgo_int32", ptr undef }, ptr %2727, 1 @@ -5604,7 +5603,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %2731 = call %reflect.Value %__llgo_funcval_code362(ptr {{(nest|swiftself)}} %2729, %"{{.*}}/runtime/internal/runtime.eface" %2728) // CHECK-NEXT: %2732 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %2723, i32 0, i32 1 // CHECK-NEXT: %2733 = load { ptr, ptr }, ptr @main.V, align 8 -// CHECK-NEXT: %2734 = call %"{{.*}}/runtime/internal/runtime.Slice" @"{{.*}}/runtime/internal/runtime.StringToRunes"(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 17 }) +// CHECK-NEXT: %2734 = call %"{{.*}}/runtime/internal/runtime.Slice" @"{{.*}}/runtime/internal/runtime.StringToRunes"(%"{{.*}}/runtime/internal/runtime.String" { ptr @426, i64 17 }) // CHECK-NEXT: %2735 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 24) // CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.Slice" %2734, ptr %2735, align 8 // CHECK-NEXT: %2736 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @"[]_llgo_int32", ptr undef }, ptr %2735, 1 @@ -5627,7 +5626,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %2748 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %2740, i32 0, i32 1 // CHECK-NEXT: %2749 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %2750 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 1 }, ptr %2750, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @427, i64 1 }, ptr %2750, align 8 // CHECK-NEXT: %2751 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %2750, 1 // CHECK-NEXT: %2752 = extractvalue { ptr, ptr } %2749, 1 // CHECK-NEXT: %2753 = extractvalue { ptr, ptr } %2749, 0 @@ -5648,7 +5647,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %2763 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %2755, i32 0, i32 1 // CHECK-NEXT: %2764 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %2765 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 1 }, ptr %2765, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @427, i64 1 }, ptr %2765, align 8 // CHECK-NEXT: %2766 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %2765, 1 // CHECK-NEXT: %2767 = extractvalue { ptr, ptr } %2764, 1 // CHECK-NEXT: %2768 = extractvalue { ptr, ptr } %2764, 0 @@ -5669,7 +5668,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %2778 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %2770, i32 0, i32 1 // CHECK-NEXT: %2779 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %2780 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 1 }, ptr %2780, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @427, i64 1 }, ptr %2780, align 8 // CHECK-NEXT: %2781 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %2780, 1 // CHECK-NEXT: %2782 = extractvalue { ptr, ptr } %2779, 1 // CHECK-NEXT: %2783 = extractvalue { ptr, ptr } %2779, 0 @@ -5690,7 +5689,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %2793 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %2785, i32 0, i32 1 // CHECK-NEXT: %2794 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %2795 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 1 }, ptr %2795, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @427, i64 1 }, ptr %2795, align 8 // CHECK-NEXT: %2796 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %2795, 1 // CHECK-NEXT: %2797 = extractvalue { ptr, ptr } %2794, 1 // CHECK-NEXT: %2798 = extractvalue { ptr, ptr } %2794, 0 @@ -5711,7 +5710,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %2808 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %2800, i32 0, i32 1 // CHECK-NEXT: %2809 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %2810 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 1 }, ptr %2810, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @427, i64 1 }, ptr %2810, align 8 // CHECK-NEXT: %2811 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %2810, 1 // CHECK-NEXT: %2812 = extractvalue { ptr, ptr } %2809, 1 // CHECK-NEXT: %2813 = extractvalue { ptr, ptr } %2809, 0 @@ -5732,7 +5731,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %2823 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %2815, i32 0, i32 1 // CHECK-NEXT: %2824 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %2825 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 1 }, ptr %2825, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @427, i64 1 }, ptr %2825, align 8 // CHECK-NEXT: %2826 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %2825, 1 // CHECK-NEXT: %2827 = extractvalue { ptr, ptr } %2824, 1 // CHECK-NEXT: %2828 = extractvalue { ptr, ptr } %2824, 0 @@ -5753,7 +5752,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %2838 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %2830, i32 0, i32 1 // CHECK-NEXT: %2839 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %2840 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 1 }, ptr %2840, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @427, i64 1 }, ptr %2840, align 8 // CHECK-NEXT: %2841 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %2840, 1 // CHECK-NEXT: %2842 = extractvalue { ptr, ptr } %2839, 1 // CHECK-NEXT: %2843 = extractvalue { ptr, ptr } %2839, 0 @@ -5774,7 +5773,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %2853 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %2845, i32 0, i32 1 // CHECK-NEXT: %2854 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %2855 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 1 }, ptr %2855, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @427, i64 1 }, ptr %2855, align 8 // CHECK-NEXT: %2856 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %2855, 1 // CHECK-NEXT: %2857 = extractvalue { ptr, ptr } %2854, 1 // CHECK-NEXT: %2858 = extractvalue { ptr, ptr } %2854, 0 @@ -5795,7 +5794,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %2868 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %2860, i32 0, i32 1 // CHECK-NEXT: %2869 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %2870 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 1 }, ptr %2870, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @427, i64 1 }, ptr %2870, align 8 // CHECK-NEXT: %2871 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %2870, 1 // CHECK-NEXT: %2872 = extractvalue { ptr, ptr } %2869, 1 // CHECK-NEXT: %2873 = extractvalue { ptr, ptr } %2869, 0 @@ -5816,7 +5815,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %2883 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %2875, i32 0, i32 1 // CHECK-NEXT: %2884 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %2885 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 1 }, ptr %2885, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @427, i64 1 }, ptr %2885, align 8 // CHECK-NEXT: %2886 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %2885, 1 // CHECK-NEXT: %2887 = extractvalue { ptr, ptr } %2884, 1 // CHECK-NEXT: %2888 = extractvalue { ptr, ptr } %2884, 0 @@ -5837,7 +5836,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %2898 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %2890, i32 0, i32 1 // CHECK-NEXT: %2899 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %2900 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 1 }, ptr %2900, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @427, i64 1 }, ptr %2900, align 8 // CHECK-NEXT: %2901 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %2900, 1 // CHECK-NEXT: %2902 = extractvalue { ptr, ptr } %2899, 1 // CHECK-NEXT: %2903 = extractvalue { ptr, ptr } %2899, 0 @@ -5858,7 +5857,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %2913 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %2905, i32 0, i32 1 // CHECK-NEXT: %2914 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %2915 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 3 }, ptr %2915, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @428, i64 3 }, ptr %2915, align 8 // CHECK-NEXT: %2916 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %2915, 1 // CHECK-NEXT: %2917 = extractvalue { ptr, ptr } %2914, 1 // CHECK-NEXT: %2918 = extractvalue { ptr, ptr } %2914, 0 @@ -5879,7 +5878,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %2928 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %2920, i32 0, i32 1 // CHECK-NEXT: %2929 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %2930 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 3 }, ptr %2930, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @428, i64 3 }, ptr %2930, align 8 // CHECK-NEXT: %2931 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %2930, 1 // CHECK-NEXT: %2932 = extractvalue { ptr, ptr } %2929, 1 // CHECK-NEXT: %2933 = extractvalue { ptr, ptr } %2929, 0 @@ -5900,7 +5899,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %2943 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %2935, i32 0, i32 1 // CHECK-NEXT: %2944 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %2945 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 3 }, ptr %2945, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @428, i64 3 }, ptr %2945, align 8 // CHECK-NEXT: %2946 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %2945, 1 // CHECK-NEXT: %2947 = extractvalue { ptr, ptr } %2944, 1 // CHECK-NEXT: %2948 = extractvalue { ptr, ptr } %2944, 0 @@ -5921,7 +5920,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %2958 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %2950, i32 0, i32 1 // CHECK-NEXT: %2959 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %2960 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 3 }, ptr %2960, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @428, i64 3 }, ptr %2960, align 8 // CHECK-NEXT: %2961 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %2960, 1 // CHECK-NEXT: %2962 = extractvalue { ptr, ptr } %2959, 1 // CHECK-NEXT: %2963 = extractvalue { ptr, ptr } %2959, 0 @@ -5942,7 +5941,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %2973 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %2965, i32 0, i32 1 // CHECK-NEXT: %2974 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %2975 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 3 }, ptr %2975, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @428, i64 3 }, ptr %2975, align 8 // CHECK-NEXT: %2976 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %2975, 1 // CHECK-NEXT: %2977 = extractvalue { ptr, ptr } %2974, 1 // CHECK-NEXT: %2978 = extractvalue { ptr, ptr } %2974, 0 @@ -5963,7 +5962,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %2988 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %2980, i32 0, i32 1 // CHECK-NEXT: %2989 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %2990 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 3 }, ptr %2990, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @428, i64 3 }, ptr %2990, align 8 // CHECK-NEXT: %2991 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %2990, 1 // CHECK-NEXT: %2992 = extractvalue { ptr, ptr } %2989, 1 // CHECK-NEXT: %2993 = extractvalue { ptr, ptr } %2989, 0 @@ -5984,7 +5983,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %3003 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %2995, i32 0, i32 1 // CHECK-NEXT: %3004 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %3005 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 3 }, ptr %3005, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @428, i64 3 }, ptr %3005, align 8 // CHECK-NEXT: %3006 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %3005, 1 // CHECK-NEXT: %3007 = extractvalue { ptr, ptr } %3004, 1 // CHECK-NEXT: %3008 = extractvalue { ptr, ptr } %3004, 0 @@ -6005,7 +6004,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %3018 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %3010, i32 0, i32 1 // CHECK-NEXT: %3019 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %3020 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 3 }, ptr %3020, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @428, i64 3 }, ptr %3020, align 8 // CHECK-NEXT: %3021 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %3020, 1 // CHECK-NEXT: %3022 = extractvalue { ptr, ptr } %3019, 1 // CHECK-NEXT: %3023 = extractvalue { ptr, ptr } %3019, 0 @@ -6026,7 +6025,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %3033 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %3025, i32 0, i32 1 // CHECK-NEXT: %3034 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %3035 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 3 }, ptr %3035, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @428, i64 3 }, ptr %3035, align 8 // CHECK-NEXT: %3036 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %3035, 1 // CHECK-NEXT: %3037 = extractvalue { ptr, ptr } %3034, 1 // CHECK-NEXT: %3038 = extractvalue { ptr, ptr } %3034, 0 @@ -6047,7 +6046,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %3048 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %3040, i32 0, i32 1 // CHECK-NEXT: %3049 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %3050 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 3 }, ptr %3050, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @428, i64 3 }, ptr %3050, align 8 // CHECK-NEXT: %3051 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %3050, 1 // CHECK-NEXT: %3052 = extractvalue { ptr, ptr } %3049, 1 // CHECK-NEXT: %3053 = extractvalue { ptr, ptr } %3049, 0 @@ -6068,7 +6067,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %3063 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %3055, i32 0, i32 1 // CHECK-NEXT: %3064 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %3065 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 3 }, ptr %3065, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @428, i64 3 }, ptr %3065, align 8 // CHECK-NEXT: %3066 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %3065, 1 // CHECK-NEXT: %3067 = extractvalue { ptr, ptr } %3064, 1 // CHECK-NEXT: %3068 = extractvalue { ptr, ptr } %3064, 0 @@ -6089,7 +6088,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %3078 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %3070, i32 0, i32 1 // CHECK-NEXT: %3079 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %3080 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 3 }, ptr %3080, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @428, i64 3 }, ptr %3080, align 8 // CHECK-NEXT: %3081 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %3080, 1 // CHECK-NEXT: %3082 = extractvalue { ptr, ptr } %3079, 1 // CHECK-NEXT: %3083 = extractvalue { ptr, ptr } %3079, 0 @@ -6101,7 +6100,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %3086 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %3085, i32 0, i32 0 // CHECK-NEXT: %3087 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %3088 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 5 }, ptr %3088, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @420, i64 5 }, ptr %3088, align 8 // CHECK-NEXT: %3089 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_main.MyString, ptr undef }, ptr %3088, 1 // CHECK-NEXT: %3090 = extractvalue { ptr, ptr } %3087, 1 // CHECK-NEXT: %3091 = extractvalue { ptr, ptr } %3087, 0 @@ -6110,7 +6109,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %3093 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %3085, i32 0, i32 1 // CHECK-NEXT: %3094 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %3095 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 5 }, ptr %3095, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @420, i64 5 }, ptr %3095, align 8 // CHECK-NEXT: %3096 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %3095, 1 // CHECK-NEXT: %3097 = extractvalue { ptr, ptr } %3094, 1 // CHECK-NEXT: %3098 = extractvalue { ptr, ptr } %3094, 0 @@ -6122,7 +6121,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %3101 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %3100, i32 0, i32 0 // CHECK-NEXT: %3102 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %3103 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 5 }, ptr %3103, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @420, i64 5 }, ptr %3103, align 8 // CHECK-NEXT: %3104 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %3103, 1 // CHECK-NEXT: %3105 = extractvalue { ptr, ptr } %3102, 1 // CHECK-NEXT: %3106 = extractvalue { ptr, ptr } %3102, 0 @@ -6131,7 +6130,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %3108 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %3100, i32 0, i32 1 // CHECK-NEXT: %3109 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %3110 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 5 }, ptr %3110, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @420, i64 5 }, ptr %3110, align 8 // CHECK-NEXT: %3111 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_main.MyString, ptr undef }, ptr %3110, 1 // CHECK-NEXT: %3112 = extractvalue { ptr, ptr } %3109, 1 // CHECK-NEXT: %3113 = extractvalue { ptr, ptr } %3109, 0 @@ -6143,7 +6142,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %3116 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %3115, i32 0, i32 0 // CHECK-NEXT: %3117 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %3118 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 5 }, ptr %3118, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @420, i64 5 }, ptr %3118, align 8 // CHECK-NEXT: %3119 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %3118, 1 // CHECK-NEXT: %3120 = extractvalue { ptr, ptr } %3117, 1 // CHECK-NEXT: %3121 = extractvalue { ptr, ptr } %3117, 0 @@ -6152,7 +6151,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %3123 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %3115, i32 0, i32 1 // CHECK-NEXT: %3124 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %3125 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 5 }, ptr %3125, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @420, i64 5 }, ptr %3125, align 8 // CHECK-NEXT: %3126 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %3125, 1 // CHECK-NEXT: %3127 = extractvalue { ptr, ptr } %3124, 1 // CHECK-NEXT: %3128 = extractvalue { ptr, ptr } %3124, 0 @@ -6164,7 +6163,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %3131 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %3130, i32 0, i32 0 // CHECK-NEXT: %3132 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %3133 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 5 }, ptr %3133, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @420, i64 5 }, ptr %3133, align 8 // CHECK-NEXT: %3134 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_main.MyString, ptr undef }, ptr %3133, 1 // CHECK-NEXT: %3135 = extractvalue { ptr, ptr } %3132, 1 // CHECK-NEXT: %3136 = extractvalue { ptr, ptr } %3132, 0 @@ -6173,7 +6172,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %3138 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %3130, i32 0, i32 1 // CHECK-NEXT: %3139 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %3140 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 5 }, ptr %3140, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @420, i64 5 }, ptr %3140, align 8 // CHECK-NEXT: %3141 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_main.MyString, ptr undef }, ptr %3140, 1 // CHECK-NEXT: %3142 = extractvalue { ptr, ptr } %3139, 1 // CHECK-NEXT: %3143 = extractvalue { ptr, ptr } %3139, 0 @@ -6185,7 +6184,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %3146 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %3145, i32 0, i32 0 // CHECK-NEXT: %3147 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %3148 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 6 }, ptr %3148, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @421, i64 6 }, ptr %3148, align 8 // CHECK-NEXT: %3149 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_main.MyString, ptr undef }, ptr %3148, 1 // CHECK-NEXT: %3150 = extractvalue { ptr, ptr } %3147, 1 // CHECK-NEXT: %3151 = extractvalue { ptr, ptr } %3147, 0 @@ -6193,7 +6192,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %3152 = call %reflect.Value %__llgo_funcval_code418(ptr {{(nest|swiftself)}} %3150, %"{{.*}}/runtime/internal/runtime.eface" %3149) // CHECK-NEXT: %3153 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %3145, i32 0, i32 1 // CHECK-NEXT: %3154 = load { ptr, ptr }, ptr @main.V, align 8 -// CHECK-NEXT: %3155 = call %"{{.*}}/runtime/internal/runtime.Slice" @"{{.*}}/runtime/internal/runtime.StringToBytes"(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 6 }) +// CHECK-NEXT: %3155 = call %"{{.*}}/runtime/internal/runtime.Slice" @"{{.*}}/runtime/internal/runtime.StringToBytes"(%"{{.*}}/runtime/internal/runtime.String" { ptr @421, i64 6 }) // CHECK-NEXT: %3156 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 24) // CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.Slice" %3155, ptr %3156, align 8 // CHECK-NEXT: %3157 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @"[]_llgo_uint8", ptr undef }, ptr %3156, 1 @@ -6206,7 +6205,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %3161 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %1, i64 210 // CHECK-NEXT: %3162 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %3161, i32 0, i32 0 // CHECK-NEXT: %3163 = load { ptr, ptr }, ptr @main.V, align 8 -// CHECK-NEXT: %3164 = call %"{{.*}}/runtime/internal/runtime.Slice" @"{{.*}}/runtime/internal/runtime.StringToBytes"(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 6 }) +// CHECK-NEXT: %3164 = call %"{{.*}}/runtime/internal/runtime.Slice" @"{{.*}}/runtime/internal/runtime.StringToBytes"(%"{{.*}}/runtime/internal/runtime.String" { ptr @422, i64 6 }) // CHECK-NEXT: %3165 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 24) // CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.Slice" %3164, ptr %3165, align 8 // CHECK-NEXT: %3166 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @"[]_llgo_uint8", ptr undef }, ptr %3165, 1 @@ -6217,7 +6216,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %3170 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %3161, i32 0, i32 1 // CHECK-NEXT: %3171 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %3172 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 6 }, ptr %3172, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @422, i64 6 }, ptr %3172, align 8 // CHECK-NEXT: %3173 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_main.MyString, ptr undef }, ptr %3172, 1 // CHECK-NEXT: %3174 = extractvalue { ptr, ptr } %3171, 1 // CHECK-NEXT: %3175 = extractvalue { ptr, ptr } %3171, 0 @@ -6228,7 +6227,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %3177 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %1, i64 211 // CHECK-NEXT: %3178 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %3177, i32 0, i32 0 // CHECK-NEXT: %3179 = load { ptr, ptr }, ptr @main.V, align 8 -// CHECK-NEXT: %3180 = call %"{{.*}}/runtime/internal/runtime.Slice" @"{{.*}}/runtime/internal/runtime.StringToBytes"(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 6 }) +// CHECK-NEXT: %3180 = call %"{{.*}}/runtime/internal/runtime.Slice" @"{{.*}}/runtime/internal/runtime.StringToBytes"(%"{{.*}}/runtime/internal/runtime.String" { ptr @423, i64 6 }) // CHECK-NEXT: %3181 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 24) // CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.Slice" %3180, ptr %3181, align 8 // CHECK-NEXT: %3182 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @"[]_llgo_uint8", ptr undef }, ptr %3181, 1 @@ -6238,7 +6237,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %3185 = call %reflect.Value %__llgo_funcval_code422(ptr {{(nest|swiftself)}} %3183, %"{{.*}}/runtime/internal/runtime.eface" %3182) // CHECK-NEXT: %3186 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %3177, i32 0, i32 1 // CHECK-NEXT: %3187 = load { ptr, ptr }, ptr @main.V, align 8 -// CHECK-NEXT: %3188 = call %"{{.*}}/runtime/internal/runtime.Slice" @"{{.*}}/runtime/internal/runtime.StringToBytes"(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 6 }) +// CHECK-NEXT: %3188 = call %"{{.*}}/runtime/internal/runtime.Slice" @"{{.*}}/runtime/internal/runtime.StringToBytes"(%"{{.*}}/runtime/internal/runtime.String" { ptr @423, i64 6 }) // CHECK-NEXT: %3189 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 24) // CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.Slice" %3188, ptr %3189, align 8 // CHECK-NEXT: %3190 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @"[]_llgo_uint8", ptr undef }, ptr %3189, 1 @@ -6252,7 +6251,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %3195 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %3194, i32 0, i32 0 // CHECK-NEXT: %3196 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %3197 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 8 }, ptr %3197, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @424, i64 8 }, ptr %3197, align 8 // CHECK-NEXT: %3198 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_main.MyString, ptr undef }, ptr %3197, 1 // CHECK-NEXT: %3199 = extractvalue { ptr, ptr } %3196, 1 // CHECK-NEXT: %3200 = extractvalue { ptr, ptr } %3196, 0 @@ -6260,7 +6259,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %3201 = call %reflect.Value %__llgo_funcval_code424(ptr {{(nest|swiftself)}} %3199, %"{{.*}}/runtime/internal/runtime.eface" %3198) // CHECK-NEXT: %3202 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %3194, i32 0, i32 1 // CHECK-NEXT: %3203 = load { ptr, ptr }, ptr @main.V, align 8 -// CHECK-NEXT: %3204 = call %"{{.*}}/runtime/internal/runtime.Slice" @"{{.*}}/runtime/internal/runtime.StringToRunes"(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 8 }) +// CHECK-NEXT: %3204 = call %"{{.*}}/runtime/internal/runtime.Slice" @"{{.*}}/runtime/internal/runtime.StringToRunes"(%"{{.*}}/runtime/internal/runtime.String" { ptr @424, i64 8 }) // CHECK-NEXT: %3205 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 24) // CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.Slice" %3204, ptr %3205, align 8 // CHECK-NEXT: %3206 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @"[]_llgo_int32", ptr undef }, ptr %3205, 1 @@ -6273,7 +6272,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %3210 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %1, i64 213 // CHECK-NEXT: %3211 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %3210, i32 0, i32 0 // CHECK-NEXT: %3212 = load { ptr, ptr }, ptr @main.V, align 8 -// CHECK-NEXT: %3213 = call %"{{.*}}/runtime/internal/runtime.Slice" @"{{.*}}/runtime/internal/runtime.StringToRunes"(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 8 }) +// CHECK-NEXT: %3213 = call %"{{.*}}/runtime/internal/runtime.Slice" @"{{.*}}/runtime/internal/runtime.StringToRunes"(%"{{.*}}/runtime/internal/runtime.String" { ptr @425, i64 8 }) // CHECK-NEXT: %3214 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 24) // CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.Slice" %3213, ptr %3214, align 8 // CHECK-NEXT: %3215 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @"[]_llgo_int32", ptr undef }, ptr %3214, 1 @@ -6284,7 +6283,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %3219 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %3210, i32 0, i32 1 // CHECK-NEXT: %3220 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %3221 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 8 }, ptr %3221, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @425, i64 8 }, ptr %3221, align 8 // CHECK-NEXT: %3222 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_main.MyString, ptr undef }, ptr %3221, 1 // CHECK-NEXT: %3223 = extractvalue { ptr, ptr } %3220, 1 // CHECK-NEXT: %3224 = extractvalue { ptr, ptr } %3220, 0 @@ -6295,7 +6294,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %3226 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %1, i64 214 // CHECK-NEXT: %3227 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %3226, i32 0, i32 0 // CHECK-NEXT: %3228 = load { ptr, ptr }, ptr @main.V, align 8 -// CHECK-NEXT: %3229 = call %"{{.*}}/runtime/internal/runtime.Slice" @"{{.*}}/runtime/internal/runtime.StringToRunes"(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 17 }) +// CHECK-NEXT: %3229 = call %"{{.*}}/runtime/internal/runtime.Slice" @"{{.*}}/runtime/internal/runtime.StringToRunes"(%"{{.*}}/runtime/internal/runtime.String" { ptr @426, i64 17 }) // CHECK-NEXT: %3230 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 24) // CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.Slice" %3229, ptr %3230, align 8 // CHECK-NEXT: %3231 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @"[]_llgo_int32", ptr undef }, ptr %3230, 1 @@ -6305,7 +6304,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %3234 = call %reflect.Value %__llgo_funcval_code428(ptr {{(nest|swiftself)}} %3232, %"{{.*}}/runtime/internal/runtime.eface" %3231) // CHECK-NEXT: %3235 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %3226, i32 0, i32 1 // CHECK-NEXT: %3236 = load { ptr, ptr }, ptr @main.V, align 8 -// CHECK-NEXT: %3237 = call %"{{.*}}/runtime/internal/runtime.Slice" @"{{.*}}/runtime/internal/runtime.StringToRunes"(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 17 }) +// CHECK-NEXT: %3237 = call %"{{.*}}/runtime/internal/runtime.Slice" @"{{.*}}/runtime/internal/runtime.StringToRunes"(%"{{.*}}/runtime/internal/runtime.String" { ptr @426, i64 17 }) // CHECK-NEXT: %3238 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 24) // CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.Slice" %3237, ptr %3238, align 8 // CHECK-NEXT: %3239 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @"[]_llgo_int32", ptr undef }, ptr %3238, 1 @@ -6318,7 +6317,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %3243 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %1, i64 215 // CHECK-NEXT: %3244 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %3243, i32 0, i32 0 // CHECK-NEXT: %3245 = load { ptr, ptr }, ptr @main.V, align 8 -// CHECK-NEXT: %3246 = call %"{{.*}}/runtime/internal/runtime.Slice" @"{{.*}}/runtime/internal/runtime.StringToRunes"(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 17 }) +// CHECK-NEXT: %3246 = call %"{{.*}}/runtime/internal/runtime.Slice" @"{{.*}}/runtime/internal/runtime.StringToRunes"(%"{{.*}}/runtime/internal/runtime.String" { ptr @426, i64 17 }) // CHECK-NEXT: %3247 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 24) // CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.Slice" %3246, ptr %3247, align 8 // CHECK-NEXT: %3248 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @"[]_llgo_int32", ptr undef }, ptr %3247, 1 @@ -6328,7 +6327,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %3251 = call %reflect.Value %__llgo_funcval_code430(ptr {{(nest|swiftself)}} %3249, %"{{.*}}/runtime/internal/runtime.eface" %3248) // CHECK-NEXT: %3252 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %3243, i32 0, i32 1 // CHECK-NEXT: %3253 = load { ptr, ptr }, ptr @main.V, align 8 -// CHECK-NEXT: %3254 = call %"{{.*}}/runtime/internal/runtime.Slice" @"{{.*}}/runtime/internal/runtime.StringToRunes"(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 17 }) +// CHECK-NEXT: %3254 = call %"{{.*}}/runtime/internal/runtime.Slice" @"{{.*}}/runtime/internal/runtime.StringToRunes"(%"{{.*}}/runtime/internal/runtime.String" { ptr @426, i64 17 }) // CHECK-NEXT: %3255 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 24) // CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.Slice" %3254, ptr %3255, align 8 // CHECK-NEXT: %3256 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_main.MyRunes, ptr undef }, ptr %3255, 1 @@ -6341,7 +6340,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %3260 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %1, i64 216 // CHECK-NEXT: %3261 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %3260, i32 0, i32 0 // CHECK-NEXT: %3262 = load { ptr, ptr }, ptr @main.V, align 8 -// CHECK-NEXT: %3263 = call %"{{.*}}/runtime/internal/runtime.Slice" @"{{.*}}/runtime/internal/runtime.StringToRunes"(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 17 }) +// CHECK-NEXT: %3263 = call %"{{.*}}/runtime/internal/runtime.Slice" @"{{.*}}/runtime/internal/runtime.StringToRunes"(%"{{.*}}/runtime/internal/runtime.String" { ptr @426, i64 17 }) // CHECK-NEXT: %3264 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 24) // CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.Slice" %3263, ptr %3264, align 8 // CHECK-NEXT: %3265 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_main.MyRunes, ptr undef }, ptr %3264, 1 @@ -6351,7 +6350,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %3268 = call %reflect.Value %__llgo_funcval_code432(ptr {{(nest|swiftself)}} %3266, %"{{.*}}/runtime/internal/runtime.eface" %3265) // CHECK-NEXT: %3269 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %3260, i32 0, i32 1 // CHECK-NEXT: %3270 = load { ptr, ptr }, ptr @main.V, align 8 -// CHECK-NEXT: %3271 = call %"{{.*}}/runtime/internal/runtime.Slice" @"{{.*}}/runtime/internal/runtime.StringToRunes"(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 17 }) +// CHECK-NEXT: %3271 = call %"{{.*}}/runtime/internal/runtime.Slice" @"{{.*}}/runtime/internal/runtime.StringToRunes"(%"{{.*}}/runtime/internal/runtime.String" { ptr @426, i64 17 }) // CHECK-NEXT: %3272 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 24) // CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.Slice" %3271, ptr %3272, align 8 // CHECK-NEXT: %3273 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @"[]_llgo_int32", ptr undef }, ptr %3272, 1 @@ -6374,7 +6373,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %3285 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %3277, i32 0, i32 1 // CHECK-NEXT: %3286 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %3287 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 1 }, ptr %3287, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @427, i64 1 }, ptr %3287, align 8 // CHECK-NEXT: %3288 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_main.MyString, ptr undef }, ptr %3287, 1 // CHECK-NEXT: %3289 = extractvalue { ptr, ptr } %3286, 1 // CHECK-NEXT: %3290 = extractvalue { ptr, ptr } %3286, 0 @@ -6395,7 +6394,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %3300 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %3292, i32 0, i32 1 // CHECK-NEXT: %3301 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %3302 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 1 }, ptr %3302, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @427, i64 1 }, ptr %3302, align 8 // CHECK-NEXT: %3303 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_main.MyString, ptr undef }, ptr %3302, 1 // CHECK-NEXT: %3304 = extractvalue { ptr, ptr } %3301, 1 // CHECK-NEXT: %3305 = extractvalue { ptr, ptr } %3301, 0 @@ -6416,7 +6415,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %3315 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %3307, i32 0, i32 1 // CHECK-NEXT: %3316 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %3317 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 1 }, ptr %3317, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @427, i64 1 }, ptr %3317, align 8 // CHECK-NEXT: %3318 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_main.MyString, ptr undef }, ptr %3317, 1 // CHECK-NEXT: %3319 = extractvalue { ptr, ptr } %3316, 1 // CHECK-NEXT: %3320 = extractvalue { ptr, ptr } %3316, 0 @@ -6437,7 +6436,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %3330 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %3322, i32 0, i32 1 // CHECK-NEXT: %3331 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %3332 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 1 }, ptr %3332, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @427, i64 1 }, ptr %3332, align 8 // CHECK-NEXT: %3333 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_main.MyString, ptr undef }, ptr %3332, 1 // CHECK-NEXT: %3334 = extractvalue { ptr, ptr } %3331, 1 // CHECK-NEXT: %3335 = extractvalue { ptr, ptr } %3331, 0 @@ -6458,7 +6457,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %3345 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %3337, i32 0, i32 1 // CHECK-NEXT: %3346 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %3347 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 1 }, ptr %3347, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @427, i64 1 }, ptr %3347, align 8 // CHECK-NEXT: %3348 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_main.MyString, ptr undef }, ptr %3347, 1 // CHECK-NEXT: %3349 = extractvalue { ptr, ptr } %3346, 1 // CHECK-NEXT: %3350 = extractvalue { ptr, ptr } %3346, 0 @@ -6479,7 +6478,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %3360 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %3352, i32 0, i32 1 // CHECK-NEXT: %3361 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %3362 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 1 }, ptr %3362, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @427, i64 1 }, ptr %3362, align 8 // CHECK-NEXT: %3363 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_main.MyString, ptr undef }, ptr %3362, 1 // CHECK-NEXT: %3364 = extractvalue { ptr, ptr } %3361, 1 // CHECK-NEXT: %3365 = extractvalue { ptr, ptr } %3361, 0 @@ -6500,7 +6499,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %3375 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %3367, i32 0, i32 1 // CHECK-NEXT: %3376 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %3377 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 1 }, ptr %3377, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @427, i64 1 }, ptr %3377, align 8 // CHECK-NEXT: %3378 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_main.MyString, ptr undef }, ptr %3377, 1 // CHECK-NEXT: %3379 = extractvalue { ptr, ptr } %3376, 1 // CHECK-NEXT: %3380 = extractvalue { ptr, ptr } %3376, 0 @@ -6521,7 +6520,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %3390 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %3382, i32 0, i32 1 // CHECK-NEXT: %3391 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %3392 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 1 }, ptr %3392, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @427, i64 1 }, ptr %3392, align 8 // CHECK-NEXT: %3393 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_main.MyString, ptr undef }, ptr %3392, 1 // CHECK-NEXT: %3394 = extractvalue { ptr, ptr } %3391, 1 // CHECK-NEXT: %3395 = extractvalue { ptr, ptr } %3391, 0 @@ -6542,7 +6541,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %3405 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %3397, i32 0, i32 1 // CHECK-NEXT: %3406 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %3407 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 1 }, ptr %3407, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @427, i64 1 }, ptr %3407, align 8 // CHECK-NEXT: %3408 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_main.MyString, ptr undef }, ptr %3407, 1 // CHECK-NEXT: %3409 = extractvalue { ptr, ptr } %3406, 1 // CHECK-NEXT: %3410 = extractvalue { ptr, ptr } %3406, 0 @@ -6563,7 +6562,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %3420 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %3412, i32 0, i32 1 // CHECK-NEXT: %3421 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %3422 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 1 }, ptr %3422, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @427, i64 1 }, ptr %3422, align 8 // CHECK-NEXT: %3423 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_main.MyString, ptr undef }, ptr %3422, 1 // CHECK-NEXT: %3424 = extractvalue { ptr, ptr } %3421, 1 // CHECK-NEXT: %3425 = extractvalue { ptr, ptr } %3421, 0 @@ -6584,7 +6583,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %3435 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %3427, i32 0, i32 1 // CHECK-NEXT: %3436 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %3437 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 1 }, ptr %3437, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @427, i64 1 }, ptr %3437, align 8 // CHECK-NEXT: %3438 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_main.MyString, ptr undef }, ptr %3437, 1 // CHECK-NEXT: %3439 = extractvalue { ptr, ptr } %3436, 1 // CHECK-NEXT: %3440 = extractvalue { ptr, ptr } %3436, 0 @@ -6605,7 +6604,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %3450 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %3442, i32 0, i32 1 // CHECK-NEXT: %3451 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %3452 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 3 }, ptr %3452, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @428, i64 3 }, ptr %3452, align 8 // CHECK-NEXT: %3453 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_main.MyString, ptr undef }, ptr %3452, 1 // CHECK-NEXT: %3454 = extractvalue { ptr, ptr } %3451, 1 // CHECK-NEXT: %3455 = extractvalue { ptr, ptr } %3451, 0 @@ -6626,7 +6625,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %3465 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %3457, i32 0, i32 1 // CHECK-NEXT: %3466 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %3467 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 3 }, ptr %3467, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @428, i64 3 }, ptr %3467, align 8 // CHECK-NEXT: %3468 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_main.MyString, ptr undef }, ptr %3467, 1 // CHECK-NEXT: %3469 = extractvalue { ptr, ptr } %3466, 1 // CHECK-NEXT: %3470 = extractvalue { ptr, ptr } %3466, 0 @@ -6647,7 +6646,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %3480 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %3472, i32 0, i32 1 // CHECK-NEXT: %3481 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %3482 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 3 }, ptr %3482, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @428, i64 3 }, ptr %3482, align 8 // CHECK-NEXT: %3483 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_main.MyString, ptr undef }, ptr %3482, 1 // CHECK-NEXT: %3484 = extractvalue { ptr, ptr } %3481, 1 // CHECK-NEXT: %3485 = extractvalue { ptr, ptr } %3481, 0 @@ -6668,7 +6667,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %3495 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %3487, i32 0, i32 1 // CHECK-NEXT: %3496 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %3497 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 3 }, ptr %3497, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @428, i64 3 }, ptr %3497, align 8 // CHECK-NEXT: %3498 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_main.MyString, ptr undef }, ptr %3497, 1 // CHECK-NEXT: %3499 = extractvalue { ptr, ptr } %3496, 1 // CHECK-NEXT: %3500 = extractvalue { ptr, ptr } %3496, 0 @@ -6689,7 +6688,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %3510 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %3502, i32 0, i32 1 // CHECK-NEXT: %3511 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %3512 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 3 }, ptr %3512, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @428, i64 3 }, ptr %3512, align 8 // CHECK-NEXT: %3513 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_main.MyString, ptr undef }, ptr %3512, 1 // CHECK-NEXT: %3514 = extractvalue { ptr, ptr } %3511, 1 // CHECK-NEXT: %3515 = extractvalue { ptr, ptr } %3511, 0 @@ -6710,7 +6709,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %3525 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %3517, i32 0, i32 1 // CHECK-NEXT: %3526 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %3527 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 3 }, ptr %3527, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @428, i64 3 }, ptr %3527, align 8 // CHECK-NEXT: %3528 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_main.MyString, ptr undef }, ptr %3527, 1 // CHECK-NEXT: %3529 = extractvalue { ptr, ptr } %3526, 1 // CHECK-NEXT: %3530 = extractvalue { ptr, ptr } %3526, 0 @@ -6731,7 +6730,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %3540 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %3532, i32 0, i32 1 // CHECK-NEXT: %3541 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %3542 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 3 }, ptr %3542, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @428, i64 3 }, ptr %3542, align 8 // CHECK-NEXT: %3543 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_main.MyString, ptr undef }, ptr %3542, 1 // CHECK-NEXT: %3544 = extractvalue { ptr, ptr } %3541, 1 // CHECK-NEXT: %3545 = extractvalue { ptr, ptr } %3541, 0 @@ -6752,7 +6751,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %3555 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %3547, i32 0, i32 1 // CHECK-NEXT: %3556 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %3557 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 3 }, ptr %3557, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @428, i64 3 }, ptr %3557, align 8 // CHECK-NEXT: %3558 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_main.MyString, ptr undef }, ptr %3557, 1 // CHECK-NEXT: %3559 = extractvalue { ptr, ptr } %3556, 1 // CHECK-NEXT: %3560 = extractvalue { ptr, ptr } %3556, 0 @@ -6773,7 +6772,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %3570 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %3562, i32 0, i32 1 // CHECK-NEXT: %3571 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %3572 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 3 }, ptr %3572, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @428, i64 3 }, ptr %3572, align 8 // CHECK-NEXT: %3573 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_main.MyString, ptr undef }, ptr %3572, 1 // CHECK-NEXT: %3574 = extractvalue { ptr, ptr } %3571, 1 // CHECK-NEXT: %3575 = extractvalue { ptr, ptr } %3571, 0 @@ -6785,7 +6784,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %3578 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %3577, i32 0, i32 0 // CHECK-NEXT: %3579 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %3580 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 6 }, ptr %3580, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @421, i64 6 }, ptr %3580, align 8 // CHECK-NEXT: %3581 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %3580, 1 // CHECK-NEXT: %3582 = extractvalue { ptr, ptr } %3579, 1 // CHECK-NEXT: %3583 = extractvalue { ptr, ptr } %3579, 0 @@ -6793,7 +6792,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %3584 = call %reflect.Value %__llgo_funcval_code474(ptr {{(nest|swiftself)}} %3582, %"{{.*}}/runtime/internal/runtime.eface" %3581) // CHECK-NEXT: %3585 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %3577, i32 0, i32 1 // CHECK-NEXT: %3586 = load { ptr, ptr }, ptr @main.V, align 8 -// CHECK-NEXT: %3587 = call %"{{.*}}/runtime/internal/runtime.Slice" @"{{.*}}/runtime/internal/runtime.StringToBytes"(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 6 }) +// CHECK-NEXT: %3587 = call %"{{.*}}/runtime/internal/runtime.Slice" @"{{.*}}/runtime/internal/runtime.StringToBytes"(%"{{.*}}/runtime/internal/runtime.String" { ptr @421, i64 6 }) // CHECK-NEXT: %3588 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 24) // CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.Slice" %3587, ptr %3588, align 8 // CHECK-NEXT: %3589 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_main.MyBytes, ptr undef }, ptr %3588, 1 @@ -6806,7 +6805,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %3593 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %1, i64 238 // CHECK-NEXT: %3594 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %3593, i32 0, i32 0 // CHECK-NEXT: %3595 = load { ptr, ptr }, ptr @main.V, align 8 -// CHECK-NEXT: %3596 = call %"{{.*}}/runtime/internal/runtime.Slice" @"{{.*}}/runtime/internal/runtime.StringToBytes"(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 6 }) +// CHECK-NEXT: %3596 = call %"{{.*}}/runtime/internal/runtime.Slice" @"{{.*}}/runtime/internal/runtime.StringToBytes"(%"{{.*}}/runtime/internal/runtime.String" { ptr @422, i64 6 }) // CHECK-NEXT: %3597 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 24) // CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.Slice" %3596, ptr %3597, align 8 // CHECK-NEXT: %3598 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_main.MyBytes, ptr undef }, ptr %3597, 1 @@ -6817,7 +6816,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %3602 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %3593, i32 0, i32 1 // CHECK-NEXT: %3603 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %3604 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 6 }, ptr %3604, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @422, i64 6 }, ptr %3604, align 8 // CHECK-NEXT: %3605 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %3604, 1 // CHECK-NEXT: %3606 = extractvalue { ptr, ptr } %3603, 1 // CHECK-NEXT: %3607 = extractvalue { ptr, ptr } %3603, 0 @@ -6828,7 +6827,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %3609 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %1, i64 239 // CHECK-NEXT: %3610 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %3609, i32 0, i32 0 // CHECK-NEXT: %3611 = load { ptr, ptr }, ptr @main.V, align 8 -// CHECK-NEXT: %3612 = call %"{{.*}}/runtime/internal/runtime.Slice" @"{{.*}}/runtime/internal/runtime.StringToBytes"(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 6 }) +// CHECK-NEXT: %3612 = call %"{{.*}}/runtime/internal/runtime.Slice" @"{{.*}}/runtime/internal/runtime.StringToBytes"(%"{{.*}}/runtime/internal/runtime.String" { ptr @423, i64 6 }) // CHECK-NEXT: %3613 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 24) // CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.Slice" %3612, ptr %3613, align 8 // CHECK-NEXT: %3614 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_main.MyBytes, ptr undef }, ptr %3613, 1 @@ -6838,7 +6837,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %3617 = call %reflect.Value %__llgo_funcval_code478(ptr {{(nest|swiftself)}} %3615, %"{{.*}}/runtime/internal/runtime.eface" %3614) // CHECK-NEXT: %3618 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %3609, i32 0, i32 1 // CHECK-NEXT: %3619 = load { ptr, ptr }, ptr @main.V, align 8 -// CHECK-NEXT: %3620 = call %"{{.*}}/runtime/internal/runtime.Slice" @"{{.*}}/runtime/internal/runtime.StringToBytes"(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 6 }) +// CHECK-NEXT: %3620 = call %"{{.*}}/runtime/internal/runtime.Slice" @"{{.*}}/runtime/internal/runtime.StringToBytes"(%"{{.*}}/runtime/internal/runtime.String" { ptr @423, i64 6 }) // CHECK-NEXT: %3621 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 24) // CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.Slice" %3620, ptr %3621, align 8 // CHECK-NEXT: %3622 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_main.MyBytes, ptr undef }, ptr %3621, 1 @@ -6852,7 +6851,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %3627 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %3626, i32 0, i32 0 // CHECK-NEXT: %3628 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %3629 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 6 }, ptr %3629, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @421, i64 6 }, ptr %3629, align 8 // CHECK-NEXT: %3630 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_main.MyString, ptr undef }, ptr %3629, 1 // CHECK-NEXT: %3631 = extractvalue { ptr, ptr } %3628, 1 // CHECK-NEXT: %3632 = extractvalue { ptr, ptr } %3628, 0 @@ -6860,7 +6859,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %3633 = call %reflect.Value %__llgo_funcval_code480(ptr {{(nest|swiftself)}} %3631, %"{{.*}}/runtime/internal/runtime.eface" %3630) // CHECK-NEXT: %3634 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %3626, i32 0, i32 1 // CHECK-NEXT: %3635 = load { ptr, ptr }, ptr @main.V, align 8 -// CHECK-NEXT: %3636 = call %"{{.*}}/runtime/internal/runtime.Slice" @"{{.*}}/runtime/internal/runtime.StringToBytes"(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 6 }) +// CHECK-NEXT: %3636 = call %"{{.*}}/runtime/internal/runtime.Slice" @"{{.*}}/runtime/internal/runtime.StringToBytes"(%"{{.*}}/runtime/internal/runtime.String" { ptr @421, i64 6 }) // CHECK-NEXT: %3637 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 24) // CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.Slice" %3636, ptr %3637, align 8 // CHECK-NEXT: %3638 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_main.MyBytes, ptr undef }, ptr %3637, 1 @@ -6873,7 +6872,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %3642 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %1, i64 241 // CHECK-NEXT: %3643 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %3642, i32 0, i32 0 // CHECK-NEXT: %3644 = load { ptr, ptr }, ptr @main.V, align 8 -// CHECK-NEXT: %3645 = call %"{{.*}}/runtime/internal/runtime.Slice" @"{{.*}}/runtime/internal/runtime.StringToBytes"(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 6 }) +// CHECK-NEXT: %3645 = call %"{{.*}}/runtime/internal/runtime.Slice" @"{{.*}}/runtime/internal/runtime.StringToBytes"(%"{{.*}}/runtime/internal/runtime.String" { ptr @422, i64 6 }) // CHECK-NEXT: %3646 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 24) // CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.Slice" %3645, ptr %3646, align 8 // CHECK-NEXT: %3647 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_main.MyBytes, ptr undef }, ptr %3646, 1 @@ -6884,7 +6883,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %3651 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %3642, i32 0, i32 1 // CHECK-NEXT: %3652 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %3653 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 6 }, ptr %3653, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @422, i64 6 }, ptr %3653, align 8 // CHECK-NEXT: %3654 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_main.MyString, ptr undef }, ptr %3653, 1 // CHECK-NEXT: %3655 = extractvalue { ptr, ptr } %3652, 1 // CHECK-NEXT: %3656 = extractvalue { ptr, ptr } %3652, 0 @@ -6896,7 +6895,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %3659 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %3658, i32 0, i32 0 // CHECK-NEXT: %3660 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %3661 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 8 }, ptr %3661, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @424, i64 8 }, ptr %3661, align 8 // CHECK-NEXT: %3662 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %3661, 1 // CHECK-NEXT: %3663 = extractvalue { ptr, ptr } %3660, 1 // CHECK-NEXT: %3664 = extractvalue { ptr, ptr } %3660, 0 @@ -6904,7 +6903,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %3665 = call %reflect.Value %__llgo_funcval_code484(ptr {{(nest|swiftself)}} %3663, %"{{.*}}/runtime/internal/runtime.eface" %3662) // CHECK-NEXT: %3666 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %3658, i32 0, i32 1 // CHECK-NEXT: %3667 = load { ptr, ptr }, ptr @main.V, align 8 -// CHECK-NEXT: %3668 = call %"{{.*}}/runtime/internal/runtime.Slice" @"{{.*}}/runtime/internal/runtime.StringToRunes"(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 8 }) +// CHECK-NEXT: %3668 = call %"{{.*}}/runtime/internal/runtime.Slice" @"{{.*}}/runtime/internal/runtime.StringToRunes"(%"{{.*}}/runtime/internal/runtime.String" { ptr @424, i64 8 }) // CHECK-NEXT: %3669 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 24) // CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.Slice" %3668, ptr %3669, align 8 // CHECK-NEXT: %3670 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_main.MyRunes, ptr undef }, ptr %3669, 1 @@ -6917,7 +6916,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %3674 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %1, i64 243 // CHECK-NEXT: %3675 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %3674, i32 0, i32 0 // CHECK-NEXT: %3676 = load { ptr, ptr }, ptr @main.V, align 8 -// CHECK-NEXT: %3677 = call %"{{.*}}/runtime/internal/runtime.Slice" @"{{.*}}/runtime/internal/runtime.StringToRunes"(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 8 }) +// CHECK-NEXT: %3677 = call %"{{.*}}/runtime/internal/runtime.Slice" @"{{.*}}/runtime/internal/runtime.StringToRunes"(%"{{.*}}/runtime/internal/runtime.String" { ptr @425, i64 8 }) // CHECK-NEXT: %3678 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 24) // CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.Slice" %3677, ptr %3678, align 8 // CHECK-NEXT: %3679 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_main.MyRunes, ptr undef }, ptr %3678, 1 @@ -6928,7 +6927,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %3683 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %3674, i32 0, i32 1 // CHECK-NEXT: %3684 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %3685 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 8 }, ptr %3685, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @425, i64 8 }, ptr %3685, align 8 // CHECK-NEXT: %3686 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %3685, 1 // CHECK-NEXT: %3687 = extractvalue { ptr, ptr } %3684, 1 // CHECK-NEXT: %3688 = extractvalue { ptr, ptr } %3684, 0 @@ -6939,7 +6938,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %3690 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %1, i64 244 // CHECK-NEXT: %3691 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %3690, i32 0, i32 0 // CHECK-NEXT: %3692 = load { ptr, ptr }, ptr @main.V, align 8 -// CHECK-NEXT: %3693 = call %"{{.*}}/runtime/internal/runtime.Slice" @"{{.*}}/runtime/internal/runtime.StringToRunes"(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 17 }) +// CHECK-NEXT: %3693 = call %"{{.*}}/runtime/internal/runtime.Slice" @"{{.*}}/runtime/internal/runtime.StringToRunes"(%"{{.*}}/runtime/internal/runtime.String" { ptr @426, i64 17 }) // CHECK-NEXT: %3694 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 24) // CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.Slice" %3693, ptr %3694, align 8 // CHECK-NEXT: %3695 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_main.MyRunes, ptr undef }, ptr %3694, 1 @@ -6949,7 +6948,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %3698 = call %reflect.Value %__llgo_funcval_code488(ptr {{(nest|swiftself)}} %3696, %"{{.*}}/runtime/internal/runtime.eface" %3695) // CHECK-NEXT: %3699 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %3690, i32 0, i32 1 // CHECK-NEXT: %3700 = load { ptr, ptr }, ptr @main.V, align 8 -// CHECK-NEXT: %3701 = call %"{{.*}}/runtime/internal/runtime.Slice" @"{{.*}}/runtime/internal/runtime.StringToRunes"(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 17 }) +// CHECK-NEXT: %3701 = call %"{{.*}}/runtime/internal/runtime.Slice" @"{{.*}}/runtime/internal/runtime.StringToRunes"(%"{{.*}}/runtime/internal/runtime.String" { ptr @426, i64 17 }) // CHECK-NEXT: %3702 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 24) // CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.Slice" %3701, ptr %3702, align 8 // CHECK-NEXT: %3703 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_main.MyRunes, ptr undef }, ptr %3702, 1 @@ -6963,7 +6962,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %3708 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %3707, i32 0, i32 0 // CHECK-NEXT: %3709 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %3710 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 8 }, ptr %3710, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @424, i64 8 }, ptr %3710, align 8 // CHECK-NEXT: %3711 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_main.MyString, ptr undef }, ptr %3710, 1 // CHECK-NEXT: %3712 = extractvalue { ptr, ptr } %3709, 1 // CHECK-NEXT: %3713 = extractvalue { ptr, ptr } %3709, 0 @@ -6971,7 +6970,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %3714 = call %reflect.Value %__llgo_funcval_code490(ptr {{(nest|swiftself)}} %3712, %"{{.*}}/runtime/internal/runtime.eface" %3711) // CHECK-NEXT: %3715 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %3707, i32 0, i32 1 // CHECK-NEXT: %3716 = load { ptr, ptr }, ptr @main.V, align 8 -// CHECK-NEXT: %3717 = call %"{{.*}}/runtime/internal/runtime.Slice" @"{{.*}}/runtime/internal/runtime.StringToRunes"(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 8 }) +// CHECK-NEXT: %3717 = call %"{{.*}}/runtime/internal/runtime.Slice" @"{{.*}}/runtime/internal/runtime.StringToRunes"(%"{{.*}}/runtime/internal/runtime.String" { ptr @424, i64 8 }) // CHECK-NEXT: %3718 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 24) // CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.Slice" %3717, ptr %3718, align 8 // CHECK-NEXT: %3719 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_main.MyRunes, ptr undef }, ptr %3718, 1 @@ -6984,7 +6983,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %3723 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %1, i64 246 // CHECK-NEXT: %3724 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %3723, i32 0, i32 0 // CHECK-NEXT: %3725 = load { ptr, ptr }, ptr @main.V, align 8 -// CHECK-NEXT: %3726 = call %"{{.*}}/runtime/internal/runtime.Slice" @"{{.*}}/runtime/internal/runtime.StringToRunes"(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 8 }) +// CHECK-NEXT: %3726 = call %"{{.*}}/runtime/internal/runtime.Slice" @"{{.*}}/runtime/internal/runtime.StringToRunes"(%"{{.*}}/runtime/internal/runtime.String" { ptr @425, i64 8 }) // CHECK-NEXT: %3727 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 24) // CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.Slice" %3726, ptr %3727, align 8 // CHECK-NEXT: %3728 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_main.MyRunes, ptr undef }, ptr %3727, 1 @@ -6995,7 +6994,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %3732 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %3723, i32 0, i32 1 // CHECK-NEXT: %3733 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %3734 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 8 }, ptr %3734, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @425, i64 8 }, ptr %3734, align 8 // CHECK-NEXT: %3735 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_main.MyString, ptr undef }, ptr %3734, 1 // CHECK-NEXT: %3736 = extractvalue { ptr, ptr } %3733, 1 // CHECK-NEXT: %3737 = extractvalue { ptr, ptr } %3733, 0 @@ -9391,7 +9390,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %5453 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %5452, i32 0, i32 0 // CHECK-NEXT: %5454 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %5455 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 5 }, ptr %5455, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @420, i64 5 }, ptr %5455, align 8 // CHECK-NEXT: %5456 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %5455, 1 // CHECK-NEXT: %5457 = extractvalue { ptr, ptr } %5454, 1 // CHECK-NEXT: %5458 = extractvalue { ptr, ptr } %5454, 0 @@ -9399,7 +9398,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %5459 = call %reflect.Value %__llgo_funcval_code733(ptr {{(nest|swiftself)}} %5457, %"{{.*}}/runtime/internal/runtime.eface" %5456) // CHECK-NEXT: %5460 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %5452, i32 0, i32 1 // CHECK-NEXT: %5461 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 5 }, ptr %5461, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @420, i64 5 }, ptr %5461, align 8 // CHECK-NEXT: %5462 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %5461, 1 // CHECK-NEXT: %5463 = call %reflect.Value @main.EmptyInterfaceV(%"{{.*}}/runtime/internal/runtime.eface" %5462) // CHECK-NEXT: store %reflect.Value %5459, ptr %5453, align 8 @@ -9415,7 +9414,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %5471 = call %reflect.Value %__llgo_funcval_code734(ptr {{(nest|swiftself)}} %5469, %"{{.*}}/runtime/internal/runtime.eface" %5468) // CHECK-NEXT: %5472 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %5464, i32 0, i32 1 // CHECK-NEXT: %5473 = call ptr @"{{.*}}/runtime/internal/runtime.AllocZ"(i64 40) -// CHECK-NEXT: %5474 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @"*_llgo_bytes.Buffer") +// CHECK-NEXT: %5474 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$uycIKA3bbxRhudEjW1hHKWKdLqHQsCVy8NdW1bkQmNw", ptr @"*_llgo_bytes.Buffer") // CHECK-NEXT: %5475 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %5474, 0 // CHECK-NEXT: %5476 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %5475, ptr %5473, 1 // CHECK-NEXT: %5477 = call %reflect.Value @main.ReaderV(%"{{.*}}/runtime/internal/runtime.iface" %5476) @@ -9424,13 +9423,13 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %5478 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %1, i64 369 // CHECK-NEXT: %5479 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %5478, i32 0, i32 0 // CHECK-NEXT: %5480 = call ptr @"{{.*}}/runtime/internal/runtime.AllocZ"(i64 40) -// CHECK-NEXT: %5481 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @"*_llgo_bytes.Buffer") +// CHECK-NEXT: %5481 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$Zutt7i_AwOTtBOIzyS7ZA5vhcNcbk0kRAoRC98HJDos", ptr @"*_llgo_bytes.Buffer") // CHECK-NEXT: %5482 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %5481, 0 // CHECK-NEXT: %5483 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %5482, ptr %5480, 1 // CHECK-NEXT: %5484 = call %reflect.Value @main.ReadWriterV(%"{{.*}}/runtime/internal/runtime.iface" %5483) // CHECK-NEXT: %5485 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %5478, i32 0, i32 1 // CHECK-NEXT: %5486 = call ptr @"{{.*}}/runtime/internal/runtime.AllocZ"(i64 40) -// CHECK-NEXT: %5487 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @"*_llgo_bytes.Buffer") +// CHECK-NEXT: %5487 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$uycIKA3bbxRhudEjW1hHKWKdLqHQsCVy8NdW1bkQmNw", ptr @"*_llgo_bytes.Buffer") // CHECK-NEXT: %5488 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %5487, 0 // CHECK-NEXT: %5489 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %5488, ptr %5486, 1 // CHECK-NEXT: %5490 = call %reflect.Value @main.ReaderV(%"{{.*}}/runtime/internal/runtime.iface" %5489) @@ -9447,7 +9446,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %5498 = call %reflect.Value %__llgo_funcval_code735(ptr {{(nest|swiftself)}} %5496, %"{{.*}}/runtime/internal/runtime.eface" %5495) // CHECK-NEXT: %5499 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %5491, i32 0, i32 1 // CHECK-NEXT: %5500 = call ptr @"{{.*}}/runtime/internal/runtime.AllocZ"(i64 40) -// CHECK-NEXT: %5501 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @"*_llgo_bytes.Buffer") +// CHECK-NEXT: %5501 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$Zutt7i_AwOTtBOIzyS7ZA5vhcNcbk0kRAoRC98HJDos", ptr @"*_llgo_bytes.Buffer") // CHECK-NEXT: %5502 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %5501, 0 // CHECK-NEXT: %5503 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %5502, ptr %5500, 1 // CHECK-NEXT: %5504 = call %reflect.Value @main.ReadWriterV(%"{{.*}}/runtime/internal/runtime.iface" %5503) @@ -9481,7 +9480,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: store ptr %2, ptr %4, align 8 // CHECK-NEXT: %5 = insertvalue { ptr, ptr } { ptr @"main.shouldPanic$1", ptr undef }, ptr %3, 1 // CHECK-NEXT: %6 = call ptr @"{{.*}}/runtime/internal/runtime.GetThreadDefer"() -// CHECK-NEXT: %7 = alloca i8, i64 {{.*}}, align 1 +// CHECK-NEXT: %7 = alloca i8, i64 {{[0-9]+}}, align 1 // CHECK-NEXT: %8 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 48) // CHECK-NEXT: %9 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %8, i32 0, i32 0 // CHECK-NEXT: store ptr %7, ptr %9, align 8 @@ -9497,7 +9496,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %15 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %8, i32 0, i32 4 // CHECK-NEXT: %16 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %8, i32 0, i32 5 // CHECK-NEXT: store ptr null, ptr %16, align 8 -// CHECK-NEXT: %17 = call i32 @{{(__)?}}sigsetjmp(ptr %7, i32 0) +// CHECK-NEXT: %17 = call i32 @{{(__)?sigsetjmp}}(ptr %7, i32 0) // CHECK-NEXT: %18 = icmp eq i32 %17, 0 // CHECK-NEXT: br i1 %18, label %_llgo_4, label %_llgo_5 // CHECK-EMPTY: @@ -9575,7 +9574,7 @@ func shouldPanic(expect string, f func()) { // CHECK-EMPTY: // CHECK-NEXT: _llgo_1: ; preds = %_llgo_0 // CHECK-NEXT: %5 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 13 }, ptr %5, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @535, i64 13 }, ptr %5, align 8 // CHECK-NEXT: %6 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %5, 1 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.Panic"(%"{{.*}}/runtime/internal/runtime.eface" %6) // CHECK-NEXT: unreachable @@ -9597,7 +9596,7 @@ func shouldPanic(expect string, f func()) { // CHECK-EMPTY: // CHECK-NEXT: _llgo_5: ; preds = %_llgo_8, %_llgo_6 // CHECK-NEXT: %13 = phi %"{{.*}}/runtime/internal/runtime.String" [ %44, %_llgo_6 ], [ %17, %_llgo_8 ] -// CHECK-NEXT: %14 = call i1 @strings.HasPrefix(%"{{.*}}/runtime/internal/runtime.String" %13, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 7 }) +// CHECK-NEXT: %14 = call i1 @strings.HasPrefix(%"{{.*}}/runtime/internal/runtime.String" %13, %"{{.*}}/runtime/internal/runtime.String" { ptr @30, i64 7 }) // CHECK-NEXT: br i1 %14, label %_llgo_11, label %_llgo_10 // CHECK-EMPTY: // CHECK-NEXT: _llgo_6: ; preds = %_llgo_15 @@ -9619,7 +9618,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %20 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" undef, ptr %18, 0 // CHECK-NEXT: %21 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" %20, i64 1, 1 // CHECK-NEXT: %22 = insertvalue %"{{.*}}/runtime/internal/runtime.Slice" %21, i64 1, 2 -// CHECK-NEXT: %23 = call %"{{.*}}/runtime/internal/runtime.String" @fmt.Sprintf(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 32 }, %"{{.*}}/runtime/internal/runtime.Slice" %22) +// CHECK-NEXT: %23 = call %"{{.*}}/runtime/internal/runtime.String" @fmt.Sprintf(%"{{.*}}/runtime/internal/runtime.String" { ptr @537, i64 32 }, %"{{.*}}/runtime/internal/runtime.Slice" %22) // CHECK-NEXT: %24 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) // CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" %23, ptr %24, align 8 // CHECK-NEXT: %25 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %24, 1 @@ -9627,7 +9626,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: unreachable // CHECK-EMPTY: // CHECK-NEXT: _llgo_10: ; preds = %_llgo_5 -// CHECK-NEXT: %26 = call %"{{.*}}/runtime/internal/runtime.String" @"{{.*}}/runtime/internal/runtime.StringCat"(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 44 }, %"{{.*}}/runtime/internal/runtime.String" %13) +// CHECK-NEXT: %26 = call %"{{.*}}/runtime/internal/runtime.String" @"{{.*}}/runtime/internal/runtime.StringCat"(%"{{.*}}/runtime/internal/runtime.String" { ptr @538, i64 44 }, %"{{.*}}/runtime/internal/runtime.String" %13) // CHECK-NEXT: %27 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) // CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" %26, ptr %27, align 8 // CHECK-NEXT: %28 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_string, ptr undef }, ptr %27, 1 @@ -9643,8 +9642,8 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: _llgo_12: ; preds = %_llgo_11 // CHECK-NEXT: %32 = extractvalue { ptr } %1, 0 // CHECK-NEXT: %33 = load %"{{.*}}/runtime/internal/runtime.String", ptr %32, align 8 -// CHECK-NEXT: %34 = call %"{{.*}}/runtime/internal/runtime.String" @"{{.*}}/runtime/internal/runtime.StringCat"(%"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 31 }, %"{{.*}}/runtime/internal/runtime.String" %33) -// CHECK-NEXT: %35 = call %"{{.*}}/runtime/internal/runtime.String" @"{{.*}}/runtime/internal/runtime.StringCat"(%"{{.*}}/runtime/internal/runtime.String" %34, %"{{.*}}/runtime/internal/runtime.String" { ptr @{{[0-9]+}}, i64 3 }) +// CHECK-NEXT: %34 = call %"{{.*}}/runtime/internal/runtime.String" @"{{.*}}/runtime/internal/runtime.StringCat"(%"{{.*}}/runtime/internal/runtime.String" { ptr @539, i64 31 }, %"{{.*}}/runtime/internal/runtime.String" %33) +// CHECK-NEXT: %35 = call %"{{.*}}/runtime/internal/runtime.String" @"{{.*}}/runtime/internal/runtime.StringCat"(%"{{.*}}/runtime/internal/runtime.String" %34, %"{{.*}}/runtime/internal/runtime.String" { ptr @540, i64 3 }) // CHECK-NEXT: %36 = call %"{{.*}}/runtime/internal/runtime.String" @"{{.*}}/runtime/internal/runtime.StringCat"(%"{{.*}}/runtime/internal/runtime.String" %35, %"{{.*}}/runtime/internal/runtime.String" %13) // CHECK-NEXT: %37 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) // CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" %36, ptr %37, align 8 diff --git a/cl/_testgo/tpinst/main.go b/cl/_testgo/tpinst/main.go index 5dc3772151..32a2a51dde 100644 --- a/cl/_testgo/tpinst/main.go +++ b/cl/_testgo/tpinst/main.go @@ -1,10 +1,7 @@ // LITTEST package main -// CHECK-NOT: @6 = private unnamed_addr constant [5 x i8] c"value", align 1 -// CHECK: @6 = private unnamed_addr constant [10 x i8] c"main.value", align 1 // CHECK: {{^}}@8 = private unnamed_addr constant [5 x i8] c"error", align 1{{$}} -// CHECK: {{^}}@15 = private unnamed_addr constant [22 x i8] c"interface{value() int}", align 1{{$}} // CHECK: {{^}}@16 = private unnamed_addr constant [5 x i8] c"value", align 1{{$}} type M[T interface{}] struct { @@ -15,12 +12,42 @@ type I[T interface{}] interface { Value() T } +func demo() { + var v1 I[int] = &M[int]{100} + + if v1.Value() != 100 { + panic("error") + } + + var v2 I[float64] = &M[float64]{100.1} + + if v2.Value() != 100.1 { + panic("error") + } + + if v1.(interface{ value() int }).value() != 100 { + panic("error") + } +} + +func main() { + demo() +} + +func (pt *M[T]) Value() T { + return pt.v +} + +func (pt *M[T]) value() T { + return pt.v +} + // CHECK-LABEL: define void @main.demo(){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %0 = call ptr @"{{.*}}/runtime/internal/runtime.AllocZ"(i64 8) // CHECK-NEXT: %1 = getelementptr inbounds %"main.M[int]", ptr %0, i32 0, i32 0 // CHECK-NEXT: store i64 100, ptr %1, align 8 -// CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @"*_llgo_main.M[int]") +// CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$Jvxc0PCI_drlfK7S5npMGdZkQLeRkQ_x2e2CifPE6w8", ptr @"*_llgo_main.M[int]") // CHECK-NEXT: %3 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %2, 0 // CHECK-NEXT: %4 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %3, ptr %0, 1 // CHECK-NEXT: %5 = call ptr @"{{.*}}/runtime/internal/runtime.IfacePtrData"(%"{{.*}}/runtime/internal/runtime.iface" %4) @@ -46,7 +73,7 @@ type I[T interface{}] interface { // CHECK-NEXT: %17 = call ptr @"{{.*}}/runtime/internal/runtime.AllocZ"(i64 8) // CHECK-NEXT: %18 = getelementptr inbounds %"main.M[float64]", ptr %17, i32 0, i32 0 // CHECK-NEXT: store double 1.001000e+02, ptr %18, align 8 -// CHECK-NEXT: %19 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @"*_llgo_main.M[float64]") +// CHECK-NEXT: %19 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$2dxw6yZ6V86Spb7J0dTDIoWqg7ba7UDXlAlpJv3-HLk", ptr @"*_llgo_main.M[float64]") // CHECK-NEXT: %20 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %19, 0 // CHECK-NEXT: %21 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %20, ptr %17, 1 // CHECK-NEXT: %22 = call ptr @"{{.*}}/runtime/internal/runtime.IfacePtrData"(%"{{.*}}/runtime/internal/runtime.iface" %21) @@ -70,7 +97,7 @@ type I[T interface{}] interface { // CHECK-EMPTY: // CHECK-NEXT: _llgo_4: ; preds = %_llgo_2 // CHECK-NEXT: %34 = call ptr @"{{.*}}/runtime/internal/runtime.IfaceType"(%"{{.*}}/runtime/internal/runtime.iface" %4) -// CHECK-NEXT: %35 = call i1 @"{{.*}}/runtime/internal/runtime.Implements"(ptr @"{{.*}}/cl/_testgo/tpinst.iface${{[-A-Za-z0-9_]+}}", ptr %34) +// CHECK-NEXT: %35 = call i1 @"{{.*}}/runtime/internal/runtime.Implements"(ptr @"{{.*}}/cl/_testgo/tpinst.iface$2sV9fFeqOv1SzesvwIdhTqCFzDT8ZX5buKUSAoHNSww", ptr %34) // CHECK-NEXT: br i1 %35, label %_llgo_7, label %_llgo_8 // CHECK-EMPTY: // CHECK-NEXT: _llgo_5: ; preds = %_llgo_7 @@ -85,7 +112,7 @@ type I[T interface{}] interface { // CHECK-EMPTY: // CHECK-NEXT: _llgo_7: ; preds = %_llgo_4 // CHECK-NEXT: %38 = extractvalue %"{{.*}}/runtime/internal/runtime.iface" %4, 1 -// CHECK-NEXT: %39 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"{{.*}}/cl/_testgo/tpinst.iface${{[-A-Za-z0-9_]+}}", ptr %34) +// CHECK-NEXT: %39 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"{{.*}}/cl/_testgo/tpinst.iface$2sV9fFeqOv1SzesvwIdhTqCFzDT8ZX5buKUSAoHNSww", ptr %34) // CHECK-NEXT: %40 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %39, 0 // CHECK-NEXT: %41 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %40, ptr %38, 1 // CHECK-NEXT: %42 = call ptr @"{{.*}}/runtime/internal/runtime.IfacePtrData"(%"{{.*}}/runtime/internal/runtime.iface" %41) @@ -101,7 +128,7 @@ type I[T interface{}] interface { // CHECK-NEXT: br i1 %51, label %_llgo_5, label %_llgo_6 // CHECK-EMPTY: // CHECK-NEXT: _llgo_8: ; preds = %_llgo_4 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr %34, %"{{.*}}/runtime/internal/runtime.String" { ptr @15, i64 22 }, %"{{.*}}/runtime/internal/runtime.String" { ptr @16, i64 5 }) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr @"_llgo_main.I[int]", ptr %34, ptr @"{{.*}}/cl/_testgo/tpinst.iface$2sV9fFeqOv1SzesvwIdhTqCFzDT8ZX5buKUSAoHNSww", %"{{.*}}/runtime/internal/runtime.String" { ptr @16, i64 5 }) // CHECK-NEXT: unreachable // CHECK-NEXT: } @@ -118,42 +145,12 @@ type I[T interface{}] interface { // CHECK-NEXT: ret void // CHECK-NEXT: } -func demo() { - var v1 I[int] = &M[int]{100} - - if v1.Value() != 100 { - panic("error") - } - - var v2 I[float64] = &M[float64]{100.1} - - if v2.Value() != 100.1 { - panic("error") - } - - if v1.(interface{ value() int }).value() != 100 { - panic("error") - } -} - // CHECK-LABEL: define void @main.main(){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: call void @main.demo() // CHECK-NEXT: ret void // CHECK-NEXT: } -func main() { - demo() -} - -func (pt *M[T]) Value() T { - return pt.v -} - -func (pt *M[T]) value() T { - return pt.v -} - // CHECK-LABEL: define linkonce i64 @"main.(*M[int]).Value"(ptr %0){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %1 = getelementptr inbounds %"main.M[int]", ptr %0, i32 0, i32 0 diff --git a/cl/_testrt/any/in.go b/cl/_testrt/any/in.go index e7a4412ac7..370e0cea8a 100644 --- a/cl/_testrt/any/in.go +++ b/cl/_testrt/any/in.go @@ -5,10 +5,20 @@ import ( "github.com/goplus/lib/c" ) -// CHECK: @1 = private unnamed_addr constant [29 x i8] c"*github.com/goplus/lib/c.Char", align 1 -// CHECK: @2 = private unnamed_addr constant [3 x i8] c"int", align 1 -// CHECK: @3 = private unnamed_addr constant [7 x i8] c"%s %d\0A\00", align 1 -// CHECK: @4 = private unnamed_addr constant [6 x i8] c"Hello\00", align 1 +// CHECK: {{^}}@2 = private unnamed_addr constant [7 x i8] c"%s %d\0A\00", align 1{{$}} +// CHECK: {{^}}@3 = private unnamed_addr constant [6 x i8] c"Hello\00", align 1{{$}} + +func hi(a any) *c.Char { + return a.(*c.Char) +} + +func incVal(a any) int { + return a.(int) + 1 +} + +func main() { + c.Printf(c.Str("%s %d\n"), hi(c.Str("Hello")), incVal(100)) +} // CHECK-LABEL: define ptr @main.hi(%"{{.*}}/runtime/internal/runtime.eface" %0){{.*}} { // CHECK-NEXT: _llgo_0: @@ -21,14 +31,10 @@ import ( // CHECK-NEXT: ret ptr %3 // CHECK-EMPTY: // CHECK-NEXT: _llgo_2: ; preds = %_llgo_0 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr %1, %"{{.*}}/runtime/internal/runtime.String" { ptr @1, i64 29 }, %"{{.*}}/runtime/internal/runtime.String" zeroinitializer) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr null, ptr %1, ptr @"*_llgo_int8", %"{{.*}}/runtime/internal/runtime.String" zeroinitializer) // CHECK-NEXT: unreachable // CHECK-NEXT: } -func hi(a any) *c.Char { - return a.(*c.Char) -} - // CHECK-LABEL: define i64 @main.incVal(%"{{.*}}/runtime/internal/runtime.eface" %0){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %1 = extractvalue %"{{.*}}/runtime/internal/runtime.eface" %0, 0 @@ -42,18 +48,10 @@ func hi(a any) *c.Char { // CHECK-NEXT: ret i64 %5 // CHECK-EMPTY: // CHECK-NEXT: _llgo_2: ; preds = %_llgo_0 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr %1, %"{{.*}}/runtime/internal/runtime.String" { ptr @2, i64 3 }, %"{{.*}}/runtime/internal/runtime.String" zeroinitializer) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr null, ptr %1, ptr @_llgo_int, %"{{.*}}/runtime/internal/runtime.String" zeroinitializer) // CHECK-NEXT: unreachable // CHECK-NEXT: } -func incVal(a any) int { - return a.(int) + 1 -} - -func main() { - c.Printf(c.Str("%s %d\n"), hi(c.Str("Hello")), incVal(100)) -} - // CHECK-LABEL: define void @main.init(){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %0 = load i1, ptr @"main.init$guard", align 1 @@ -69,11 +67,11 @@ func main() { // CHECK-LABEL: define void @main.main(){{.*}} { // CHECK-NEXT: _llgo_0: -// CHECK-NEXT: %0 = call ptr @main.hi(%"{{.*}}/runtime/internal/runtime.eface" { ptr @"*_llgo_int8", ptr @4 }) +// CHECK-NEXT: %0 = call ptr @main.hi(%"{{.*}}/runtime/internal/runtime.eface" { ptr @"*_llgo_int8", ptr @3 }) // CHECK-NEXT: %1 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 8) // CHECK-NEXT: store i64 100, ptr %1, align 8 // CHECK-NEXT: %2 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_int, ptr undef }, ptr %1, 1 // CHECK-NEXT: %3 = call i64 @main.incVal(%"{{.*}}/runtime/internal/runtime.eface" %2) -// CHECK-NEXT: %4 = call i32 (ptr, ...) @printf(ptr @3, ptr %0, i64 %3) +// CHECK-NEXT: %4 = call i32 (ptr, ...) @printf(ptr @2, ptr %0, i64 %3) // CHECK-NEXT: ret void // CHECK-NEXT: } diff --git a/cl/_testrt/funcdecl/in.go b/cl/_testrt/funcdecl/in.go index 2bc82e1ee9..203301731e 100644 --- a/cl/_testrt/funcdecl/in.go +++ b/cl/_testrt/funcdecl/in.go @@ -5,9 +5,38 @@ import ( "unsafe" ) -// CHECK: @4 = private unnamed_addr constant [39 x i8] c"struct{$f func(); $data unsafe.Pointer}", align 1 -// CHECK: @5 = private unnamed_addr constant [4 x i8] c"demo", align 1 -// CHECK: @6 = private unnamed_addr constant [5 x i8] c"hello", align 1 +// CHECK: {{^}}@4 = private unnamed_addr constant [4 x i8] c"demo", align 1{{$}} +// CHECK: {{^}}@5 = private unnamed_addr constant [5 x i8] c"hello", align 1{{$}} + +func check(fn func()) { + var a any = demo + var b any = fn + fn1 := a.(func()) + fn2 := b.(func()) + println(a, b, fn, fn1, fn2, demo) + println(closurePtr(a) == closurePtr(b)) +} + +func closurePtr(a any) unsafe.Pointer { + return (*rtype)(unsafe.Pointer(&a)).ptr.fn +} + +type rtype struct { + typ unsafe.Pointer + ptr *struct { + fn unsafe.Pointer + env unsafe.Pointer + } +} + +func demo() { + println("demo") +} + +func main() { + println("hello") + check(demo) +} // CHECK-LABEL: define void @main.check({ ptr, ptr } %0){{.*}} { // CHECK-NEXT: _llgo_0: @@ -29,7 +58,7 @@ import ( // CHECK-NEXT: br i1 %10, label %_llgo_3, label %_llgo_4 // CHECK-EMPTY: // CHECK-NEXT: _llgo_2: ; preds = %_llgo_0 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr %5, %"{{.*}}/runtime/internal/runtime.String" { ptr @4, i64 39 }, %"{{.*}}/runtime/internal/runtime.String" zeroinitializer) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr null, ptr %5, ptr @"_llgo_closure$b7Su1hWaFih-M0M9hMk6nO_RD1K_GQu5WjIXQp6Q2e8", %"{{.*}}/runtime/internal/runtime.String" zeroinitializer) // CHECK-NEXT: unreachable // CHECK-EMPTY: // CHECK-NEXT: _llgo_3: ; preds = %_llgo_1 @@ -58,19 +87,10 @@ import ( // CHECK-NEXT: ret void // CHECK-EMPTY: // CHECK-NEXT: _llgo_4: ; preds = %_llgo_1 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr %9, %"{{.*}}/runtime/internal/runtime.String" { ptr @4, i64 39 }, %"{{.*}}/runtime/internal/runtime.String" zeroinitializer) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr null, ptr %9, ptr @"_llgo_closure$b7Su1hWaFih-M0M9hMk6nO_RD1K_GQu5WjIXQp6Q2e8", %"{{.*}}/runtime/internal/runtime.String" zeroinitializer) // CHECK-NEXT: unreachable // CHECK-NEXT: } -func check(fn func()) { - var a any = demo - var b any = fn - fn1 := a.(func()) - fn2 := b.(func()) - println(a, b, fn, fn1, fn2, demo) - println(closurePtr(a) == closurePtr(b)) -} - // CHECK-LABEL: define ptr @main.closurePtr(%"{{.*}}/runtime/internal/runtime.eface" %0){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %1 = call ptr @"{{.*}}/runtime/internal/runtime.AllocZ"(i64 16) @@ -82,21 +102,9 @@ func check(fn func()) { // CHECK-NEXT: ret ptr %5 // CHECK-NEXT: } -func closurePtr(a any) unsafe.Pointer { - return (*rtype)(unsafe.Pointer(&a)).ptr.fn -} - -type rtype struct { - typ unsafe.Pointer - ptr *struct { - fn unsafe.Pointer - env unsafe.Pointer - } -} - // CHECK-LABEL: define void @main.demo(){{.*}} { // CHECK-NEXT: _llgo_0: -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintString"(%"{{.*}}/runtime/internal/runtime.String" { ptr @5, i64 4 }) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintString"(%"{{.*}}/runtime/internal/runtime.String" { ptr @4, i64 4 }) // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintByte"(i8 10) // CHECK-NEXT: ret void // CHECK-NEXT: } @@ -114,19 +122,10 @@ type rtype struct { // CHECK-NEXT: ret void // CHECK-NEXT: } -func demo() { - println("demo") -} - // CHECK-LABEL: define void @main.main(){{.*}} { // CHECK-NEXT: _llgo_0: -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintString"(%"{{.*}}/runtime/internal/runtime.String" { ptr @6, i64 5 }) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintString"(%"{{.*}}/runtime/internal/runtime.String" { ptr @5, i64 5 }) // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintByte"(i8 10) // CHECK-NEXT: call void @main.check({ ptr, ptr } { ptr @main.demo, ptr null }) // CHECK-NEXT: ret void // CHECK-NEXT: } - -func main() { - println("hello") - check(demo) -} diff --git a/cl/_testrt/makemap/in.go b/cl/_testrt/makemap/in.go index d7f35d1e62..8b901275fe 100644 --- a/cl/_testrt/makemap/in.go +++ b/cl/_testrt/makemap/in.go @@ -1,16 +1,13 @@ // LITTEST package main -// CHECK: @16 = private unnamed_addr constant [5 x i8] c"hello", align 1 -// CHECK: @17 = private unnamed_addr constant [5 x i8] c"world", align 1 -// CHECK: @18 = private unnamed_addr constant [4 x i8] c"llgo", align 1 -// CHECK: @19 = private unnamed_addr constant [1 x i8] c":", align 1 -// CHECK: @22 = private unnamed_addr constant [2 x i8] c"go", align 1 -// CHECK: @23 = private unnamed_addr constant [7 x i8] c"bad key", align 1 -// CHECK: @24 = private unnamed_addr constant [7 x i8] c"bad len", align 1 -// CHECK: @31 = private unnamed_addr constant [7 x i8] c"main.N1", align 1 -// CHECK: @33 = private unnamed_addr constant [6 x i8] c"main.K", align 1 -// CHECK: @40 = private unnamed_addr constant [7 x i8] c"main.K2", align 1 +// CHECK: {{^}}@16 = private unnamed_addr constant [5 x i8] c"hello", align 1{{$}} +// CHECK: {{^}}@17 = private unnamed_addr constant [5 x i8] c"world", align 1{{$}} +// CHECK: {{^}}@18 = private unnamed_addr constant [4 x i8] c"llgo", align 1{{$}} +// CHECK: {{^}}@19 = private unnamed_addr constant [1 x i8] c":", align 1{{$}} +// CHECK: {{^}}@22 = private unnamed_addr constant [2 x i8] c"go", align 1{{$}} +// CHECK: {{^}}@23 = private unnamed_addr constant [7 x i8] c"bad key", align 1{{$}} +// CHECK: {{^}}@24 = private unnamed_addr constant [7 x i8] c"bad len", align 1{{$}} func main() { make1() @@ -52,6 +49,93 @@ func make1() { } } +type N1 [1]int + +func make2() { + m2 := make(map[int]string) + println(m2, len(m2), m2 == nil, m2 != nil) + var m3 map[int]string + println(m3, len(m3), m3 == nil, m3 != nil) + + n := make(map[any]int) + n[N1{1}] = 100 + n[N1{2}] = 200 + n[N1{3}] = 300 + n[N1{2}] = -200 + for k, v := range n { + println(k.(N1)[0], v) + } +} + +type N struct { + n1 int8 + n2 int8 +} +type K [1]N +type K2 [1]*N + +func make3() { + var a any = K{N{1, 2}} + var b any = K{N{1, 2}} + println(a == b) + + m := make(map[any]int) + m[K{N{1, 2}}] = 100 + m[K{N{3, 4}}] = 200 + for k, v := range m { + println(k.(K)[0].n1, v) + } +} + +func make4() { + var a any = K2{&N{1, 2}} + var b any = K2{&N{1, 2}} + println(a == b) + + m := make(map[any]int) + m[K2{&N{1, 2}}] = 100 + m[K2{&N{3, 4}}] = 200 + for k, v := range m { + println(k.(K2)[0].n1, v) + } +} + +func make5() { + ch := make(chan int) + var a any = ch + var b any = ch + println(a == b) + m := make(map[chan int]int) + m[ch] = 100 + m[ch] = 200 + for k, v := range m { + println(k, v) + } +} + +type M map[int]string + +func make6() { + var m M + m = make(map[int]string) + m[1] = "hello" + for k, v := range m { + println(k, v) + } +} + +func make7() { + type N int + m := map[N]string{ + 1: "hello", + 2: "world", + } + for k, v := range m { + println(k, v) + } + println(m[1]) +} + // CHECK-LABEL: define void @main.init(){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %0 = load i1, ptr @"main.init$guard", align 1 @@ -253,8 +337,6 @@ func make1() { // CHECK-NEXT: br i1 %77, label %_llgo_5, label %_llgo_6 // CHECK-NEXT: } -type N1 [1]int - // CHECK-LABEL: define void @main.make2(){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %0 = call ptr @"{{.*}}/runtime/internal/runtime.MakeMap"(ptr @"map[_llgo_int]_llgo_string", i64 0) @@ -377,33 +459,10 @@ type N1 [1]int // CHECK-NEXT: br label %_llgo_1 // CHECK-EMPTY: // CHECK-NEXT: _llgo_8: ; preds = %_llgo_2 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr %39, %"{{.*}}/runtime/internal/runtime.String" { ptr @32, i64 44 }, %"{{.*}}/runtime/internal/runtime.String" zeroinitializer) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr null, ptr %39, ptr @_llgo_main.N1, %"{{.*}}/runtime/internal/runtime.String" zeroinitializer) // CHECK-NEXT: unreachable // CHECK-NEXT: } -func make2() { - m2 := make(map[int]string) - println(m2, len(m2), m2 == nil, m2 != nil) - var m3 map[int]string - println(m3, len(m3), m3 == nil, m3 != nil) - - n := make(map[any]int) - n[N1{1}] = 100 - n[N1{2}] = 200 - n[N1{3}] = 300 - n[N1{2}] = -200 - for k, v := range n { - println(k.(N1)[0], v) - } -} - -type N struct { - n1 int8 - n2 int8 -} -type K [1]N -type K2 [1]*N - // CHECK-LABEL: define void @main.make3(){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %0 = alloca [1 x %main.N], align 8 @@ -514,23 +573,10 @@ type K2 [1]*N // CHECK-NEXT: br label %_llgo_1 // CHECK-EMPTY: // CHECK-NEXT: _llgo_8: ; preds = %_llgo_2 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr %39, %"{{.*}}/runtime/internal/runtime.String" { ptr @39, i64 43 }, %"{{.*}}/runtime/internal/runtime.String" zeroinitializer) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr null, ptr %39, ptr @_llgo_main.K, %"{{.*}}/runtime/internal/runtime.String" zeroinitializer) // CHECK-NEXT: unreachable // CHECK-NEXT: } -func make3() { - var a any = K{N{1, 2}} - var b any = K{N{1, 2}} - println(a == b) - - m := make(map[any]int) - m[K{N{1, 2}}] = 100 - m[K{N{3, 4}}] = 200 - for k, v := range m { - println(k.(K)[0].n1, v) - } -} - // CHECK-LABEL: define void @main.make4(){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %0 = alloca [1 x ptr], align 8 @@ -646,23 +692,10 @@ func make3() { // CHECK-NEXT: br label %_llgo_1 // CHECK-EMPTY: // CHECK-NEXT: _llgo_8: ; preds = %_llgo_2 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr %43, %"{{.*}}/runtime/internal/runtime.String" { ptr @42, i64 44 }, %"{{.*}}/runtime/internal/runtime.String" zeroinitializer) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr null, ptr %43, ptr @_llgo_main.K2, %"{{.*}}/runtime/internal/runtime.String" zeroinitializer) // CHECK-NEXT: unreachable // CHECK-NEXT: } -func make4() { - var a any = K2{&N{1, 2}} - var b any = K2{&N{1, 2}} - println(a == b) - - m := make(map[any]int) - m[K2{&N{1, 2}}] = 100 - m[K2{&N{3, 4}}] = 200 - for k, v := range m { - println(k.(K2)[0].n1, v) - } -} - // CHECK-LABEL: define void @main.make5(){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %0 = call ptr @"{{.*}}/runtime/internal/runtime.NewChan"(i64 8, i64 0) @@ -718,21 +751,6 @@ func make4() { // CHECK-NEXT: br i1 %21, label %_llgo_2, label %_llgo_3 // CHECK-NEXT: } -func make5() { - ch := make(chan int) - var a any = ch - var b any = ch - println(a == b) - m := make(map[chan int]int) - m[ch] = 100 - m[ch] = 200 - for k, v := range m { - println(k, v) - } -} - -type M map[int]string - // CHECK-LABEL: define void @main.make6(){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %0 = call ptr @"{{.*}}/runtime/internal/runtime.MakeMap"(ptr @"map[_llgo_int]_llgo_string", i64 0) @@ -778,15 +796,6 @@ type M map[int]string // CHECK-NEXT: br i1 %15, label %_llgo_2, label %_llgo_3 // CHECK-NEXT: } -func make6() { - var m M - m = make(map[int]string) - m[1] = "hello" - for k, v := range m { - println(k, v) - } -} - // CHECK-LABEL: define void @main.make7(){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %0 = call ptr @"{{.*}}/runtime/internal/runtime.MakeMap"(ptr @"map[_llgo_main.N.7.0]_llgo_string", i64 2) @@ -841,15 +850,3 @@ func make6() { // CHECK-NEXT: %20 = extractvalue { i1, i64, %"{{.*}}/runtime/internal/runtime.String" } %19, 0 // CHECK-NEXT: br i1 %20, label %_llgo_2, label %_llgo_3 // CHECK-NEXT: } - -func make7() { - type N int - m := map[N]string{ - 1: "hello", - 2: "world", - } - for k, v := range m { - println(k, v) - } - println(m[1]) -} diff --git a/cl/_testrt/tpabi/in.go b/cl/_testrt/tpabi/in.go index 76493e4b8a..52ff69bdae 100644 --- a/cl/_testrt/tpabi/in.go +++ b/cl/_testrt/tpabi/in.go @@ -3,23 +3,10 @@ package main import "github.com/goplus/lib/c" -// CHECK: @0 = private unnamed_addr constant [1 x i8] c"a", align 1 -// CHECK: @1 = private unnamed_addr constant [18 x i8] c"main.T[string,int]", align 1 -// CHECK: @5 = private unnamed_addr constant [4 x i8] c"Info", align 1 -// CHECK: @11 = private unnamed_addr constant [5 x i8] c"hello", align 1 - -// CHECK-LABEL: define void @main.init(){{.*}} { -// CHECK-NEXT: _llgo_0: -// CHECK-NEXT: %0 = load i1, ptr @"main.init$guard", align 1 -// CHECK-NEXT: br i1 %0, label %_llgo_2, label %_llgo_1 -// CHECK-EMPTY: -// CHECK-NEXT: _llgo_1: ; preds = %_llgo_0 -// CHECK-NEXT: store i1 true, ptr @"main.init$guard", align 1 -// CHECK-NEXT: br label %_llgo_2 -// CHECK-EMPTY: -// CHECK-NEXT: _llgo_2: ; preds = %_llgo_1, %_llgo_0 -// CHECK-NEXT: ret void -// CHECK-NEXT: } +// CHECK: {{^}}@0 = private unnamed_addr constant [1 x i8] c"a", align 1{{$}} +// CHECK: {{^}}@5 = private unnamed_addr constant [4 x i8] c"Info", align 1{{$}} +// CHECK: {{^}}@10 = private unnamed_addr constant [5 x i8] c"hello", align 1{{$}} +// CHECK: {{^}}@12 = private unnamed_addr constant [54 x i8] c"{{.*}}/cl/_testrt/tpabi.T[string, int]", align 1{{$}} type T[M, N any] struct { m M @@ -45,6 +32,30 @@ func (t *K[N]) Advance(n int) *K[N] { return nil } +func main() { + var a any = T[string, int]{"a", 1} + println(a.(T[string, int]).m) + var i I = &T[string, int]{"hello", 100} + i.Demo() + + k := &K[int]{1, 2, 3, 4} + println(c.Advance(k, 1)) + println(k.Advance(1)) +} + +// CHECK-LABEL: define void @main.init(){{.*}} { +// CHECK-NEXT: _llgo_0: +// CHECK-NEXT: %0 = load i1, ptr @"main.init$guard", align 1 +// CHECK-NEXT: br i1 %0, label %_llgo_2, label %_llgo_1 +// CHECK-EMPTY: +// CHECK-NEXT: _llgo_1: ; preds = %_llgo_0 +// CHECK-NEXT: store i1 true, ptr @"main.init$guard", align 1 +// CHECK-NEXT: br label %_llgo_2 +// CHECK-EMPTY: +// CHECK-NEXT: _llgo_2: ; preds = %_llgo_1, %_llgo_0 +// CHECK-NEXT: ret void +// CHECK-NEXT: } + // CHECK-LABEL: define void @main.main(){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %0 = alloca %"main.T[string,int]", align 8 @@ -70,7 +81,7 @@ func (t *K[N]) Advance(n int) *K[N] { // CHECK-NEXT: %11 = call ptr @"{{.*}}/runtime/internal/runtime.AllocZ"(i64 24) // CHECK-NEXT: %12 = getelementptr inbounds %"main.T[string,int]", ptr %11, i32 0, i32 0 // CHECK-NEXT: %13 = getelementptr inbounds %"main.T[string,int]", ptr %11, i32 0, i32 1 -// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @11, i64 5 }, ptr %12, align 8 +// CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @10, i64 5 }, ptr %12, align 8 // CHECK-NEXT: store i64 100, ptr %13, align 8 // CHECK-NEXT: %14 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$BP0p_lUsEd-IbbtJVukGmgrdQkqzcoYzSiwgUvgFvUs", ptr @"*_llgo_main.T[string,int]") // CHECK-NEXT: %15 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %14, 0 @@ -102,21 +113,10 @@ func (t *K[N]) Advance(n int) *K[N] { // CHECK-NEXT: ret void // CHECK-EMPTY: // CHECK-NEXT: _llgo_2: ; preds = %_llgo_0 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr %6, %"{{.*}}/runtime/internal/runtime.String" { ptr @10, i64 54 }, %"{{.*}}/runtime/internal/runtime.String" zeroinitializer) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr null, ptr %6, ptr @"_llgo_main.T[string,int]", %"{{.*}}/runtime/internal/runtime.String" zeroinitializer) // CHECK-NEXT: unreachable // CHECK-NEXT: } -func main() { - var a any = T[string, int]{"a", 1} - println(a.(T[string, int]).m) - var i I = &T[string, int]{"hello", 100} - i.Demo() - - k := &K[int]{1, 2, 3, 4} - println(c.Advance(k, 1)) - println(k.Advance(1)) -} - // CHECK-LABEL: define linkonce void @"main.T[string,int].Info"(%"main.T[string,int]" %0){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %1 = alloca %"main.T[string,int]", align 8 @@ -149,7 +149,7 @@ func main() { // CHECK-LABEL: define linkonce void @"main.(*T[string,int]).Info"(ptr %0){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %1 = icmp eq ptr %0, null -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicWrapNilPointer"(i1 %1, %"{{.*}}/runtime/internal/runtime.String" { ptr @10, i64 54 }, %"{{.*}}/runtime/internal/runtime.String" { ptr @5, i64 4 }) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicWrapNilPointer"(i1 %1, %"{{.*}}/runtime/internal/runtime.String" { ptr @12, i64 54 }, %"{{.*}}/runtime/internal/runtime.String" { ptr @5, i64 4 }) // CHECK-NEXT: %2 = load %"main.T[string,int]", ptr %0, align 8 // CHECK-NEXT: call void @"main.T[string,int].Info"(%"main.T[string,int]" %2) // CHECK-NEXT: ret void diff --git a/cl/_testrt/typed/in.go b/cl/_testrt/typed/in.go index 7eefecc701..a03b85c8be 100644 --- a/cl/_testrt/typed/in.go +++ b/cl/_testrt/typed/in.go @@ -1,8 +1,21 @@ // LITTEST package main -// CHECK: @0 = private unnamed_addr constant [5 x i8] c"hello", align 1 -// CHECK: @1 = private unnamed_addr constant [6 x i8] c"main.T", align 1 +// CHECK: {{^}}@0 = private unnamed_addr constant [5 x i8] c"hello", align 1{{$}} + +type T string +type A [2]int + +func main() { + var v any = T("hello") + println(v.(T)) + s, ok := v.(string) + println(s, ok) + + var a any = A{1, 2} + ar, ok := a.(A) + println(ar[0], ar[1], ok) +} // CHECK-LABEL: define void @main.init(){{.*}} { // CHECK-NEXT: _llgo_0: @@ -17,9 +30,6 @@ package main // CHECK-NEXT: ret void // CHECK-NEXT: } -type T string -type A [2]int - // CHECK-LABEL: define void @main.main(){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %0 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) @@ -39,7 +49,7 @@ type A [2]int // CHECK-NEXT: br i1 %7, label %_llgo_3, label %_llgo_4 // CHECK-EMPTY: // CHECK-NEXT: _llgo_2: ; preds = %_llgo_0 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr %2, %"{{.*}}/runtime/internal/runtime.String" { ptr @3, i64 41 }, %"{{.*}}/runtime/internal/runtime.String" zeroinitializer) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr null, ptr %2, ptr @_llgo_main.T, %"{{.*}}/runtime/internal/runtime.String" zeroinitializer) // CHECK-NEXT: unreachable // CHECK-EMPTY: // CHECK-NEXT: _llgo_3: ; preds = %_llgo_1 @@ -103,14 +113,3 @@ type A [2]int // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintByte"(i8 10) // CHECK-NEXT: ret void // CHECK-NEXT: } - -func main() { - var v any = T("hello") - println(v.(T)) - s, ok := v.(string) - println(s, ok) - - var a any = A{1, 2} - ar, ok := a.(A) - println(ar[0], ar[1], ok) -} diff --git a/runtime/internal/runtime/errors.go b/runtime/internal/runtime/errors.go index 7b6776d99a..90e5267dd1 100644 --- a/runtime/internal/runtime/errors.go +++ b/runtime/internal/runtime/errors.go @@ -164,36 +164,13 @@ type TypeAssertionError struct { func (*TypeAssertionError) RuntimeError() {} -func PanicTypeAssert(concrete *_type, asserted string, missingMethod string) { - if concrete == nil { - panic(errorString("interface conversion: interface is nil, not " + asserted)) - } - if missingMethod != "" { - panic(errorString("interface conversion: " + concrete.String() + " is not " + asserted + ": missing method " + missingMethod)) - } - cs := concrete.String() - msg := "interface conversion: interface is " + cs + ", not " + asserted - if sameTypeAssertName(concrete, cs, asserted) { - msg += " (types from different scopes)" - } - panic(errorString(msg)) -} - -func sameTypeAssertName(concrete *_type, concreteString, asserted string) bool { - if concreteString == asserted { - return true - } - pkg := pkgpath(concrete) - return pkg != "" && hasPrefix(asserted, pkg+".") && typeNameSuffix(concreteString) == typeNameSuffix(asserted) -} - -func typeNameSuffix(name string) string { - for i := len(name) - 1; i >= 0; i-- { - if name[i] == '.' { - return name[i+1:] - } - } - return name +func PanicTypeAssert(source, concrete, asserted *_type, missingMethod string) { + panic(&TypeAssertionError{ + _interface: source, + concrete: concrete, + asserted: asserted, + missingMethod: missingMethod, + }) } func (e *TypeAssertionError) Error() string { diff --git a/ssa/interface.go b/ssa/interface.go index 1fde542203..c2cf57ad0d 100644 --- a/ssa/interface.go +++ b/ssa/interface.go @@ -388,7 +388,13 @@ func (b Builder) TypeAssert(x Expr, assertedTyp Type, commaOk bool) Expr { blks := b.Func.MakeBlocks(2) b.If(eq, blks[0], blks[1]) b.SetBlockEx(blks[1], AtEnd, false) - b.Call(b.Pkg.rtFunc("PanicTypeAssert"), tx, b.Str(assertedTyp.RawType().String()), b.Str(typeAssertMissingMethod(assertedTyp))) + var source Expr + if rawIntf, ok := x.RawType().Underlying().(*types.Interface); ok && rawIntf.NumMethods() > 0 { + source = b.abiType(x.RawType()) + } else { + source = b.Prog.Nil(b.Prog.AbiTypePtr()) + } + b.Call(b.Pkg.rtFunc("PanicTypeAssert"), source, tx, tabi, b.Str(typeAssertMissingMethod(assertedTyp))) b.Unreachable() b.SetBlockEx(blks[0], AtEnd, false) b.blk.last = blks[0].last diff --git a/test/go/interface_type_assert_panic_test.go b/test/go/interface_type_assert_panic_test.go index 7d0870a663..89b722c74e 100644 --- a/test/go/interface_type_assert_panic_test.go +++ b/test/go/interface_type_assert_panic_test.go @@ -8,6 +8,8 @@ type typeAssertInterface interface { type typeAssertScopedT struct{} +type typeAssertResult int + var typeAssertScopedValue any func typeAssertValue(v any) any { @@ -26,6 +28,16 @@ func TestInterfaceAssertToConcretePanicsWithRuntimeError(t *testing.T) { }) } +func TestGenericNilInterfaceAssertMentionsSourceType(t *testing.T) { + expectPanicContaining(t, "interface { TypeAssertValue() gotest.typeAssertResult }", func() { + typeAssertGenericNil[typeAssertResult]() + }) +} + +func typeAssertGenericNil[T any]() { + _ = interface{ TypeAssertValue() T }(nil).(T) +} + func TestInterfaceAssertRejectsSameNameTypesFromDifferentScopes(t *testing.T) { typeAssertAssignLocalT() typeAssertLocalToLocalT(t) diff --git a/test/goroot/xfail.yaml b/test/goroot/xfail.yaml index 02ceb84a6d..0c2f3978d1 100644 --- a/test/goroot/xfail.yaml +++ b/test/goroot/xfail.yaml @@ -1373,20 +1373,6 @@ xfails: directive: runoutput case: rangegen.go reason: current main goroot runoutput failure on darwin/arm64 - - platform: darwin/arm64 - directive: run - case: typeparam/mdempsky/16.go - reason: nil-interface assertion panic implements runtime.Error but the message lacks the source interface type and prints the command-line-arguments package path on darwin/arm64 - - version: go1.24 - platform: linux/amd64 - directive: run - case: typeparam/mdempsky/16.go - reason: nil-interface assertion panic implements runtime.Error but the message lacks the source interface type and prints the command-line-arguments package path on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: typeparam/mdempsky/16.go - reason: nil-interface assertion panic implements runtime.Error but the message lacks the source interface type and prints the command-line-arguments package path on linux/amd64 - version: go1.24 platform: linux/amd64 directive: runoutput @@ -1659,10 +1645,6 @@ xfails: directive: run case: fixedbugs/issue57823.go reason: go1.26 goroot run failure on linux/amd64 - - platform: darwin/arm64 - directive: run - case: fixedbugs/issue26094.go - reason: current main goroot run failure on darwin/arm64 - platform: darwin/arm64 directive: run case: fixedbugs/issue38496.go @@ -1677,10 +1659,6 @@ xfails: directive: run case: fixedbugs/issue73920.go reason: go1.26 goroot run failure on darwin/arm64 - - platform: linux/amd64 - directive: run - case: fixedbugs/issue26094.go - reason: current main goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run @@ -1708,14 +1686,6 @@ xfails: directive: rundir case: fixedbugs/issue24693.go reason: llgo constructs cross-package itabs incorrectly for unexported interface methods - - version: go1.26 - directive: rundir - case: fixedbugs/issue18911.go - reason: llgo interface-conversion diagnostics omit the same-looking types from different packages detail - - version: go1.26 - directive: rundir - case: interface/embed3.go - reason: llgo interface-conversion diagnostics report the import path instead of the package name - directive: run case: fixedbugs/issue52072.go reason: llgo loses the named return value when a deferred nil-receiver method panic is recovered From fb72c4cba82fbeddd9cfcbd0a1021c93818f0174 Mon Sep 17 00:00:00 2001 From: Li Jie Date: Mon, 10 Aug 2026 11:14:31 +0800 Subject: [PATCH 06/21] runtime: recover SIGBUS memory faults --- runtime/internal/runtime/z_signal.go | 10 +++-- runtime/internal/runtime/z_signal_darwin.go | 7 +++ runtime/internal/runtime/z_signal_linux.go | 7 +++ runtime/internal/runtime/z_signal_other.go | 7 +++ test/go/recover_fault_unix_test.go | 49 +++++++++++++++++++++ 5 files changed, 77 insertions(+), 3 deletions(-) create mode 100644 runtime/internal/runtime/z_signal_darwin.go create mode 100644 runtime/internal/runtime/z_signal_linux.go create mode 100644 runtime/internal/runtime/z_signal_other.go create mode 100644 test/go/recover_fault_unix_test.go diff --git a/runtime/internal/runtime/z_signal.go b/runtime/internal/runtime/z_signal.go index 1283dff626..e0e98bce9a 100644 --- a/runtime/internal/runtime/z_signal.go +++ b/runtime/internal/runtime/z_signal.go @@ -38,11 +38,15 @@ const ( // For wasm platform compatibility, signal handling is excluded via build tags. // See PR #1059 for wasm platform requirements. func init() { - signal.Signal(SIGSEGV, func(v c.Int) { - if v == SIGSEGV { + handleFault := func(v c.Int) { + if v == SIGSEGV || v == SIGBUS { panic(errorString("invalid memory address or nil pointer dereference")) } var buf [20]byte panic(errorString("unexpected signal value: " + string(itoa(buf[:], uint64(v))))) - }) + } + signal.Signal(SIGSEGV, handleFault) + if SIGBUS != 0 { + signal.Signal(SIGBUS, handleFault) + } } diff --git a/runtime/internal/runtime/z_signal_darwin.go b/runtime/internal/runtime/z_signal_darwin.go new file mode 100644 index 0000000000..d34ee86607 --- /dev/null +++ b/runtime/internal/runtime/z_signal_darwin.go @@ -0,0 +1,7 @@ +//go:build darwin && !wasm && !baremetal + +package runtime + +import c "github.com/goplus/llgo/runtime/internal/clite" + +const SIGBUS = c.Int(0xa) diff --git a/runtime/internal/runtime/z_signal_linux.go b/runtime/internal/runtime/z_signal_linux.go new file mode 100644 index 0000000000..ff74f64db4 --- /dev/null +++ b/runtime/internal/runtime/z_signal_linux.go @@ -0,0 +1,7 @@ +//go:build linux && !wasm && !baremetal + +package runtime + +import c "github.com/goplus/llgo/runtime/internal/clite" + +const SIGBUS = c.Int(0x7) diff --git a/runtime/internal/runtime/z_signal_other.go b/runtime/internal/runtime/z_signal_other.go new file mode 100644 index 0000000000..5be18c7bb6 --- /dev/null +++ b/runtime/internal/runtime/z_signal_other.go @@ -0,0 +1,7 @@ +//go:build !darwin && !linux && !wasm && !baremetal + +package runtime + +import c "github.com/goplus/llgo/runtime/internal/clite" + +const SIGBUS = c.Int(0) diff --git a/test/go/recover_fault_unix_test.go b/test/go/recover_fault_unix_test.go new file mode 100644 index 0000000000..96ecaa2a91 --- /dev/null +++ b/test/go/recover_fault_unix_test.go @@ -0,0 +1,49 @@ +//go:build linux || darwin + +package gotest + +import ( + "runtime/debug" + "syscall" + "testing" +) + +func faultCopy(dst, src []byte) (n int, err error) { + defer func() { + if r, ok := recover().(error); ok { + err = r + } + }() + + for i := 0; i < len(dst) && i < len(src); i++ { + dst[i] = src[i] + n++ + } + return +} + +func TestRecoverAfterFaultPreservesNamedResult(t *testing.T) { + old := debug.SetPanicOnFault(true) + defer debug.SetPanicOnFault(old) + + size := syscall.Getpagesize() + data, err := syscall.Mmap(-1, 0, 16*size, syscall.PROT_READ|syscall.PROT_WRITE, syscall.MAP_ANON|syscall.MAP_PRIVATE) + if err != nil { + t.Fatalf("mmap: %v", err) + } + defer syscall.Munmap(data) + + hole := data[len(data)/2 : 3*(len(data)/4)] + if err := syscall.Mprotect(hole, syscall.PROT_NONE); err != nil { + t.Fatalf("mprotect: %v", err) + } + + const offset = 5 + n, err := faultCopy(data[offset:], make([]byte, len(data))) + if err == nil { + t.Fatal("no error from copy across memory hole") + } + if want := len(data)/2 - offset; n != want { + t.Fatalf("copy returned %d, want %d", n, want) + } +} From 16aab702c7834b192db85301b04b4813b9ef08a5 Mon Sep 17 00:00:00 2001 From: Li Jie Date: Mon, 10 Aug 2026 11:14:31 +0800 Subject: [PATCH 07/21] test/goroot: enable panic and recover cases --- test/goroot/xfail.yaml | 53 ------------------------------------------ 1 file changed, 53 deletions(-) diff --git a/test/goroot/xfail.yaml b/test/goroot/xfail.yaml index 0c2f3978d1..1cf72243aa 100644 --- a/test/goroot/xfail.yaml +++ b/test/goroot/xfail.yaml @@ -1231,22 +1231,6 @@ flakes: directive: run case: init1.go reason: linux/amd64 goroot run can either pass or expose incomplete runtime initialization - - platform: darwin/arm64 - directive: run - case: recover2.go - reason: darwin/arm64 goroot run can either pass or expose incomplete recover semantics - - platform: linux/amd64 - directive: run - case: recover2.go - reason: linux/amd64 goroot run can either pass or expose incomplete recover semantics - - platform: darwin/arm64 - directive: run - case: zerodivide.go - reason: darwin/arm64 goroot run can either pass or expose incomplete integer divide panic semantics - - platform: linux/amd64 - directive: run - case: zerodivide.go - reason: linux/amd64 goroot run can either pass or expose incomplete integer divide panic semantics - platform: darwin/arm64 directive: run case: deferfin.go @@ -1399,10 +1383,6 @@ xfails: directive: run case: recover1.go reason: latest main goroot run failure on darwin/arm64 - - platform: darwin/arm64 - directive: run - case: recover4.go - reason: latest main goroot run failure on darwin/arm64 - platform: darwin/arm64 directive: run case: stackobj.go @@ -1545,11 +1525,6 @@ xfails: directive: run case: fixedbugs/issue4562.go reason: panic/fault statement-line granularity in untracked functions (P4b prebuilt pcline) - - version: go1.24 - platform: linux/amd64 - directive: run - case: recover4.go - reason: go1.24 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run @@ -1560,11 +1535,6 @@ xfails: directive: run case: recover1.go reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: recover4.go - reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run @@ -1649,26 +1619,6 @@ xfails: directive: run case: fixedbugs/issue38496.go reason: current main goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue73917.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue73920.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue73917.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue73920.go - reason: go1.26 goroot run failure on linux/amd64 - platform: linux/amd64 directive: run case: fixedbugs/issue38496.go @@ -1686,6 +1636,3 @@ xfails: directive: rundir case: fixedbugs/issue24693.go reason: llgo constructs cross-package itabs incorrectly for unexported interface methods - - directive: run - case: fixedbugs/issue52072.go - reason: llgo loses the named return value when a deferred nil-receiver method panic is recovered From 2138523b1fd96ddacfa52e3acae15c0a9954fc2b Mon Sep 17 00:00:00 2001 From: Li Jie Date: Mon, 10 Aug 2026 19:57:34 +0800 Subject: [PATCH 08/21] test/go: cover remaining nested recover semantics --- test/go/recover_defer_fixedbugs_test.go | 149 ++++++++++++++++++++++++ 1 file changed, 149 insertions(+) diff --git a/test/go/recover_defer_fixedbugs_test.go b/test/go/recover_defer_fixedbugs_test.go index 1f04b3a394..15cc6a838a 100644 --- a/test/go/recover_defer_fixedbugs_test.go +++ b/test/go/recover_defer_fixedbugs_test.go @@ -1,6 +1,7 @@ package gotest import ( + "reflect" "runtime" "strings" "testing" @@ -67,6 +68,154 @@ func TestRecoverFixedbugNestedDeferInDeferredFuncDoesNotRecover(t *testing.T) { } } +func fixedbugCaptureRecover(dst *any) { + *dst = recover() +} + +func TestRecoverNestedDeferredBuiltinRecoversOuterPanic(t *testing.T) { + outer := any("unset") + func() { + defer fixedbugCaptureRecover(&outer) + defer func() { + defer recover() + }() + panic("outer") + }() + if outer != nil { + t.Fatalf("outer recover = %v, want nil after nested deferred recover", outer) + } +} + +func TestRecoverNestedDeferredBuiltinAfterInnerRecover(t *testing.T) { + outer := any("unset") + inner := any("unset") + func() { + defer fixedbugCaptureRecover(&outer) + defer func() { + defer recover() + defer fixedbugCaptureRecover(&inner) + panic("inner") + }() + panic("outer") + }() + if inner != "inner" { + t.Fatalf("inner recover = %v, want inner", inner) + } + if outer != nil { + t.Fatalf("outer recover = %v, want nil after nested deferred recover", outer) + } +} + +func TestRecoverNestedDeferredBuiltinBeforeInnerRecover(t *testing.T) { + outer := any("unset") + inner := any("unset") + func() { + defer fixedbugCaptureRecover(&outer) + defer func() { + defer fixedbugCaptureRecover(&inner) + defer recover() + panic("inner") + }() + panic("outer") + }() + if inner != "inner" { + t.Fatalf("inner recover = %v, want inner", inner) + } + if outer != "outer" { + t.Fatalf("outer recover = %v, want outer", outer) + } +} + +type fixedbugNestedPanicInterface interface { + panicInner() +} + +type fixedbugNestedPanicValue struct{} + +func (fixedbugNestedPanicValue) panicInner() { + panic("inner") +} + +var fixedbugNestedPanicRecover any + +func fixedbugRecoverNestedPanic() { + defer func() { + fixedbugNestedPanicRecover = recover() + }() + var v fixedbugNestedPanicInterface = fixedbugNestedPanicValue{} + v.panicInner() +} + +type fixedbugOuterRecoverInterface interface { + recoverOuter() +} + +type fixedbugOuterRecoverValue struct{} + +var fixedbugOuterPanicRecover any + +func (fixedbugOuterRecoverValue) recoverOuter() { + fixedbugRecoverNestedPanic() + fixedbugOuterPanicRecover = recover() +} + +func TestRecoverOuterPanicAfterNestedPanicIsRecovered(t *testing.T) { + fixedbugNestedPanicRecover = nil + fixedbugOuterPanicRecover = nil + func() { + var v fixedbugOuterRecoverInterface = fixedbugOuterRecoverValue{} + defer v.recoverOuter() + panic("outer") + }() + if fixedbugNestedPanicRecover != "inner" { + t.Fatalf("nested recover = %v, want inner", fixedbugNestedPanicRecover) + } + if fixedbugOuterPanicRecover != "outer" { + t.Fatalf("outer recover = %v, want outer", fixedbugOuterPanicRecover) + } +} + +type fixedbugReflectRecoverValue struct{} + +var fixedbugReflectMethodRecover any + +func (*fixedbugReflectRecoverValue) RecoverValue() { + fixedbugReflectMethodRecover = recover() +} + +func TestRecoverDeferredReflectMethodWrappers(t *testing.T) { + tests := []struct { + name string + run func(*fixedbugReflectRecoverValue) + }{ + { + name: "method value", + run: func(v *fixedbugReflectRecoverValue) { + f := reflect.ValueOf(v).Method(0).Interface().(func()) + defer f() + panic("method value") + }, + }, + { + name: "method expression", + run: func(v *fixedbugReflectRecoverValue) { + f := reflect.TypeOf(v).Method(0).Func.Interface().(func(*fixedbugReflectRecoverValue)) + defer f(v) + panic("method expression") + }, + }, + } + for _, test := range tests { + t.Run(test.name, func(t *testing.T) { + fixedbugReflectMethodRecover = nil + test.run(&fixedbugReflectRecoverValue{}) + if fixedbugReflectMethodRecover != test.name { + t.Fatalf("reflect recover = %v, want %q", fixedbugReflectMethodRecover, test.name) + } + }) + } +} + var fixedbugReturnedRecover any func fixedbugReturnedRecoverFunc() func() { From 3fb85f573494e8fa34afd852c510945bec70333a Mon Sep 17 00:00:00 2001 From: Li Jie Date: Mon, 10 Aug 2026 20:16:20 +0800 Subject: [PATCH 09/21] test/go: cover reflected recover wrappers --- test/go/recover_defer_fixedbugs_test.go | 33 +++++++++++++++++++++++++ 1 file changed, 33 insertions(+) diff --git a/test/go/recover_defer_fixedbugs_test.go b/test/go/recover_defer_fixedbugs_test.go index 15cc6a838a..e0e97a825c 100644 --- a/test/go/recover_defer_fixedbugs_test.go +++ b/test/go/recover_defer_fixedbugs_test.go @@ -216,6 +216,39 @@ func TestRecoverDeferredReflectMethodWrappers(t *testing.T) { } } +func TestRecoverDeferredReflectMakeFunc(t *testing.T) { + got := any("unset") + f := reflect.MakeFunc(reflect.TypeOf((func())(nil)), func([]reflect.Value) []reflect.Value { + got = recover() + return nil + }).Interface().(func()) + func() { + defer f() + panic("make func") + }() + if got != "make func" { + t.Fatalf("reflect MakeFunc recover = %v, want make func", got) + } +} + +func fixedbugReflectIndirectRecover() { + fixedbugReflectMethodRecover = recover() +} + +func TestRecoverReflectCallRemainsIndirect(t *testing.T) { + fixedbugReflectMethodRecover = any("unset") + func() { + defer fixedbugCaptureRecover(&fixedbugReflectMethodRecover) + defer func() { + reflect.ValueOf(fixedbugReflectIndirectRecover).Call(nil) + }() + panic("outer") + }() + if fixedbugReflectMethodRecover != "outer" { + t.Fatalf("outer recover = %v, want outer", fixedbugReflectMethodRecover) + } +} + var fixedbugReturnedRecover any func fixedbugReturnedRecoverFunc() func() { From 96f90110c86fc8cc6e243f52270d1c3c67844332 Mon Sep 17 00:00:00 2001 From: Li Jie Date: Mon, 10 Aug 2026 20:21:22 +0800 Subject: [PATCH 10/21] runtime: preserve nested recover ownership --- runtime/internal/runtime/runtime2.go | 1 + runtime/internal/runtime/z_baremetal.go | 7 +++- runtime/internal/runtime/z_default.go | 3 ++ runtime/internal/runtime/z_rt.go | 50 +++++++++++++++++++------ ssa/eh.go | 8 +++- 5 files changed, 54 insertions(+), 15 deletions(-) diff --git a/runtime/internal/runtime/runtime2.go b/runtime/internal/runtime/runtime2.go index ee18851f31..95e18caa2c 100644 --- a/runtime/internal/runtime/runtime2.go +++ b/runtime/internal/runtime/runtime2.go @@ -42,6 +42,7 @@ type g struct { panic_ unsafe.Pointer panicPCs panicPCStore recoverFrame unsafe.Pointer + recoverPanic unsafe.Pointer m *m atomicstatus uint32 diff --git a/runtime/internal/runtime/z_baremetal.go b/runtime/internal/runtime/z_baremetal.go index 3669a6ffbc..5fe5d37d27 100644 --- a/runtime/internal/runtime/z_baremetal.go +++ b/runtime/internal/runtime/z_baremetal.go @@ -15,13 +15,16 @@ var ( // Rethrow rethrows a panic. // In baremetal single-threaded environment, we use longjmp to execute defers. -// Note: recover() will return nil for now (panic value not stored). func Rethrow(link *Defer) { + gp := getg() + if ptr := gp.panic_; gp.panicIsSuspended(ptr) { + return + } if link == nil { c.Printf(c.Str("fatal error\n")) c.Exit(2) } else { - if ptr := getg().panic_; ptr != nil && link == GetThreadDefer() { + if ptr := gp.panic_; ptr != nil && link == GetThreadDefer() { node := (*panicNode)(ptr) node.moveToDefer(link) } diff --git a/runtime/internal/runtime/z_default.go b/runtime/internal/runtime/z_default.go index fc88e4bc38..f32b95a5bb 100644 --- a/runtime/internal/runtime/z_default.go +++ b/runtime/internal/runtime/z_default.go @@ -19,6 +19,9 @@ var ( func Rethrow(link *Defer) { gp := getg() if ptr := gp.panic_; ptr != nil { + if gp.panicIsSuspended(ptr) { + return + } if link == nil { node := (*panicNode)(ptr) TracePanic(node.arg) diff --git a/runtime/internal/runtime/z_rt.go b/runtime/internal/runtime/z_rt.go index bc7cf9ae84..33904a257f 100644 --- a/runtime/internal/runtime/z_rt.go +++ b/runtime/internal/runtime/z_rt.go @@ -45,12 +45,16 @@ type panicNode struct { // unwinding that frame has been replaced by this newer panic and must not // resume if the newer panic is recovered farther down the defer chain. func (node *panicNode) moveToDefer(link *Defer) { + gp := getg() for node.prev != nil { prev := (*panicNode)(node.prev) if prev.defer_ != link { break } node.prev = prev.prev + if gp.recoverPanic == unsafe.Pointer(prev) { + gp.recoverPanic = nil + } c.Free(unsafe.Pointer(prev)) } node.defer_ = link @@ -62,14 +66,12 @@ func Recover(token unsafe.Pointer) (ret any) { if token == nil || token != gp.recoverFrame { return nil } - ptr := gp.panic_ - if ptr != nil { + ptr := gp.recoverPanic + if ptr != nil && ptr == gp.panic_ { node := (*panicNode)(ptr) - if node.defer_ != gp.defer_ { - return nil - } gp.panic_ = node.prev gp.recoverFrame = nil + gp.recoverPanic = nil ret = node.arg c.Free(unsafe.Pointer(node)) if PanicRecovered != nil { @@ -91,17 +93,28 @@ func Recover(token unsafe.Pointer) (ret any) { } // StartRecoverFrame enables direct recover calls made by the deferred function -// currently being invoked from frame. -func StartRecoverFrame(frame unsafe.Pointer) unsafe.Pointer { +// currently being invoked from frame. The eligible panic is captured here, +// while the runtime is still executing the defer frame that selected it. A +// nested defer frame can then distinguish its own panic from an outer panic +// suspended in the direct deferred activation. This is LLGo's explicit-defer +// counterpart to gorecover locating the matching _panic through stack frames. +func StartRecoverFrame(frame unsafe.Pointer) (oldFrame, oldPanic unsafe.Pointer) { gp := getg() - old := gp.recoverFrame + oldFrame = gp.recoverFrame + oldPanic = gp.recoverPanic gp.recoverFrame = frame - return old + gp.recoverPanic = nil + if ptr := gp.panic_; ptr != nil && (*panicNode)(ptr).defer_ == gp.defer_ { + gp.recoverPanic = ptr + } + return } // EndRecoverFrame restores direct recover permission after a deferred call. -func EndRecoverFrame(frame unsafe.Pointer) { - getg().recoverFrame = frame +func EndRecoverFrame(frame, panic_ unsafe.Pointer) { + gp := getg() + gp.recoverFrame = frame + gp.recoverPanic = panic_ } // BindRecoverFrame replaces a deferred function's code token with the unique @@ -125,6 +138,21 @@ func StartRecoverFrameAlias(from, to unsafe.Pointer) unsafe.Pointer { return old } +// EndRecoverFrameAlias restores only the direct-call token. Transparent +// wrappers share their caller's eligible panic rather than opening a nested +// defer scope. +func EndRecoverFrameAlias(frame unsafe.Pointer) { + getg().recoverFrame = frame +} + +// panicIsSuspended reports whether ptr belongs to an outer panic whose direct +// deferred function is still running. It must not resume from one of that +// function's nested defer frames; the outer dispatcher resumes it after the +// direct call returns and restores its caller's recover scope. +func (gp *g) panicIsSuspended(ptr unsafe.Pointer) bool { + return ptr != nil && ptr == gp.recoverPanic +} + // RecoverMark, set by the public runtime package, records the recovering // frame for panic-snapshot splicing. var RecoverMark func() diff --git a/ssa/eh.go b/ssa/eh.go index 5ef41a36af..3c1726b6c9 100644 --- a/ssa/eh.go +++ b/ssa/eh.go @@ -596,7 +596,11 @@ func (b Builder) callRecoverScopedDefer(fn Expr, mayRecover bool, call func()) { } prev := b.Call(b.Pkg.rtFunc("StartRecoverFrame"), token) call() - b.Call(b.Pkg.rtFunc("EndRecoverFrame"), prev) + b.Call( + b.Pkg.rtFunc("EndRecoverFrame"), + b.getField(prev, 0), + b.getField(prev, 1), + ) } // CallRecoverAlias invokes fn through a compiler-generated wrapper while @@ -612,7 +616,7 @@ func (b Builder) CallRecoverAlias(from Expr, mayRecover bool, fn Expr, buildCall token, ) ret := buildCall(b, fn, args...) - b.Call(b.Pkg.rtFunc("EndRecoverFrame"), prev) + b.Call(b.Pkg.rtFunc("EndRecoverFrameAlias"), prev) return ret } From e2dcfcd6623476baf8917dc56c9d258e5634cadc Mon Sep 17 00:00:00 2001 From: Li Jie Date: Mon, 10 Aug 2026 20:24:25 +0800 Subject: [PATCH 11/21] reflect: keep recover through generated wrappers --- runtime/internal/lib/reflect/makefunc.go | 39 +++++++++++++++++++----- 1 file changed, 32 insertions(+), 7 deletions(-) diff --git a/runtime/internal/lib/reflect/makefunc.go b/runtime/internal/lib/reflect/makefunc.go index 09fd3d0f8d..848c86a814 100644 --- a/runtime/internal/lib/reflect/makefunc.go +++ b/runtime/internal/lib/reflect/makefunc.go @@ -29,6 +29,7 @@ import ( "github.com/goplus/llgo/runtime/abi" c "github.com/goplus/llgo/runtime/internal/clite" "github.com/goplus/llgo/runtime/internal/ffi" + "github.com/goplus/llgo/runtime/internal/runtime" ) type funcData struct { @@ -36,9 +37,16 @@ type funcData struct { tout []*abi.Type fn func(args []Value) (results []Value) nin int + + recoverFrom unsafe.Pointer + recoverTo unsafe.Pointer } func MakeFunc(typ Type, fn func(args []Value) (results []Value)) Value { + return makeFunc(typ, fn, ValueOf(fn).UnsafePointer()) +} + +func makeFunc(typ Type, fn func(args []Value) (results []Value), recoverTo unsafe.Pointer) Value { if typ.Kind() != Func { panic("reflect: call of MakeFunc with non-Func type") } @@ -52,7 +60,14 @@ func MakeFunc(typ Type, fn func(args []Value) (results []Value)) Value { } outs := toRuntimeTypes(ftyp.Out) closure := ffi.NewClosure() - userdata := &funcData{ftyp: ftyp, fn: fn, nin: len(ftyp.In), tout: outs} + userdata := &funcData{ + ftyp: ftyp, + fn: fn, + nin: len(ftyp.In), + tout: outs, + recoverFrom: closure.Fn, + recoverTo: recoverTo, + } switch len(ftyp.Out) { case 0: @@ -89,7 +104,7 @@ func bind0(cif *ffi.Signature, ret unsafe.Pointer, args *unsafe.Pointer, userdat for i := 0; i < fd.nin; i++ { ins[i] = ffiToValue(ffi.Index(args, uintptr(i)), fd.ftyp.In[i]) } - fd.fn(ins) + fd.call(ins) } func bind1(cif *ffi.Signature, ret unsafe.Pointer, args *unsafe.Pointer, userdata unsafe.Pointer) { @@ -98,7 +113,7 @@ func bind1(cif *ffi.Signature, ret unsafe.Pointer, args *unsafe.Pointer, userdat for i := 0; i < fd.nin; i++ { ins[i] = ffiToValue(ffi.Index(args, uintptr(i)), fd.ftyp.In[i]) } - out := validateMakeFuncResults(fd.fn(ins), fd.ftyp, fd.tout) + out := validateMakeFuncResults(fd.call(ins), fd.ftyp, fd.tout) storeMakeFuncResult(ret, out[0], fd.tout[0]) } @@ -108,7 +123,7 @@ func bindn(cif *ffi.Signature, ret unsafe.Pointer, args *unsafe.Pointer, userdat for i := 0; i < fd.nin; i++ { ins[i] = ffiToValue(ffi.Index(args, uintptr(i)), fd.ftyp.In[i]) } - outs := validateMakeFuncResults(fd.fn(ins), fd.ftyp, fd.tout) + outs := validateMakeFuncResults(fd.call(ins), fd.ftyp, fd.tout) var offset uintptr = 0 alignment := uintptr(cif.RType.Alignment) for i, out := range outs { @@ -118,6 +133,16 @@ func bindn(cif *ffi.Signature, ret unsafe.Pointer, args *unsafe.Pointer, userdat } } +// call crosses the libffi entry stub as a transparent wrapper. This mirrors +// the Go runtime's treatment of reflect.makeFuncStub and methodValueCall as +// wrapper frames when deciding whether recover is called directly. +func (fd *funcData) call(in []Value) []Value { + prev := runtime.StartRecoverFrameAlias(fd.recoverFrom, fd.recoverTo) + out := fd.fn(in) + runtime.EndRecoverFrameAlias(prev) + return out +} + func validateMakeFuncResults(out []Value, ftyp *abi.FuncType, touts []*abi.Type) []Value { if len(out) != len(touts) { panic("reflect: wrong return count from function created by MakeFunc") @@ -269,15 +294,15 @@ func makeMethodValue(op string, v Value) Value { // userdata owns the receiver state. Pointing a hidden-env funcval directly // at Ifn would be invalid because Ifn expects the receiver as an ordinary // first ABI argument. - methodReceiver(op, rcvr, int(v.flag)>>flagMethodShift) + _, _, recoverTo := methodReceiver(op, rcvr, int(v.flag)>>flagMethodShift) method := v callOp := "Call" if method.Type().(*rtype).t.FuncType().Variadic() { callOp = "CallSlice" } - ret := MakeFunc(v.Type(), func(args []Value) []Value { + ret := makeFunc(v.Type(), func(args []Value) []Value { return method.call(callOp, args) - }) + }, recoverTo) // Cause panic if method is not appropriate. // The panic would still happen during the call if we omit this, // but we want Interface() and other operations to fail early. From 43b42904cabcbb4a45591f230934c581a74adccb Mon Sep 17 00:00:00 2001 From: Li Jie Date: Mon, 10 Aug 2026 20:53:38 +0800 Subject: [PATCH 12/21] runtime: keep recover scope state atomic --- runtime/internal/runtime/z_rt.go | 18 +++++++++++------- ssa/eh.go | 6 +----- 2 files changed, 12 insertions(+), 12 deletions(-) diff --git a/runtime/internal/runtime/z_rt.go b/runtime/internal/runtime/z_rt.go index 33904a257f..da6b9e3ae7 100644 --- a/runtime/internal/runtime/z_rt.go +++ b/runtime/internal/runtime/z_rt.go @@ -41,6 +41,11 @@ type panicNode struct { defer_ *Defer } +type recoverState struct { + frame unsafe.Pointer + panic_ unsafe.Pointer +} + // moveToDefer advances a panic to the next defer frame. A panic already // unwinding that frame has been replaced by this newer panic and must not // resume if the newer panic is recovered farther down the defer chain. @@ -98,23 +103,22 @@ func Recover(token unsafe.Pointer) (ret any) { // nested defer frame can then distinguish its own panic from an outer panic // suspended in the direct deferred activation. This is LLGo's explicit-defer // counterpart to gorecover locating the matching _panic through stack frames. -func StartRecoverFrame(frame unsafe.Pointer) (oldFrame, oldPanic unsafe.Pointer) { +func StartRecoverFrame(frame unsafe.Pointer) recoverState { gp := getg() - oldFrame = gp.recoverFrame - oldPanic = gp.recoverPanic + old := recoverState{frame: gp.recoverFrame, panic_: gp.recoverPanic} gp.recoverFrame = frame gp.recoverPanic = nil if ptr := gp.panic_; ptr != nil && (*panicNode)(ptr).defer_ == gp.defer_ { gp.recoverPanic = ptr } - return + return old } // EndRecoverFrame restores direct recover permission after a deferred call. -func EndRecoverFrame(frame, panic_ unsafe.Pointer) { +func EndRecoverFrame(state recoverState) { gp := getg() - gp.recoverFrame = frame - gp.recoverPanic = panic_ + gp.recoverFrame = state.frame + gp.recoverPanic = state.panic_ } // BindRecoverFrame replaces a deferred function's code token with the unique diff --git a/ssa/eh.go b/ssa/eh.go index 3c1726b6c9..7e386e1a0f 100644 --- a/ssa/eh.go +++ b/ssa/eh.go @@ -596,11 +596,7 @@ func (b Builder) callRecoverScopedDefer(fn Expr, mayRecover bool, call func()) { } prev := b.Call(b.Pkg.rtFunc("StartRecoverFrame"), token) call() - b.Call( - b.Pkg.rtFunc("EndRecoverFrame"), - b.getField(prev, 0), - b.getField(prev, 1), - ) + b.Call(b.Pkg.rtFunc("EndRecoverFrame"), prev) } // CallRecoverAlias invokes fn through a compiler-generated wrapper while From 05fb4594ab58d0e6fee083bd3115367a83bbeab8 Mon Sep 17 00:00:00 2001 From: Li Jie Date: Mon, 10 Aug 2026 20:53:44 +0800 Subject: [PATCH 13/21] cl: refresh recover state IR checks --- cl/_testgo/cgodefer/cgodefer.go | 4 +-- cl/_testgo/closureall/in.go | 2 +- cl/_testgo/closureenv/in.go | 2 +- cl/_testgo/defer4/in.go | 4 +-- cl/_testgo/deferclosure/in.go | 4 +-- cl/_testgo/deferiface/in.go | 4 +-- cl/_testgo/genericembediface/in.go | 4 +-- cl/_testgo/goexit/in.go | 12 ++++---- cl/_testgo/ifaceprom/in.go | 12 ++++---- cl/_testgo/indexerr/in.go | 48 +++++++++++++++--------------- cl/_testgo/makeslice/in.go | 12 ++++---- cl/_testgo/reader/in.go | 8 ++--- cl/_testgo/recoverthenpanic/in.go | 4 +-- cl/_testgo/reflectconv/in.go | 4 +-- 14 files changed, 62 insertions(+), 62 deletions(-) diff --git a/cl/_testgo/cgodefer/cgodefer.go b/cl/_testgo/cgodefer/cgodefer.go index 6925b641c8..1a4aeb3c8d 100644 --- a/cl/_testgo/cgodefer/cgodefer.go +++ b/cl/_testgo/cgodefer/cgodefer.go @@ -118,12 +118,12 @@ func main() { // CHECK-NEXT: %33 = extractvalue { ptr, i64, { ptr, ptr } } %31, 2 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.FreeDeferNode"(ptr %30) // CHECK-NEXT: %34 = extractvalue { ptr, ptr } %33, 0 -// CHECK-NEXT: %35 = call ptr @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr %34) +// CHECK-NEXT: %35 = call %"{{.*}}/runtime/internal/runtime.recoverState" @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr %34) // CHECK-NEXT: %36 = extractvalue { ptr, ptr } %33, 1 // CHECK-NEXT: %37 = extractvalue { ptr, ptr } %33, 0 // CHECK-NEXT: %__llgo_funcval_code1 = call ptr asm "", "=r,0"(ptr %37) // CHECK-NEXT: call void %__llgo_funcval_code1(ptr {{(nest|swiftself)}} %36) -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %35) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(%"{{.*}}/runtime/internal/runtime.recoverState" %35) // CHECK-NEXT: br label %_llgo_8 // CHECK-EMPTY: // CHECK-NEXT: _llgo_8: ; preds = %_llgo_7, %_llgo_2 diff --git a/cl/_testgo/closureall/in.go b/cl/_testgo/closureall/in.go index cbe1038165..20efa1471b 100644 --- a/cl/_testgo/closureall/in.go +++ b/cl/_testgo/closureall/in.go @@ -262,6 +262,6 @@ func makeWithFree(base int) Fn { // CHECK-NEXT: %12 = extractvalue { ptr, ptr } %9, 1 // CHECK-NEXT: %13 = extractvalue { ptr, ptr } %9, 0 // CHECK-NEXT: %14 = call i64 %13(ptr %12, i64 %1) -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %11) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrameAlias"(ptr %11) // CHECK-NEXT: ret i64 %14 // CHECK-NEXT: } diff --git a/cl/_testgo/closureenv/in.go b/cl/_testgo/closureenv/in.go index ca44567df8..06ad8be1f7 100644 --- a/cl/_testgo/closureenv/in.go +++ b/cl/_testgo/closureenv/in.go @@ -252,6 +252,6 @@ func main() { // CHECK-NEXT: %11 = extractvalue { ptr, ptr } %8, 1 // CHECK-NEXT: %12 = extractvalue { ptr, ptr } %8, 0 // CHECK-NEXT: %13 = call i1 %12(ptr %11) -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %10) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrameAlias"(ptr %10) // CHECK-NEXT: ret i1 %13 // CHECK-NEXT: } diff --git a/cl/_testgo/defer4/in.go b/cl/_testgo/defer4/in.go index f4151f6920..703e18be39 100644 --- a/cl/_testgo/defer4/in.go +++ b/cl/_testgo/defer4/in.go @@ -73,9 +73,9 @@ func main() { // CHECK-NEXT: _llgo_2: ; preds = %_llgo_5 // CHECK-NEXT: store ptr blockaddress(@main.fail, %_llgo_6), ptr %8, align 8 // CHECK-NEXT: %13 = load i64, ptr %7, align 8 -// CHECK-NEXT: %14 = call ptr @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr @"main.fail$1") +// CHECK-NEXT: %14 = call %"{{.*}}/runtime/internal/runtime.recoverState" @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr @"main.fail$1") // CHECK-NEXT: call void @"main.fail$1"() -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %14) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(%"{{.*}}/runtime/internal/runtime.recoverState" %14) // CHECK-NEXT: br label %_llgo_6 // CHECK-EMPTY: // CHECK-NEXT: _llgo_3: ; preds = %_llgo_5, %_llgo_8 diff --git a/cl/_testgo/deferclosure/in.go b/cl/_testgo/deferclosure/in.go index 7c87545949..852f8df233 100644 --- a/cl/_testgo/deferclosure/in.go +++ b/cl/_testgo/deferclosure/in.go @@ -298,12 +298,12 @@ func main() { // CHECK-NEXT: %29 = extractvalue { ptr, i64, { ptr, ptr } } %27, 2 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.FreeDeferNode"(ptr %26) // CHECK-NEXT: %30 = extractvalue { ptr, ptr } %29, 0 -// CHECK-NEXT: %31 = call ptr @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr %30) +// CHECK-NEXT: %31 = call %"{{.*}}/runtime/internal/runtime.recoverState" @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr %30) // CHECK-NEXT: %32 = extractvalue { ptr, ptr } %29, 1 // CHECK-NEXT: %33 = extractvalue { ptr, ptr } %29, 0 // CHECK-NEXT: %__llgo_funcval_code = call ptr asm "", "=r,0"(ptr %33) // CHECK-NEXT: call void %__llgo_funcval_code(ptr {{(nest|swiftself)}} %32) -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %31) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(%"{{.*}}/runtime/internal/runtime.recoverState" %31) // CHECK-NEXT: br label %_llgo_8 // CHECK-EMPTY: // CHECK-NEXT: _llgo_8: ; preds = %_llgo_7, %_llgo_2 diff --git a/cl/_testgo/deferiface/in.go b/cl/_testgo/deferiface/in.go index 74d4c7e1ab..5cedafe869 100644 --- a/cl/_testgo/deferiface/in.go +++ b/cl/_testgo/deferiface/in.go @@ -135,11 +135,11 @@ func main() { // CHECK-NEXT: %32 = extractvalue { ptr, i64, { ptr, ptr } } %30, 2 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.FreeDeferNode"(ptr %29) // CHECK-NEXT: %33 = extractvalue { ptr, ptr } %32, 0 -// CHECK-NEXT: %34 = call ptr @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr %33) +// CHECK-NEXT: %34 = call %"{{.*}}/runtime/internal/runtime.recoverState" @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr %33) // CHECK-NEXT: %35 = extractvalue { ptr, ptr } %32, 1 // CHECK-NEXT: %36 = extractvalue { ptr, ptr } %32, 0 // CHECK-NEXT: call void %36(ptr %35) -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %34) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(%"{{.*}}/runtime/internal/runtime.recoverState" %34) // CHECK-NEXT: br label %_llgo_8 // CHECK-EMPTY: // CHECK-NEXT: _llgo_8: ; preds = %_llgo_7, %_llgo_2 diff --git a/cl/_testgo/genericembediface/in.go b/cl/_testgo/genericembediface/in.go index 8d040f984e..2b298c83d6 100644 --- a/cl/_testgo/genericembediface/in.go +++ b/cl/_testgo/genericembediface/in.go @@ -147,7 +147,7 @@ func main() { // CHECK-NEXT: %11 = extractvalue { ptr, ptr } %8, 1 // CHECK-NEXT: %12 = extractvalue { ptr, ptr } %8, 0 // CHECK-NEXT: %13 = call %"{{.*}}/runtime/internal/runtime.String" %12(ptr %11) -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %10) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrameAlias"(ptr %10) // CHECK-NEXT: ret %"{{.*}}/runtime/internal/runtime.String" %13 // CHECK-NEXT: } @@ -169,6 +169,6 @@ func main() { // CHECK-NEXT: %12 = extractvalue { ptr, ptr } %9, 1 // CHECK-NEXT: %13 = extractvalue { ptr, ptr } %9, 0 // CHECK-NEXT: %14 = call %"{{.*}}/runtime/internal/runtime.String" %13(ptr %12) -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %11) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrameAlias"(ptr %11) // CHECK-NEXT: ret %"{{.*}}/runtime/internal/runtime.String" %14 // CHECK-NEXT: } diff --git a/cl/_testgo/goexit/in.go b/cl/_testgo/goexit/in.go index 39ba36ad6a..c46bd150eb 100644 --- a/cl/_testgo/goexit/in.go +++ b/cl/_testgo/goexit/in.go @@ -280,12 +280,12 @@ func demo3() { // CHECK-NEXT: %31 = extractvalue { ptr, i64, { ptr, ptr } } %29, 2 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.FreeDeferNode"(ptr %28) // CHECK-NEXT: %32 = extractvalue { ptr, ptr } %31, 0 -// CHECK-NEXT: %33 = call ptr @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr %32) +// CHECK-NEXT: %33 = call %"{{.*}}/runtime/internal/runtime.recoverState" @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr %32) // CHECK-NEXT: %34 = extractvalue { ptr, ptr } %31, 1 // CHECK-NEXT: %35 = extractvalue { ptr, ptr } %31, 0 // CHECK-NEXT: %__llgo_funcval_code = call ptr asm "", "=r,0"(ptr %35) // CHECK-NEXT: call void %__llgo_funcval_code(ptr {{(nest|swiftself)}} %34) -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %33) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(%"{{.*}}/runtime/internal/runtime.recoverState" %33) // CHECK-NEXT: br label %_llgo_8 // CHECK-EMPTY: // CHECK-NEXT: _llgo_8: ; preds = %_llgo_7, %_llgo_2 @@ -383,9 +383,9 @@ func demo3() { // CHECK-NEXT: _llgo_2: ; preds = %_llgo_5, %_llgo_4 // CHECK-NEXT: store ptr blockaddress(@"main.demo3$1", %_llgo_7), ptr %14, align 8 // CHECK-NEXT: %19 = load i64, ptr %13, align 8 -// CHECK-NEXT: %20 = call ptr @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr @"main.demo3$1$2") +// CHECK-NEXT: %20 = call %"{{.*}}/runtime/internal/runtime.recoverState" @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr @"main.demo3$1$2") // CHECK-NEXT: call void @"main.demo3$1$2"() -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %20) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(%"{{.*}}/runtime/internal/runtime.recoverState" %20) // CHECK-NEXT: br label %_llgo_7 // CHECK-EMPTY: // CHECK-NEXT: _llgo_3: ; preds = %_llgo_5, %_llgo_9 @@ -429,12 +429,12 @@ func demo3() { // CHECK-NEXT: %33 = extractvalue { ptr, i64, { ptr, ptr } } %31, 2 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.FreeDeferNode"(ptr %30) // CHECK-NEXT: %34 = extractvalue { ptr, ptr } %33, 0 -// CHECK-NEXT: %35 = call ptr @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr %34) +// CHECK-NEXT: %35 = call %"{{.*}}/runtime/internal/runtime.recoverState" @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr %34) // CHECK-NEXT: %36 = extractvalue { ptr, ptr } %33, 1 // CHECK-NEXT: %37 = extractvalue { ptr, ptr } %33, 0 // CHECK-NEXT: %__llgo_funcval_code = call ptr asm "", "=r,0"(ptr %37) // CHECK-NEXT: call void %__llgo_funcval_code(ptr {{(nest|swiftself)}} %36) -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %35) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(%"{{.*}}/runtime/internal/runtime.recoverState" %35) // CHECK-NEXT: br label %_llgo_9 // CHECK-EMPTY: // CHECK-NEXT: _llgo_9: ; preds = %_llgo_8, %_llgo_7 diff --git a/cl/_testgo/ifaceprom/in.go b/cl/_testgo/ifaceprom/in.go index 29bc00c9ca..08e47ad91f 100644 --- a/cl/_testgo/ifaceprom/in.go +++ b/cl/_testgo/ifaceprom/in.go @@ -83,7 +83,7 @@ func main() { // CHECK-NEXT: %12 = extractvalue { ptr, ptr } %9, 1 // CHECK-NEXT: %13 = extractvalue { ptr, ptr } %9, 0 // CHECK-NEXT: %14 = call i64 %13(ptr %12) -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %11) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrameAlias"(ptr %11) // CHECK-NEXT: ret i64 %14 // CHECK-NEXT: } @@ -105,7 +105,7 @@ func main() { // CHECK-NEXT: %12 = extractvalue { ptr, ptr } %9, 1 // CHECK-NEXT: %13 = extractvalue { ptr, ptr } %9, 0 // CHECK-NEXT: %14 = call %"{{.*}}/runtime/internal/runtime.String" %13(ptr %12) -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %11) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrameAlias"(ptr %11) // CHECK-NEXT: ret %"{{.*}}/runtime/internal/runtime.String" %14 // CHECK-NEXT: } @@ -124,7 +124,7 @@ func main() { // CHECK-NEXT: %11 = extractvalue { ptr, ptr } %8, 1 // CHECK-NEXT: %12 = extractvalue { ptr, ptr } %8, 0 // CHECK-NEXT: %13 = call i64 %12(ptr %11) -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %10) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrameAlias"(ptr %10) // CHECK-NEXT: ret i64 %13 // CHECK-NEXT: } @@ -143,7 +143,7 @@ func main() { // CHECK-NEXT: %11 = extractvalue { ptr, ptr } %8, 1 // CHECK-NEXT: %12 = extractvalue { ptr, ptr } %8, 0 // CHECK-NEXT: %13 = call %"{{.*}}/runtime/internal/runtime.String" %12(ptr %11) -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %10) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrameAlias"(ptr %10) // CHECK-NEXT: ret %"{{.*}}/runtime/internal/runtime.String" %13 // CHECK-NEXT: } @@ -433,7 +433,7 @@ func main() { // CHECK-NEXT: %11 = extractvalue { ptr, ptr } %8, 1 // CHECK-NEXT: %12 = extractvalue { ptr, ptr } %8, 0 // CHECK-NEXT: %13 = call i64 %12(ptr %11) -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %10) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrameAlias"(ptr %10) // CHECK-NEXT: ret i64 %13 // CHECK-NEXT: } @@ -452,6 +452,6 @@ func main() { // CHECK-NEXT: %11 = extractvalue { ptr, ptr } %8, 1 // CHECK-NEXT: %12 = extractvalue { ptr, ptr } %8, 0 // CHECK-NEXT: %13 = call %"{{.*}}/runtime/internal/runtime.String" %12(ptr %11) -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %10) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrameAlias"(ptr %10) // CHECK-NEXT: ret %"{{.*}}/runtime/internal/runtime.String" %13 // CHECK-NEXT: } diff --git a/cl/_testgo/indexerr/in.go b/cl/_testgo/indexerr/in.go index b12c5d6897..b820551c2c 100644 --- a/cl/_testgo/indexerr/in.go +++ b/cl/_testgo/indexerr/in.go @@ -241,9 +241,9 @@ func slice2(n int) { // CHECK-NEXT: _llgo_2: ; preds = %_llgo_5, %_llgo_4 // CHECK-NEXT: store ptr blockaddress(@"main.init#1", %_llgo_3), ptr %8, align 8 // CHECK-NEXT: %13 = load i64, ptr %7, align 8 -// CHECK-NEXT: %14 = call ptr @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr @"main.init#1$1") +// CHECK-NEXT: %14 = call %"{{.*}}/runtime/internal/runtime.recoverState" @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr @"main.init#1$1") // CHECK-NEXT: call void @"main.init#1$1"() -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %14) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(%"{{.*}}/runtime/internal/runtime.recoverState" %14) // CHECK-NEXT: %15 = load %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, align 8 // CHECK-NEXT: %16 = extractvalue %"{{.*}}/runtime/internal/runtime.Defer" %15, 2 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.SetThreadDefer"(ptr %16) @@ -316,9 +316,9 @@ func slice2(n int) { // CHECK-NEXT: _llgo_2: ; preds = %_llgo_5, %_llgo_4 // CHECK-NEXT: store ptr blockaddress(@"main.init#10", %_llgo_3), ptr %8, align 8 // CHECK-NEXT: %13 = load i64, ptr %7, align 8 -// CHECK-NEXT: %14 = call ptr @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr @"main.init#10$1") +// CHECK-NEXT: %14 = call %"{{.*}}/runtime/internal/runtime.recoverState" @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr @"main.init#10$1") // CHECK-NEXT: call void @"main.init#10$1"() -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %14) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(%"{{.*}}/runtime/internal/runtime.recoverState" %14) // CHECK-NEXT: %15 = load %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, align 8 // CHECK-NEXT: %16 = extractvalue %"{{.*}}/runtime/internal/runtime.Defer" %15, 2 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.SetThreadDefer"(ptr %16) @@ -407,9 +407,9 @@ func slice2(n int) { // CHECK-NEXT: _llgo_2: ; preds = %_llgo_5, %_llgo_4 // CHECK-NEXT: store ptr blockaddress(@"main.init#11", %_llgo_3), ptr %8, align 8 // CHECK-NEXT: %13 = load i64, ptr %7, align 8 -// CHECK-NEXT: %14 = call ptr @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr @"main.init#11$1") +// CHECK-NEXT: %14 = call %"{{.*}}/runtime/internal/runtime.recoverState" @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr @"main.init#11$1") // CHECK-NEXT: call void @"main.init#11$1"() -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %14) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(%"{{.*}}/runtime/internal/runtime.recoverState" %14) // CHECK-NEXT: %15 = load %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, align 8 // CHECK-NEXT: %16 = extractvalue %"{{.*}}/runtime/internal/runtime.Defer" %15, 2 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.SetThreadDefer"(ptr %16) @@ -497,9 +497,9 @@ func slice2(n int) { // CHECK-NEXT: _llgo_2: ; preds = %_llgo_5, %_llgo_4 // CHECK-NEXT: store ptr blockaddress(@"main.init#12", %_llgo_3), ptr %8, align 8 // CHECK-NEXT: %13 = load i64, ptr %7, align 8 -// CHECK-NEXT: %14 = call ptr @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr @"main.init#12$1") +// CHECK-NEXT: %14 = call %"{{.*}}/runtime/internal/runtime.recoverState" @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr @"main.init#12$1") // CHECK-NEXT: call void @"main.init#12$1"() -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %14) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(%"{{.*}}/runtime/internal/runtime.recoverState" %14) // CHECK-NEXT: %15 = load %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, align 8 // CHECK-NEXT: %16 = extractvalue %"{{.*}}/runtime/internal/runtime.Defer" %15, 2 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.SetThreadDefer"(ptr %16) @@ -587,9 +587,9 @@ func slice2(n int) { // CHECK-NEXT: _llgo_2: ; preds = %_llgo_5, %_llgo_4 // CHECK-NEXT: store ptr blockaddress(@"main.init#2", %_llgo_3), ptr %8, align 8 // CHECK-NEXT: %13 = load i64, ptr %7, align 8 -// CHECK-NEXT: %14 = call ptr @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr @"main.init#2$1") +// CHECK-NEXT: %14 = call %"{{.*}}/runtime/internal/runtime.recoverState" @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr @"main.init#2$1") // CHECK-NEXT: call void @"main.init#2$1"() -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %14) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(%"{{.*}}/runtime/internal/runtime.recoverState" %14) // CHECK-NEXT: %15 = load %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, align 8 // CHECK-NEXT: %16 = extractvalue %"{{.*}}/runtime/internal/runtime.Defer" %15, 2 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.SetThreadDefer"(ptr %16) @@ -662,9 +662,9 @@ func slice2(n int) { // CHECK-NEXT: _llgo_2: ; preds = %_llgo_5, %_llgo_4 // CHECK-NEXT: store ptr blockaddress(@"main.init#3", %_llgo_3), ptr %8, align 8 // CHECK-NEXT: %13 = load i64, ptr %7, align 8 -// CHECK-NEXT: %14 = call ptr @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr @"main.init#3$1") +// CHECK-NEXT: %14 = call %"{{.*}}/runtime/internal/runtime.recoverState" @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr @"main.init#3$1") // CHECK-NEXT: call void @"main.init#3$1"() -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %14) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(%"{{.*}}/runtime/internal/runtime.recoverState" %14) // CHECK-NEXT: %15 = load %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, align 8 // CHECK-NEXT: %16 = extractvalue %"{{.*}}/runtime/internal/runtime.Defer" %15, 2 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.SetThreadDefer"(ptr %16) @@ -737,9 +737,9 @@ func slice2(n int) { // CHECK-NEXT: _llgo_2: ; preds = %_llgo_5, %_llgo_4 // CHECK-NEXT: store ptr blockaddress(@"main.init#4", %_llgo_3), ptr %8, align 8 // CHECK-NEXT: %13 = load i64, ptr %7, align 8 -// CHECK-NEXT: %14 = call ptr @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr @"main.init#4$1") +// CHECK-NEXT: %14 = call %"{{.*}}/runtime/internal/runtime.recoverState" @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr @"main.init#4$1") // CHECK-NEXT: call void @"main.init#4$1"() -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %14) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(%"{{.*}}/runtime/internal/runtime.recoverState" %14) // CHECK-NEXT: %15 = load %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, align 8 // CHECK-NEXT: %16 = extractvalue %"{{.*}}/runtime/internal/runtime.Defer" %15, 2 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.SetThreadDefer"(ptr %16) @@ -812,9 +812,9 @@ func slice2(n int) { // CHECK-NEXT: _llgo_2: ; preds = %_llgo_5, %_llgo_4 // CHECK-NEXT: store ptr blockaddress(@"main.init#5", %_llgo_3), ptr %8, align 8 // CHECK-NEXT: %13 = load i64, ptr %7, align 8 -// CHECK-NEXT: %14 = call ptr @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr @"main.init#5$1") +// CHECK-NEXT: %14 = call %"{{.*}}/runtime/internal/runtime.recoverState" @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr @"main.init#5$1") // CHECK-NEXT: call void @"main.init#5$1"() -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %14) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(%"{{.*}}/runtime/internal/runtime.recoverState" %14) // CHECK-NEXT: %15 = load %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, align 8 // CHECK-NEXT: %16 = extractvalue %"{{.*}}/runtime/internal/runtime.Defer" %15, 2 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.SetThreadDefer"(ptr %16) @@ -887,9 +887,9 @@ func slice2(n int) { // CHECK-NEXT: _llgo_2: ; preds = %_llgo_5, %_llgo_4 // CHECK-NEXT: store ptr blockaddress(@"main.init#6", %_llgo_3), ptr %8, align 8 // CHECK-NEXT: %13 = load i64, ptr %7, align 8 -// CHECK-NEXT: %14 = call ptr @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr @"main.init#6$1") +// CHECK-NEXT: %14 = call %"{{.*}}/runtime/internal/runtime.recoverState" @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr @"main.init#6$1") // CHECK-NEXT: call void @"main.init#6$1"() -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %14) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(%"{{.*}}/runtime/internal/runtime.recoverState" %14) // CHECK-NEXT: %15 = load %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, align 8 // CHECK-NEXT: %16 = extractvalue %"{{.*}}/runtime/internal/runtime.Defer" %15, 2 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.SetThreadDefer"(ptr %16) @@ -962,9 +962,9 @@ func slice2(n int) { // CHECK-NEXT: _llgo_2: ; preds = %_llgo_5, %_llgo_4 // CHECK-NEXT: store ptr blockaddress(@"main.init#7", %_llgo_3), ptr %8, align 8 // CHECK-NEXT: %13 = load i64, ptr %7, align 8 -// CHECK-NEXT: %14 = call ptr @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr @"main.init#7$1") +// CHECK-NEXT: %14 = call %"{{.*}}/runtime/internal/runtime.recoverState" @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr @"main.init#7$1") // CHECK-NEXT: call void @"main.init#7$1"() -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %14) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(%"{{.*}}/runtime/internal/runtime.recoverState" %14) // CHECK-NEXT: %15 = load %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, align 8 // CHECK-NEXT: %16 = extractvalue %"{{.*}}/runtime/internal/runtime.Defer" %15, 2 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.SetThreadDefer"(ptr %16) @@ -1048,9 +1048,9 @@ func slice2(n int) { // CHECK-NEXT: _llgo_2: ; preds = %_llgo_5, %_llgo_4 // CHECK-NEXT: store ptr blockaddress(@"main.init#8", %_llgo_3), ptr %8, align 8 // CHECK-NEXT: %13 = load i64, ptr %7, align 8 -// CHECK-NEXT: %14 = call ptr @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr @"main.init#8$1") +// CHECK-NEXT: %14 = call %"{{.*}}/runtime/internal/runtime.recoverState" @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr @"main.init#8$1") // CHECK-NEXT: call void @"main.init#8$1"() -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %14) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(%"{{.*}}/runtime/internal/runtime.recoverState" %14) // CHECK-NEXT: %15 = load %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, align 8 // CHECK-NEXT: %16 = extractvalue %"{{.*}}/runtime/internal/runtime.Defer" %15, 2 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.SetThreadDefer"(ptr %16) @@ -1134,9 +1134,9 @@ func slice2(n int) { // CHECK-NEXT: _llgo_2: ; preds = %_llgo_5, %_llgo_4 // CHECK-NEXT: store ptr blockaddress(@"main.init#9", %_llgo_3), ptr %8, align 8 // CHECK-NEXT: %13 = load i64, ptr %7, align 8 -// CHECK-NEXT: %14 = call ptr @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr @"main.init#9$1") +// CHECK-NEXT: %14 = call %"{{.*}}/runtime/internal/runtime.recoverState" @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr @"main.init#9$1") // CHECK-NEXT: call void @"main.init#9$1"() -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %14) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(%"{{.*}}/runtime/internal/runtime.recoverState" %14) // CHECK-NEXT: %15 = load %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, align 8 // CHECK-NEXT: %16 = extractvalue %"{{.*}}/runtime/internal/runtime.Defer" %15, 2 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.SetThreadDefer"(ptr %16) diff --git a/cl/_testgo/makeslice/in.go b/cl/_testgo/makeslice/in.go index a8f3b01e70..d0a9f3db0b 100644 --- a/cl/_testgo/makeslice/in.go +++ b/cl/_testgo/makeslice/in.go @@ -152,9 +152,9 @@ func init() { // CHECK-NEXT: _llgo_2: ; preds = %_llgo_5, %_llgo_4 // CHECK-NEXT: store ptr blockaddress(@"main.init#3", %_llgo_3), ptr %8, align 8 // CHECK-NEXT: %13 = load i64, ptr %7, align 8 -// CHECK-NEXT: %14 = call ptr @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr @"main.init#3$1") +// CHECK-NEXT: %14 = call %"{{.*}}/runtime/internal/runtime.recoverState" @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr @"main.init#3$1") // CHECK-NEXT: call void @"main.init#3$1"() -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %14) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(%"{{.*}}/runtime/internal/runtime.recoverState" %14) // CHECK-NEXT: %15 = load %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, align 8 // CHECK-NEXT: %16 = extractvalue %"{{.*}}/runtime/internal/runtime.Defer" %15, 2 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.SetThreadDefer"(ptr %16) @@ -225,9 +225,9 @@ func init() { // CHECK-NEXT: _llgo_2: ; preds = %_llgo_5, %_llgo_4 // CHECK-NEXT: store ptr blockaddress(@"main.init#4", %_llgo_3), ptr %8, align 8 // CHECK-NEXT: %13 = load i64, ptr %7, align 8 -// CHECK-NEXT: %14 = call ptr @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr @"main.init#4$1") +// CHECK-NEXT: %14 = call %"{{.*}}/runtime/internal/runtime.recoverState" @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr @"main.init#4$1") // CHECK-NEXT: call void @"main.init#4$1"() -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %14) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(%"{{.*}}/runtime/internal/runtime.recoverState" %14) // CHECK-NEXT: %15 = load %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, align 8 // CHECK-NEXT: %16 = extractvalue %"{{.*}}/runtime/internal/runtime.Defer" %15, 2 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.SetThreadDefer"(ptr %16) @@ -298,9 +298,9 @@ func init() { // CHECK-NEXT: _llgo_2: ; preds = %_llgo_5, %_llgo_4 // CHECK-NEXT: store ptr blockaddress(@"main.init#5", %_llgo_3), ptr %8, align 8 // CHECK-NEXT: %13 = load i64, ptr %7, align 8 -// CHECK-NEXT: %14 = call ptr @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr @"main.init#5$1") +// CHECK-NEXT: %14 = call %"{{.*}}/runtime/internal/runtime.recoverState" @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr @"main.init#5$1") // CHECK-NEXT: call void @"main.init#5$1"() -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %14) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(%"{{.*}}/runtime/internal/runtime.recoverState" %14) // CHECK-NEXT: %15 = load %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, align 8 // CHECK-NEXT: %16 = extractvalue %"{{.*}}/runtime/internal/runtime.Defer" %15, 2 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.SetThreadDefer"(ptr %16) diff --git a/cl/_testgo/reader/in.go b/cl/_testgo/reader/in.go index 151fdcdab6..5b26065806 100644 --- a/cl/_testgo/reader/in.go +++ b/cl/_testgo/reader/in.go @@ -594,7 +594,7 @@ func main() { // CHECK-NEXT: %13 = extractvalue { ptr, ptr } %10, 1 // CHECK-NEXT: %14 = extractvalue { ptr, ptr } %10, 0 // CHECK-NEXT: %15 = call { i64, %"{{.*}}/runtime/internal/runtime.iface" } %14(ptr %13, %"{{.*}}/runtime/internal/runtime.Slice" %1) -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %12) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrameAlias"(ptr %12) // CHECK-NEXT: %16 = extractvalue { i64, %"{{.*}}/runtime/internal/runtime.iface" } %15, 0 // CHECK-NEXT: %17 = extractvalue { i64, %"{{.*}}/runtime/internal/runtime.iface" } %15, 1 // CHECK-NEXT: %18 = insertvalue { i64, %"{{.*}}/runtime/internal/runtime.iface" } undef, i64 %16, 0 @@ -626,7 +626,7 @@ func main() { // CHECK-NEXT: %12 = extractvalue { ptr, ptr } %9, 1 // CHECK-NEXT: %13 = extractvalue { ptr, ptr } %9, 0 // CHECK-NEXT: %14 = call { i64, %"{{.*}}/runtime/internal/runtime.iface" } %13(ptr %12, %"{{.*}}/runtime/internal/runtime.Slice" %1) -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %11) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrameAlias"(ptr %11) // CHECK-NEXT: %15 = extractvalue { i64, %"{{.*}}/runtime/internal/runtime.iface" } %14, 0 // CHECK-NEXT: %16 = extractvalue { i64, %"{{.*}}/runtime/internal/runtime.iface" } %14, 1 // CHECK-NEXT: %17 = insertvalue { i64, %"{{.*}}/runtime/internal/runtime.iface" } undef, i64 %15, 0 @@ -657,7 +657,7 @@ func main() { // CHECK-NEXT: %13 = extractvalue { ptr, ptr } %10, 1 // CHECK-NEXT: %14 = extractvalue { ptr, ptr } %10, 0 // CHECK-NEXT: %15 = call { i64, %"{{.*}}/runtime/internal/runtime.iface" } %14(ptr %13, %"{{.*}}/runtime/internal/runtime.Slice" %1) -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %12) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrameAlias"(ptr %12) // CHECK-NEXT: %16 = extractvalue { i64, %"{{.*}}/runtime/internal/runtime.iface" } %15, 0 // CHECK-NEXT: %17 = extractvalue { i64, %"{{.*}}/runtime/internal/runtime.iface" } %15, 1 // CHECK-NEXT: %18 = insertvalue { i64, %"{{.*}}/runtime/internal/runtime.iface" } undef, i64 %16, 0 @@ -725,7 +725,7 @@ func main() { // CHECK-NEXT: %12 = extractvalue { ptr, ptr } %9, 1 // CHECK-NEXT: %13 = extractvalue { ptr, ptr } %9, 0 // CHECK-NEXT: %14 = call { i64, %"{{.*}}/runtime/internal/runtime.iface" } %13(ptr %12, %"{{.*}}/runtime/internal/runtime.Slice" %1) -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %11) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrameAlias"(ptr %11) // CHECK-NEXT: %15 = extractvalue { i64, %"{{.*}}/runtime/internal/runtime.iface" } %14, 0 // CHECK-NEXT: %16 = extractvalue { i64, %"{{.*}}/runtime/internal/runtime.iface" } %14, 1 // CHECK-NEXT: %17 = insertvalue { i64, %"{{.*}}/runtime/internal/runtime.iface" } undef, i64 %15, 0 diff --git a/cl/_testgo/recoverthenpanic/in.go b/cl/_testgo/recoverthenpanic/in.go index f4fe1c94e9..0d1cfd8757 100644 --- a/cl/_testgo/recoverthenpanic/in.go +++ b/cl/_testgo/recoverthenpanic/in.go @@ -163,9 +163,9 @@ func main() { // CHECK-NEXT: _llgo_2: ; preds = %_llgo_5 // CHECK-NEXT: store ptr blockaddress(@main.main, %_llgo_3), ptr %8, align 8 // CHECK-NEXT: %13 = load i64, ptr %7, align 8 -// CHECK-NEXT: %14 = call ptr @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr @main.End) +// CHECK-NEXT: %14 = call %"{{.*}}/runtime/internal/runtime.recoverState" @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr @main.End) // CHECK-NEXT: call void @main.End() -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %14) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(%"{{.*}}/runtime/internal/runtime.recoverState" %14) // CHECK-NEXT: %15 = load %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, align 8 // CHECK-NEXT: %16 = extractvalue %"{{.*}}/runtime/internal/runtime.Defer" %15, 2 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.SetThreadDefer"(ptr %16) diff --git a/cl/_testgo/reflectconv/in.go b/cl/_testgo/reflectconv/in.go index 369c55c1a5..179d464a64 100644 --- a/cl/_testgo/reflectconv/in.go +++ b/cl/_testgo/reflectconv/in.go @@ -9547,12 +9547,12 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %33 = extractvalue { ptr, i64, { ptr, ptr } } %31, 2 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.FreeDeferNode"(ptr %30) // CHECK-NEXT: %34 = extractvalue { ptr, ptr } %33, 0 -// CHECK-NEXT: %35 = call ptr @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr %34) +// CHECK-NEXT: %35 = call %"{{.*}}/runtime/internal/runtime.recoverState" @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr %34) // CHECK-NEXT: %36 = extractvalue { ptr, ptr } %33, 1 // CHECK-NEXT: %37 = extractvalue { ptr, ptr } %33, 0 // CHECK-NEXT: %__llgo_funcval_code1 = call ptr asm "", "=r,0"(ptr %37) // CHECK-NEXT: call void %__llgo_funcval_code1(ptr {{(nest|swiftself)}} %36) -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(ptr %35) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(%"{{.*}}/runtime/internal/runtime.recoverState" %35) // CHECK-NEXT: br label %_llgo_8 // CHECK-EMPTY: // CHECK-NEXT: _llgo_8: ; preds = %_llgo_7, %_llgo_2 From 2c3f2d81a6936bc02046d5ffa018bf064cd15db9 Mon Sep 17 00:00:00 2001 From: Li Jie Date: Mon, 10 Aug 2026 21:56:49 +0800 Subject: [PATCH 14/21] cl: keep recover IR checks portable --- cl/_testgo/abimethod/in.go | 26 +++++++++---------- cl/_testgo/closureall/in.go | 4 +-- cl/_testgo/closureenv/in.go | 4 +-- cl/_testgo/defer4/in.go | 4 +-- cl/_testgo/deferclosure/in.go | 8 +++--- cl/_testgo/genericembediface/in.go | 6 ++--- cl/_testgo/goexit/in.go | 6 ++--- cl/_testgo/ifaceprom/in.go | 2 +- cl/_testgo/indexerr/in.go | 24 +++++++++--------- cl/_testgo/invoke/in.go | 40 +++++++++++++++--------------- cl/_testgo/makeslice/in.go | 6 ++--- cl/_testgo/reader/in.go | 14 +++++------ cl/_testgo/reflect/in.go | 2 +- cl/_testgo/reflectconv/in.go | 26 +++++++++---------- cl/_testgo/tpinst/main.go | 10 ++++---- cl/_testrt/tpabi/in.go | 2 +- 16 files changed, 92 insertions(+), 92 deletions(-) diff --git a/cl/_testgo/abimethod/in.go b/cl/_testgo/abimethod/in.go index 725a53779b..869387be3f 100644 --- a/cl/_testgo/abimethod/in.go +++ b/cl/_testgo/abimethod/in.go @@ -299,7 +299,7 @@ type I2 interface { // CHECK-NEXT: store i64 100, ptr %4, align 8 // CHECK-NEXT: store i64 10, ptr %1, align 8 // CHECK-NEXT: store ptr %3, ptr %2, align 8 -// CHECK-NEXT: %5 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$WkyTd7mXEW0USaC6FIo7OG9IdUUyjAJl_h3PFrMEtHc", ptr @"*{{.*}}/cl/_testgo/abimethod.struct$uZOBdiU3hXPUbVo89Hd5Yu-O7H5aW05rvCsBARpyejU") +// CHECK-NEXT: %5 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @"*{{.*}}/cl/_testgo/abimethod.struct${{[-A-Za-z0-9_]+}}") // CHECK-NEXT: %6 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %5, 0 // CHECK-NEXT: %7 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %6, ptr %0, 1 // CHECK-NEXT: %8 = call ptr @"{{.*}}/runtime/internal/runtime.IfacePtrData"(%"{{.*}}/runtime/internal/runtime.iface" %7) @@ -339,7 +339,7 @@ type I2 interface { // CHECK-NEXT: %5 = load { i64, ptr }, ptr %0, align 8 // CHECK-NEXT: %6 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) // CHECK-NEXT: store { i64, ptr } %5, ptr %6, align 8 -// CHECK-NEXT: %7 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$WkyTd7mXEW0USaC6FIo7OG9IdUUyjAJl_h3PFrMEtHc", ptr @"{{.*}}/cl/_testgo/abimethod.struct$uZOBdiU3hXPUbVo89Hd5Yu-O7H5aW05rvCsBARpyejU") +// CHECK-NEXT: %7 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @"{{.*}}/cl/_testgo/abimethod.struct${{[-A-Za-z0-9_]+}}") // CHECK-NEXT: %8 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %7, 0 // CHECK-NEXT: %9 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %8, ptr %6, 1 // CHECK-NEXT: %10 = call ptr @"{{.*}}/runtime/internal/runtime.IfacePtrData"(%"{{.*}}/runtime/internal/runtime.iface" %9) @@ -377,7 +377,7 @@ type I2 interface { // CHECK-NEXT: %4 = load { i64, %main.T }, ptr %0, align 8 // CHECK-NEXT: %5 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) // CHECK-NEXT: store { i64, %main.T } %4, ptr %5, align 8 -// CHECK-NEXT: %6 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$WkyTd7mXEW0USaC6FIo7OG9IdUUyjAJl_h3PFrMEtHc", ptr @"{{.*}}/cl/_testgo/abimethod.struct$wV1HLSFXt7Wv7h73sIB8bnWmKRl_W0D4YiEDGTV0x6E") +// CHECK-NEXT: %6 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @"{{.*}}/cl/_testgo/abimethod.struct${{[-A-Za-z0-9_]+}}") // CHECK-NEXT: %7 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %6, 0 // CHECK-NEXT: %8 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %7, ptr %5, 1 // CHECK-NEXT: %9 = call ptr @"{{.*}}/runtime/internal/runtime.IfacePtrData"(%"{{.*}}/runtime/internal/runtime.iface" %8) @@ -411,7 +411,7 @@ type I2 interface { // CHECK-NEXT: %3 = getelementptr inbounds %main.T, ptr %2, i32 0, i32 0 // CHECK-NEXT: store i64 10, ptr %1, align 8 // CHECK-NEXT: store i64 100, ptr %3, align 8 -// CHECK-NEXT: %4 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$WkyTd7mXEW0USaC6FIo7OG9IdUUyjAJl_h3PFrMEtHc", ptr @"*{{.*}}/cl/_testgo/abimethod.struct$wV1HLSFXt7Wv7h73sIB8bnWmKRl_W0D4YiEDGTV0x6E") +// CHECK-NEXT: %4 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @"*{{.*}}/cl/_testgo/abimethod.struct${{[-A-Za-z0-9_]+}}") // CHECK-NEXT: %5 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %4, 0 // CHECK-NEXT: %6 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %5, ptr %0, 1 // CHECK-NEXT: %7 = call ptr @"{{.*}}/runtime/internal/runtime.IfacePtrData"(%"{{.*}}/runtime/internal/runtime.iface" %6) @@ -445,7 +445,7 @@ type I2 interface { // CHECK-NEXT: %3 = getelementptr inbounds %main.T, ptr %2, i32 0, i32 0 // CHECK-NEXT: store i64 10, ptr %1, align 8 // CHECK-NEXT: store i64 100, ptr %3, align 8 -// CHECK-NEXT: %4 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$GIQLduxo5T_xLwYbboAKy8LzikHgsGzb7WxrkOH3Lr4", ptr @"*{{.*}}/cl/_testgo/abimethod.struct$wV1HLSFXt7Wv7h73sIB8bnWmKRl_W0D4YiEDGTV0x6E") +// CHECK-NEXT: %4 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @"*{{.*}}/cl/_testgo/abimethod.struct${{[-A-Za-z0-9_]+}}") // CHECK-NEXT: %5 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %4, 0 // CHECK-NEXT: %6 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %5, ptr %0, 1 // CHECK-NEXT: %7 = call ptr @"{{.*}}/runtime/internal/runtime.IfacePtrData"(%"{{.*}}/runtime/internal/runtime.iface" %6) @@ -485,7 +485,7 @@ type I2 interface { // CHECK-NEXT: %5 = load { i64, ptr }, ptr %0, align 8 // CHECK-NEXT: %6 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) // CHECK-NEXT: store { i64, ptr } %5, ptr %6, align 8 -// CHECK-NEXT: %7 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$GIQLduxo5T_xLwYbboAKy8LzikHgsGzb7WxrkOH3Lr4", ptr @"{{.*}}/cl/_testgo/abimethod.struct$uZOBdiU3hXPUbVo89Hd5Yu-O7H5aW05rvCsBARpyejU") +// CHECK-NEXT: %7 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @"{{.*}}/cl/_testgo/abimethod.struct${{[-A-Za-z0-9_]+}}") // CHECK-NEXT: %8 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %7, 0 // CHECK-NEXT: %9 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %8, ptr %6, 1 // CHECK-NEXT: %10 = call ptr @"{{.*}}/runtime/internal/runtime.IfacePtrData"(%"{{.*}}/runtime/internal/runtime.iface" %9) @@ -525,7 +525,7 @@ type I2 interface { // CHECK-NEXT: %5 = load { i64, ptr }, ptr %0, align 8 // CHECK-NEXT: %6 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) // CHECK-NEXT: store { i64, ptr } %5, ptr %6, align 8 -// CHECK-NEXT: %7 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$58AxoxqQ6sGUOM73FOqFrXsMlgxkU4HGd-S1Wl-ssYw", ptr @"{{.*}}/cl/_testgo/abimethod.struct$uZOBdiU3hXPUbVo89Hd5Yu-O7H5aW05rvCsBARpyejU") +// CHECK-NEXT: %7 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @"{{.*}}/cl/_testgo/abimethod.struct${{[-A-Za-z0-9_]+}}") // CHECK-NEXT: %8 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %7, 0 // CHECK-NEXT: %9 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %8, ptr %6, 1 // CHECK-NEXT: %10 = call ptr @"{{.*}}/runtime/internal/runtime.IfacePtrData"(%"{{.*}}/runtime/internal/runtime.iface" %9) @@ -585,7 +585,7 @@ type I2 interface { // CHECK-NEXT: %5 = load { i64, ptr }, ptr %0, align 8 // CHECK-NEXT: %6 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) // CHECK-NEXT: store { i64, ptr } %5, ptr %6, align 8 -// CHECK-NEXT: %7 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"{{.*}}/cl/_testgo/abimethod.iface$kT5SIXt45Cspjl04Bof3DZVSOIltlDo-njpk6KqtZvA", ptr @"{{.*}}/cl/_testgo/abimethod.struct$uZOBdiU3hXPUbVo89Hd5Yu-O7H5aW05rvCsBARpyejU") +// CHECK-NEXT: %7 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"{{.*}}/cl/_testgo/abimethod.iface${{[-A-Za-z0-9_]+}}", ptr @"{{.*}}/cl/_testgo/abimethod.struct${{[-A-Za-z0-9_]+}}") // CHECK-NEXT: %8 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %7, 0 // CHECK-NEXT: %9 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %8, ptr %6, 1 // CHECK-NEXT: %10 = call ptr @"{{.*}}/runtime/internal/runtime.IfacePtrData"(%"{{.*}}/runtime/internal/runtime.iface" %9) @@ -659,7 +659,7 @@ type I2 interface { // CHECK-NEXT: %3 = call ptr @bytes.NewBufferString(%"{{.*}}/runtime/internal/runtime.String" { ptr @26, i64 5 }) // CHECK-NEXT: store i64 10, ptr %1, align 8 // CHECK-NEXT: store ptr %3, ptr %2, align 8 -// CHECK-NEXT: %4 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$O6rEVxIuA5O1E0KWpQBCgGx26X5gYhJ_nnJnHVL8_7U", ptr @"*{{.*}}/cl/_testgo/abimethod.struct$RGW016k7zllXgGPm1CvD5-IBe-9lphOOTCFtYyDGLjY") +// CHECK-NEXT: %4 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @"*{{.*}}/cl/_testgo/abimethod.struct${{[-A-Za-z0-9_]+}}") // CHECK-NEXT: %5 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %4, 0 // CHECK-NEXT: %6 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %5, ptr %0, 1 // CHECK-NEXT: %7 = call ptr @"{{.*}}/runtime/internal/runtime.IfacePtrData"(%"{{.*}}/runtime/internal/runtime.iface" %6) @@ -689,7 +689,7 @@ type I2 interface { // CHECK-LABEL: define void @main.testGeneric(){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %0 = call ptr @"{{.*}}/runtime/internal/runtime.AllocZ"(i64 8) -// CHECK-NEXT: %1 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$uinGjIxPTfzB5e5h5gH-0VIvLl5rQdJ_yx2UsrxQqds", ptr @"*_llgo_main.Pointer[any]") +// CHECK-NEXT: %1 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @"*_llgo_main.Pointer[any]") // CHECK-NEXT: %2 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %1, 0 // CHECK-NEXT: %3 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %2, ptr %0, 1 // CHECK-NEXT: %4 = call ptr @"main.testGeneric$1"() @@ -752,7 +752,7 @@ type I2 interface { // CHECK-NEXT: %0 = call ptr @"{{.*}}/runtime/internal/runtime.AllocZ"(i64 8) // CHECK-NEXT: %1 = getelementptr inbounds %main.T, ptr %0, i32 0, i32 0 // CHECK-NEXT: store i64 100, ptr %1, align 8 -// CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$WkyTd7mXEW0USaC6FIo7OG9IdUUyjAJl_h3PFrMEtHc", ptr @"*_llgo_main.T") +// CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @"*_llgo_main.T") // CHECK-NEXT: %3 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %2, 0 // CHECK-NEXT: %4 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %3, ptr %0, 1 // CHECK-NEXT: %5 = call ptr @"{{.*}}/runtime/internal/runtime.IfacePtrData"(%"{{.*}}/runtime/internal/runtime.iface" %4) @@ -787,7 +787,7 @@ type I2 interface { // CHECK-NEXT: %2 = load %main.T, ptr %0, align 8 // CHECK-NEXT: %3 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 8) // CHECK-NEXT: store %main.T %2, ptr %3, align 8 -// CHECK-NEXT: %4 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$WkyTd7mXEW0USaC6FIo7OG9IdUUyjAJl_h3PFrMEtHc", ptr @_llgo_main.T) +// CHECK-NEXT: %4 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @_llgo_main.T) // CHECK-NEXT: %5 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %4, 0 // CHECK-NEXT: %6 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %5, ptr %3, 1 // CHECK-NEXT: %7 = call ptr @"{{.*}}/runtime/internal/runtime.IfacePtrData"(%"{{.*}}/runtime/internal/runtime.iface" %6) @@ -818,7 +818,7 @@ type I2 interface { // CHECK-NEXT: %0 = call ptr @"{{.*}}/runtime/internal/runtime.AllocZ"(i64 8) // CHECK-NEXT: %1 = getelementptr inbounds %main.T, ptr %0, i32 0, i32 0 // CHECK-NEXT: store i64 100, ptr %1, align 8 -// CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$GIQLduxo5T_xLwYbboAKy8LzikHgsGzb7WxrkOH3Lr4", ptr @"*_llgo_main.T") +// CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @"*_llgo_main.T") // CHECK-NEXT: %3 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %2, 0 // CHECK-NEXT: %4 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %3, ptr %0, 1 // CHECK-NEXT: %5 = call ptr @"{{.*}}/runtime/internal/runtime.IfacePtrData"(%"{{.*}}/runtime/internal/runtime.iface" %4) diff --git a/cl/_testgo/closureall/in.go b/cl/_testgo/closureall/in.go index 20efa1471b..3b4dafe116 100644 --- a/cl/_testgo/closureall/in.go +++ b/cl/_testgo/closureall/in.go @@ -167,7 +167,7 @@ func makeWithFree(base int) Fn { // CHECK-NEXT: %__llgo_funcval_code2 = call ptr asm "", "=r,0"(ptr %15) // CHECK-NEXT: %16 = call i64 %__llgo_funcval_code2(ptr {{(nest|swiftself)}} %14, i64 7) // CHECK-NEXT: %17 = call i64 @"main.(*S).Add$thunk"(ptr %9, i64 8) -// CHECK-NEXT: %18 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$VdBKYV8-gcMjZtZfcf-u2oKoj9Lu3VXwuG8TGCW2S4A", ptr @"*_llgo_main.S") +// CHECK-NEXT: %18 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @"*_llgo_main.S") // CHECK-NEXT: %19 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %18, 0 // CHECK-NEXT: %20 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %19, ptr %9, 1 // CHECK-NEXT: %21 = call ptr @"{{.*}}/runtime/internal/runtime.IfaceType"(%"{{.*}}/runtime/internal/runtime.iface" %20) @@ -189,7 +189,7 @@ func makeWithFree(base int) Fn { // CHECK-NEXT: ret void // CHECK-EMPTY: // CHECK-NEXT: _llgo_2: ; preds = %_llgo_0 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr @"_llgo_iface$VdBKYV8-gcMjZtZfcf-u2oKoj9Lu3VXwuG8TGCW2S4A", ptr %21, ptr @"_llgo_iface$VdBKYV8-gcMjZtZfcf-u2oKoj9Lu3VXwuG8TGCW2S4A", %"{{.*}}/runtime/internal/runtime.String" { ptr @7, i64 3 }) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr %21, ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", %"{{.*}}/runtime/internal/runtime.String" { ptr @7, i64 3 }) // CHECK-NEXT: unreachable // CHECK-NEXT: } diff --git a/cl/_testgo/closureenv/in.go b/cl/_testgo/closureenv/in.go index 06ad8be1f7..91c91bf34a 100644 --- a/cl/_testgo/closureenv/in.go +++ b/cl/_testgo/closureenv/in.go @@ -142,7 +142,7 @@ func main() { // CHECK-NEXT: unreachable // CHECK-EMPTY: // CHECK-NEXT: _llgo_8: ; preds = %_llgo_6 -// CHECK-NEXT: %30 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$36psrSzSiKQuwmDQNUwPgWt23w6DHhlw0KM1_Hu7IbY", ptr @"*_llgo_main.nilReceiver") +// CHECK-NEXT: %30 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @"*_llgo_main.nilReceiver") // CHECK-NEXT: %31 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %30, 0 // CHECK-NEXT: %32 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %31, ptr null, 1 // CHECK-NEXT: %33 = call ptr @"{{.*}}/runtime/internal/runtime.IfaceType"(%"{{.*}}/runtime/internal/runtime.iface" %32) @@ -173,7 +173,7 @@ func main() { // CHECK-NEXT: br i1 %42, label %_llgo_10, label %_llgo_9 // CHECK-EMPTY: // CHECK-NEXT: _llgo_12: ; preds = %_llgo_8 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr @"_llgo_iface$36psrSzSiKQuwmDQNUwPgWt23w6DHhlw0KM1_Hu7IbY", ptr %33, ptr @"_llgo_iface$36psrSzSiKQuwmDQNUwPgWt23w6DHhlw0KM1_Hu7IbY", %"{{.*}}/runtime/internal/runtime.String" { ptr @6, i64 5 }) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr %33, ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", %"{{.*}}/runtime/internal/runtime.String" { ptr @6, i64 5 }) // CHECK-NEXT: unreachable // CHECK-NEXT: } diff --git a/cl/_testgo/defer4/in.go b/cl/_testgo/defer4/in.go index 703e18be39..8b42b91f67 100644 --- a/cl/_testgo/defer4/in.go +++ b/cl/_testgo/defer4/in.go @@ -47,7 +47,7 @@ func main() { // CHECK-LABEL: define void @main.fail(){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %0 = call ptr @"{{.*}}/runtime/internal/runtime.GetThreadDefer"() -// CHECK-NEXT: %1 = alloca i8, i64 {{[0-9]+}}, align 1 +// CHECK-NEXT: %1 = alloca i8 // CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 48) // CHECK-NEXT: %3 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, i32 0, i32 0 // CHECK-NEXT: store ptr %1, ptr %3, align 8 @@ -176,7 +176,7 @@ func main() { // CHECK-LABEL: define void @main.main(){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %0 = call ptr @"{{.*}}/runtime/internal/runtime.GetThreadDefer"() -// CHECK-NEXT: %1 = alloca i8, i64 {{[0-9]+}}, align 1 +// CHECK-NEXT: %1 = alloca i8 // CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 48) // CHECK-NEXT: %3 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, i32 0, i32 0 // CHECK-NEXT: store ptr %1, ptr %3, align 8 diff --git a/cl/_testgo/deferclosure/in.go b/cl/_testgo/deferclosure/in.go index 852f8df233..bb8af74aac 100644 --- a/cl/_testgo/deferclosure/in.go +++ b/cl/_testgo/deferclosure/in.go @@ -133,7 +133,7 @@ func main() { // CHECK-NEXT: store ptr %0, ptr %2, align 8 // CHECK-NEXT: %3 = insertvalue { ptr, ptr } { ptr @"main.testDeferClosureValue$1", ptr undef }, ptr %1, 1 // CHECK-NEXT: %4 = call ptr @"{{.*}}/runtime/internal/runtime.GetThreadDefer"() -// CHECK-NEXT: %5 = alloca i8, i64 {{.*}}, align 1 +// CHECK-NEXT: %5 = alloca i8 // CHECK-NEXT: %6 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 48) // CHECK-NEXT: %7 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %6, i32 0, i32 0 // CHECK-NEXT: store ptr %5, ptr %7, align 8 @@ -233,7 +233,7 @@ func main() { // CHECK-NEXT: %2 = getelementptr inbounds %main.FuncHolder, ptr %0, i32 0, i32 0 // CHECK-NEXT: %3 = load volatile { ptr, ptr }, ptr %2, align 8 // CHECK-NEXT: %4 = call ptr @"{{.*}}/runtime/internal/runtime.GetThreadDefer"() -// CHECK-NEXT: %5 = alloca i8, i64 {{.*}}, align 1 +// CHECK-NEXT: %5 = alloca i8 // CHECK-NEXT: %6 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 48) // CHECK-NEXT: %7 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %6, i32 0, i32 0 // CHECK-NEXT: store ptr %5, ptr %7, align 8 @@ -326,7 +326,7 @@ func main() { // CHECK-NEXT: %0 = call ptr @"{{.*}}/runtime/internal/runtime.AllocZ"(i64 16) // CHECK-NEXT: call void @"main.(*Handler).SetHandler"(ptr %0, { ptr, ptr } { ptr @"main.testDeferMethodLiteral$1", ptr null }) // CHECK-NEXT: %1 = call ptr @"{{.*}}/runtime/internal/runtime.GetThreadDefer"() -// CHECK-NEXT: %2 = alloca i8, i64 {{.*}}, align 1 +// CHECK-NEXT: %2 = alloca i8 // CHECK-NEXT: %3 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 48) // CHECK-NEXT: %4 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %3, i32 0, i32 0 // CHECK-NEXT: store ptr %2, ptr %4, align 8 @@ -430,7 +430,7 @@ func main() { // CHECK-NEXT: store ptr %1, ptr %3, align 8 // CHECK-NEXT: %4 = insertvalue { ptr, ptr } { ptr @"main.testDeferStructClosure$1", ptr undef }, ptr %2, 1 // CHECK-NEXT: %5 = call ptr @"{{.*}}/runtime/internal/runtime.GetThreadDefer"() -// CHECK-NEXT: %6 = alloca i8, i64 {{.*}}, align 1 +// CHECK-NEXT: %6 = alloca i8 // CHECK-NEXT: %7 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 48) // CHECK-NEXT: %8 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %7, i32 0, i32 0 // CHECK-NEXT: store ptr %6, ptr %8, align 8 diff --git a/cl/_testgo/genericembediface/in.go b/cl/_testgo/genericembediface/in.go index 2b298c83d6..adffded214 100644 --- a/cl/_testgo/genericembediface/in.go +++ b/cl/_testgo/genericembediface/in.go @@ -47,13 +47,13 @@ func main() { // CHECK-EMPTY: // CHECK-NEXT: _llgo_1: ; preds = %_llgo_0 // CHECK-NEXT: %4 = extractvalue %"{{.*}}/runtime/internal/runtime.eface" %0, 1 -// CHECK-NEXT: %5 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$BvNBaULAPv8d6dMcw84Vo_vBubLQ8fAehPBYVHY6m7g", ptr %2) +// CHECK-NEXT: %5 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr %2) // CHECK-NEXT: %6 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %5, 0 // CHECK-NEXT: %7 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %6, ptr %4, 1 // CHECK-NEXT: %8 = call ptr @"{{.*}}/runtime/internal/runtime.AllocZ"(i64 16) // CHECK-NEXT: %9 = getelementptr inbounds %"{{.*}}/cl/_testgo/genericembediface/streamlib.GenericServerStream[main.Request,main.Response]", ptr %8, i32 0, i32 0 // CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.iface" %1, ptr %9, align 8 -// CHECK-NEXT: %10 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$v_XV1q3uiNvAZy1sSF5r_9UE2XfxcttHV0UKe3XpAeo", ptr @"*_llgo_{{.*}}/cl/_testgo/genericembediface/streamlib.GenericServerStream[main.Request,main.Response]") +// CHECK-NEXT: %10 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @"*_llgo_{{.*}}/cl/_testgo/genericembediface/streamlib.GenericServerStream[main.Request,main.Response]") // CHECK-NEXT: %11 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %10, 0 // CHECK-NEXT: %12 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %11, ptr %8, 1 // CHECK-NEXT: %13 = call ptr @"{{.*}}/runtime/internal/runtime.IfacePtrData"(%"{{.*}}/runtime/internal/runtime.iface" %7) @@ -93,7 +93,7 @@ func main() { // CHECK-NEXT: %1 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @_llgo_main.server, ptr undef }, ptr %0, 1 // CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 0) // CHECK-NEXT: store %main.stream zeroinitializer, ptr %2, align 1 -// CHECK-NEXT: %3 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$v_XV1q3uiNvAZy1sSF5r_9UE2XfxcttHV0UKe3XpAeo", ptr @_llgo_main.stream) +// CHECK-NEXT: %3 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @_llgo_main.stream) // CHECK-NEXT: %4 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %3, 0 // CHECK-NEXT: %5 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %4, ptr %2, 1 // CHECK-NEXT: %6 = call %"{{.*}}/runtime/internal/runtime.iface" @main.handler(%"{{.*}}/runtime/internal/runtime.eface" %1, %"{{.*}}/runtime/internal/runtime.iface" %5) diff --git a/cl/_testgo/goexit/in.go b/cl/_testgo/goexit/in.go index c46bd150eb..ad67e5dc77 100644 --- a/cl/_testgo/goexit/in.go +++ b/cl/_testgo/goexit/in.go @@ -93,7 +93,7 @@ func demo3() { // CHECK-NEXT: store ptr %2, ptr %4, align 8 // CHECK-NEXT: %5 = insertvalue { ptr, ptr } { ptr @"main.demo1$1$1", ptr undef }, ptr %3, 1 // CHECK-NEXT: %6 = call ptr @"{{.*}}/runtime/internal/runtime.GetThreadDefer"() -// CHECK-NEXT: %7 = alloca i8, i64 {{.*}}, align 1 +// CHECK-NEXT: %7 = alloca i8 // CHECK-NEXT: %8 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 48) // CHECK-NEXT: %9 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %8, i32 0, i32 0 // CHECK-NEXT: store ptr %7, ptr %9, align 8 @@ -216,7 +216,7 @@ func demo3() { // CHECK-NEXT: store ptr %2, ptr %4, align 8 // CHECK-NEXT: %5 = insertvalue { ptr, ptr } { ptr @"main.demo2$1$1", ptr undef }, ptr %3, 1 // CHECK-NEXT: %6 = call ptr @"{{.*}}/runtime/internal/runtime.GetThreadDefer"() -// CHECK-NEXT: %7 = alloca i8, i64 {{.*}}, align 1 +// CHECK-NEXT: %7 = alloca i8 // CHECK-NEXT: %8 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 48) // CHECK-NEXT: %9 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %8, i32 0, i32 0 // CHECK-NEXT: store ptr %7, ptr %9, align 8 @@ -357,7 +357,7 @@ func demo3() { // CHECK-NEXT: store ptr %2, ptr %4, align 8 // CHECK-NEXT: %5 = insertvalue { ptr, ptr } { ptr @"main.demo3$1$1", ptr undef }, ptr %3, 1 // CHECK-NEXT: %6 = call ptr @"{{.*}}/runtime/internal/runtime.GetThreadDefer"() -// CHECK-NEXT: %7 = alloca i8, i64 {{.*}}, align 1 +// CHECK-NEXT: %7 = alloca i8 // CHECK-NEXT: %8 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 48) // CHECK-NEXT: %9 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %8, i32 0, i32 0 // CHECK-NEXT: store ptr %7, ptr %9, align 8 diff --git a/cl/_testgo/ifaceprom/in.go b/cl/_testgo/ifaceprom/in.go index 08e47ad91f..329a065825 100644 --- a/cl/_testgo/ifaceprom/in.go +++ b/cl/_testgo/ifaceprom/in.go @@ -197,7 +197,7 @@ func main() { // CHECK-NEXT: %1 = getelementptr inbounds %main.S, ptr %0, i32 0, i32 0 // CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 0) // CHECK-NEXT: store %main.impl zeroinitializer, ptr %2, align 1 -// CHECK-NEXT: %3 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"{{.*}}/cl/_testgo/ifaceprom.iface$zZ89tENb5h_KNjvpxf1TXPfaWFYn0IZrZwyVf42lRtA", ptr @_llgo_main.impl) +// CHECK-NEXT: %3 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"{{.*}}/cl/_testgo/ifaceprom.iface${{[-A-Za-z0-9_]+}}", ptr @_llgo_main.impl) // CHECK-NEXT: %4 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %3, 0 // CHECK-NEXT: %5 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %4, ptr %2, 1 // CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.iface" %5, ptr %1, align 8 diff --git a/cl/_testgo/indexerr/in.go b/cl/_testgo/indexerr/in.go index b820551c2c..38882a81f9 100644 --- a/cl/_testgo/indexerr/in.go +++ b/cl/_testgo/indexerr/in.go @@ -215,7 +215,7 @@ func slice2(n int) { // CHECK-LABEL: define void @"main.init#1"(){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %0 = call ptr @"{{.*}}/runtime/internal/runtime.GetThreadDefer"() -// CHECK-NEXT: %1 = alloca i8, i64 {{.*}}, align 1 +// CHECK-NEXT: %1 = alloca i8 // CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 48) // CHECK-NEXT: %3 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, i32 0, i32 0 // CHECK-NEXT: store ptr %1, ptr %3, align 8 @@ -290,7 +290,7 @@ func slice2(n int) { // CHECK-LABEL: define void @"main.init#10"(){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %0 = call ptr @"{{.*}}/runtime/internal/runtime.GetThreadDefer"() -// CHECK-NEXT: %1 = alloca i8, i64 {{.*}}, align 1 +// CHECK-NEXT: %1 = alloca i8 // CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 48) // CHECK-NEXT: %3 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, i32 0, i32 0 // CHECK-NEXT: store ptr %1, ptr %3, align 8 @@ -381,7 +381,7 @@ func slice2(n int) { // CHECK-LABEL: define void @"main.init#11"(){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %0 = call ptr @"{{.*}}/runtime/internal/runtime.GetThreadDefer"() -// CHECK-NEXT: %1 = alloca i8, i64 {{.*}}, align 1 +// CHECK-NEXT: %1 = alloca i8 // CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 48) // CHECK-NEXT: %3 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, i32 0, i32 0 // CHECK-NEXT: store ptr %1, ptr %3, align 8 @@ -471,7 +471,7 @@ func slice2(n int) { // CHECK-LABEL: define void @"main.init#12"(){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %0 = call ptr @"{{.*}}/runtime/internal/runtime.GetThreadDefer"() -// CHECK-NEXT: %1 = alloca i8, i64 {{.*}}, align 1 +// CHECK-NEXT: %1 = alloca i8 // CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 48) // CHECK-NEXT: %3 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, i32 0, i32 0 // CHECK-NEXT: store ptr %1, ptr %3, align 8 @@ -561,7 +561,7 @@ func slice2(n int) { // CHECK-LABEL: define void @"main.init#2"(){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %0 = call ptr @"{{.*}}/runtime/internal/runtime.GetThreadDefer"() -// CHECK-NEXT: %1 = alloca i8, i64 {{.*}}, align 1 +// CHECK-NEXT: %1 = alloca i8 // CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 48) // CHECK-NEXT: %3 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, i32 0, i32 0 // CHECK-NEXT: store ptr %1, ptr %3, align 8 @@ -636,7 +636,7 @@ func slice2(n int) { // CHECK-LABEL: define void @"main.init#3"(){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %0 = call ptr @"{{.*}}/runtime/internal/runtime.GetThreadDefer"() -// CHECK-NEXT: %1 = alloca i8, i64 {{.*}}, align 1 +// CHECK-NEXT: %1 = alloca i8 // CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 48) // CHECK-NEXT: %3 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, i32 0, i32 0 // CHECK-NEXT: store ptr %1, ptr %3, align 8 @@ -711,7 +711,7 @@ func slice2(n int) { // CHECK-LABEL: define void @"main.init#4"(){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %0 = call ptr @"{{.*}}/runtime/internal/runtime.GetThreadDefer"() -// CHECK-NEXT: %1 = alloca i8, i64 {{.*}}, align 1 +// CHECK-NEXT: %1 = alloca i8 // CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 48) // CHECK-NEXT: %3 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, i32 0, i32 0 // CHECK-NEXT: store ptr %1, ptr %3, align 8 @@ -786,7 +786,7 @@ func slice2(n int) { // CHECK-LABEL: define void @"main.init#5"(){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %0 = call ptr @"{{.*}}/runtime/internal/runtime.GetThreadDefer"() -// CHECK-NEXT: %1 = alloca i8, i64 {{.*}}, align 1 +// CHECK-NEXT: %1 = alloca i8 // CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 48) // CHECK-NEXT: %3 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, i32 0, i32 0 // CHECK-NEXT: store ptr %1, ptr %3, align 8 @@ -861,7 +861,7 @@ func slice2(n int) { // CHECK-LABEL: define void @"main.init#6"(){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %0 = call ptr @"{{.*}}/runtime/internal/runtime.GetThreadDefer"() -// CHECK-NEXT: %1 = alloca i8, i64 {{.*}}, align 1 +// CHECK-NEXT: %1 = alloca i8 // CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 48) // CHECK-NEXT: %3 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, i32 0, i32 0 // CHECK-NEXT: store ptr %1, ptr %3, align 8 @@ -936,7 +936,7 @@ func slice2(n int) { // CHECK-LABEL: define void @"main.init#7"(){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %0 = call ptr @"{{.*}}/runtime/internal/runtime.GetThreadDefer"() -// CHECK-NEXT: %1 = alloca i8, i64 {{.*}}, align 1 +// CHECK-NEXT: %1 = alloca i8 // CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 48) // CHECK-NEXT: %3 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, i32 0, i32 0 // CHECK-NEXT: store ptr %1, ptr %3, align 8 @@ -1022,7 +1022,7 @@ func slice2(n int) { // CHECK-LABEL: define void @"main.init#8"(){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %0 = call ptr @"{{.*}}/runtime/internal/runtime.GetThreadDefer"() -// CHECK-NEXT: %1 = alloca i8, i64 {{.*}}, align 1 +// CHECK-NEXT: %1 = alloca i8 // CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 48) // CHECK-NEXT: %3 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, i32 0, i32 0 // CHECK-NEXT: store ptr %1, ptr %3, align 8 @@ -1108,7 +1108,7 @@ func slice2(n int) { // CHECK-LABEL: define void @"main.init#9"(){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %0 = call ptr @"{{.*}}/runtime/internal/runtime.GetThreadDefer"() -// CHECK-NEXT: %1 = alloca i8, i64 {{.*}}, align 1 +// CHECK-NEXT: %1 = alloca i8 // CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 48) // CHECK-NEXT: %3 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, i32 0, i32 0 // CHECK-NEXT: store ptr %1, ptr %3, align 8 diff --git a/cl/_testgo/invoke/in.go b/cl/_testgo/invoke/in.go index f9c29180f1..51f6f3f8ad 100644 --- a/cl/_testgo/invoke/in.go +++ b/cl/_testgo/invoke/in.go @@ -336,87 +336,87 @@ type M interface { // CHECK-NEXT: %10 = load %main.T, ptr %0, align 8 // CHECK-NEXT: %11 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) // CHECK-NEXT: store %main.T %10, ptr %11, align 8 -// CHECK-NEXT: %12 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$uRUteI7wmSy7y7ODhGzk0FdDaxGKMhVSSu6HZEv9aa0", ptr @_llgo_main.T) +// CHECK-NEXT: %12 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @_llgo_main.T) // CHECK-NEXT: %13 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %12, 0 // CHECK-NEXT: %14 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %13, ptr %11, 1 // CHECK-NEXT: call void @main.invoke(%"{{.*}}/runtime/internal/runtime.iface" %14) -// CHECK-NEXT: %15 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$uRUteI7wmSy7y7ODhGzk0FdDaxGKMhVSSu6HZEv9aa0", ptr @"*_llgo_main.T") +// CHECK-NEXT: %15 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @"*_llgo_main.T") // CHECK-NEXT: %16 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %15, 0 // CHECK-NEXT: %17 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %16, ptr %0, 1 // CHECK-NEXT: call void @main.invoke(%"{{.*}}/runtime/internal/runtime.iface" %17) // CHECK-NEXT: %18 = load i64, ptr %2, align 8 // CHECK-NEXT: %19 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 8) // CHECK-NEXT: store i64 %18, ptr %19, align 8 -// CHECK-NEXT: %20 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$uRUteI7wmSy7y7ODhGzk0FdDaxGKMhVSSu6HZEv9aa0", ptr @_llgo_main.T1) +// CHECK-NEXT: %20 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @_llgo_main.T1) // CHECK-NEXT: %21 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %20, 0 // CHECK-NEXT: %22 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %21, ptr %19, 1 // CHECK-NEXT: call void @main.invoke(%"{{.*}}/runtime/internal/runtime.iface" %22) -// CHECK-NEXT: %23 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$uRUteI7wmSy7y7ODhGzk0FdDaxGKMhVSSu6HZEv9aa0", ptr @"*_llgo_main.T1") +// CHECK-NEXT: %23 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @"*_llgo_main.T1") // CHECK-NEXT: %24 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %23, 0 // CHECK-NEXT: %25 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %24, ptr %2, 1 // CHECK-NEXT: call void @main.invoke(%"{{.*}}/runtime/internal/runtime.iface" %25) // CHECK-NEXT: %26 = load double, ptr %3, align 8 // CHECK-NEXT: %27 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 8) // CHECK-NEXT: store double %26, ptr %27, align 8 -// CHECK-NEXT: %28 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$uRUteI7wmSy7y7ODhGzk0FdDaxGKMhVSSu6HZEv9aa0", ptr @_llgo_main.T2) +// CHECK-NEXT: %28 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @_llgo_main.T2) // CHECK-NEXT: %29 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %28, 0 // CHECK-NEXT: %30 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %29, ptr %27, 1 // CHECK-NEXT: call void @main.invoke(%"{{.*}}/runtime/internal/runtime.iface" %30) -// CHECK-NEXT: %31 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$uRUteI7wmSy7y7ODhGzk0FdDaxGKMhVSSu6HZEv9aa0", ptr @"*_llgo_main.T2") +// CHECK-NEXT: %31 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @"*_llgo_main.T2") // CHECK-NEXT: %32 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %31, 0 // CHECK-NEXT: %33 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %32, ptr %3, 1 // CHECK-NEXT: call void @main.invoke(%"{{.*}}/runtime/internal/runtime.iface" %33) -// CHECK-NEXT: %34 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$uRUteI7wmSy7y7ODhGzk0FdDaxGKMhVSSu6HZEv9aa0", ptr @"*_llgo_main.T3") +// CHECK-NEXT: %34 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @"*_llgo_main.T3") // CHECK-NEXT: %35 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %34, 0 // CHECK-NEXT: %36 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %35, ptr %4, 1 // CHECK-NEXT: call void @main.invoke(%"{{.*}}/runtime/internal/runtime.iface" %36) // CHECK-NEXT: %37 = load [1 x i64], ptr %5, align 8 // CHECK-NEXT: %38 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 8) // CHECK-NEXT: store [1 x i64] %37, ptr %38, align 8 -// CHECK-NEXT: %39 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$uRUteI7wmSy7y7ODhGzk0FdDaxGKMhVSSu6HZEv9aa0", ptr @_llgo_main.T4) +// CHECK-NEXT: %39 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @_llgo_main.T4) // CHECK-NEXT: %40 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %39, 0 // CHECK-NEXT: %41 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %40, ptr %38, 1 // CHECK-NEXT: call void @main.invoke(%"{{.*}}/runtime/internal/runtime.iface" %41) -// CHECK-NEXT: %42 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$uRUteI7wmSy7y7ODhGzk0FdDaxGKMhVSSu6HZEv9aa0", ptr @"*_llgo_main.T4") +// CHECK-NEXT: %42 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @"*_llgo_main.T4") // CHECK-NEXT: %43 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %42, 0 // CHECK-NEXT: %44 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %43, ptr %5, 1 // CHECK-NEXT: call void @main.invoke(%"{{.*}}/runtime/internal/runtime.iface" %44) // CHECK-NEXT: %45 = load %main.T5, ptr %7, align 8 // CHECK-NEXT: %46 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 8) // CHECK-NEXT: store %main.T5 %45, ptr %46, align 8 -// CHECK-NEXT: %47 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$uRUteI7wmSy7y7ODhGzk0FdDaxGKMhVSSu6HZEv9aa0", ptr @_llgo_main.T5) +// CHECK-NEXT: %47 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @_llgo_main.T5) // CHECK-NEXT: %48 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %47, 0 // CHECK-NEXT: %49 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %48, ptr %46, 1 // CHECK-NEXT: call void @main.invoke(%"{{.*}}/runtime/internal/runtime.iface" %49) -// CHECK-NEXT: %50 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$uRUteI7wmSy7y7ODhGzk0FdDaxGKMhVSSu6HZEv9aa0", ptr @"*_llgo_main.T5") +// CHECK-NEXT: %50 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @"*_llgo_main.T5") // CHECK-NEXT: %51 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %50, 0 // CHECK-NEXT: %52 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %51, ptr %7, 1 // CHECK-NEXT: call void @main.invoke(%"{{.*}}/runtime/internal/runtime.iface" %52) // CHECK-NEXT: %53 = load %main.T6, ptr %9, align 8 // CHECK-NEXT: %54 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) // CHECK-NEXT: store %main.T6 %53, ptr %54, align 8 -// CHECK-NEXT: %55 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$uRUteI7wmSy7y7ODhGzk0FdDaxGKMhVSSu6HZEv9aa0", ptr @_llgo_main.T6) +// CHECK-NEXT: %55 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @_llgo_main.T6) // CHECK-NEXT: %56 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %55, 0 // CHECK-NEXT: %57 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %56, ptr %54, 1 // CHECK-NEXT: call void @main.invoke(%"{{.*}}/runtime/internal/runtime.iface" %57) -// CHECK-NEXT: %58 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$uRUteI7wmSy7y7ODhGzk0FdDaxGKMhVSSu6HZEv9aa0", ptr @"*_llgo_main.T6") +// CHECK-NEXT: %58 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @"*_llgo_main.T6") // CHECK-NEXT: %59 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %58, 0 // CHECK-NEXT: %60 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %59, ptr %9, 1 // CHECK-NEXT: call void @main.invoke(%"{{.*}}/runtime/internal/runtime.iface" %60) // CHECK-NEXT: %61 = call ptr @"{{.*}}/runtime/internal/runtime.IfaceType"(%"{{.*}}/runtime/internal/runtime.iface" zeroinitializer) -// CHECK-NEXT: %62 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$uRUteI7wmSy7y7ODhGzk0FdDaxGKMhVSSu6HZEv9aa0", ptr %61) +// CHECK-NEXT: %62 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr %61) // CHECK-NEXT: %63 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %62, 0 // CHECK-NEXT: %64 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %63, ptr null, 1 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintIface"(%"{{.*}}/runtime/internal/runtime.iface" %64) // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintByte"(i8 32) // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintIface"(%"{{.*}}/runtime/internal/runtime.iface" zeroinitializer) // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PrintByte"(i8 10) -// CHECK-NEXT: %65 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$jwmSdgh1zvY_TDIgLzCkvkbiyrdwl9N806DH0JGcyMI", ptr @"*_llgo_main.T") +// CHECK-NEXT: %65 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @"*_llgo_main.T") // CHECK-NEXT: %66 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %65, 0 // CHECK-NEXT: %67 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %66, ptr %0, 1 // CHECK-NEXT: %68 = call ptr @"{{.*}}/runtime/internal/runtime.IfaceType"(%"{{.*}}/runtime/internal/runtime.iface" %67) // CHECK-NEXT: %69 = extractvalue %"{{.*}}/runtime/internal/runtime.iface" %67, 1 -// CHECK-NEXT: %70 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$uRUteI7wmSy7y7ODhGzk0FdDaxGKMhVSSu6HZEv9aa0", ptr %68) +// CHECK-NEXT: %70 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr %68) // CHECK-NEXT: %71 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %70, 0 // CHECK-NEXT: %72 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %71, ptr %69, 1 // CHECK-NEXT: call void @main.invoke(%"{{.*}}/runtime/internal/runtime.iface" %72) @@ -434,7 +434,7 @@ type M interface { // CHECK-EMPTY: // CHECK-NEXT: _llgo_1: ; preds = %_llgo_0 // CHECK-NEXT: %80 = extractvalue %"{{.*}}/runtime/internal/runtime.eface" %77, 1 -// CHECK-NEXT: %81 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$uRUteI7wmSy7y7ODhGzk0FdDaxGKMhVSSu6HZEv9aa0", ptr %78) +// CHECK-NEXT: %81 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr %78) // CHECK-NEXT: %82 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %81, 0 // CHECK-NEXT: %83 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %82, ptr %80, 1 // CHECK-NEXT: call void @main.invoke(%"{{.*}}/runtime/internal/runtime.iface" %83) @@ -448,7 +448,7 @@ type M interface { // CHECK-EMPTY: // CHECK-NEXT: _llgo_3: ; preds = %_llgo_1 // CHECK-NEXT: %86 = extractvalue %"{{.*}}/runtime/internal/runtime.eface" %77, 0 -// CHECK-NEXT: %87 = call i1 @"{{.*}}/runtime/internal/runtime.Implements"(ptr @"_llgo_iface$uRUteI7wmSy7y7ODhGzk0FdDaxGKMhVSSu6HZEv9aa0", ptr %86) +// CHECK-NEXT: %87 = call i1 @"{{.*}}/runtime/internal/runtime.Implements"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr %86) // CHECK-NEXT: br i1 %87, label %_llgo_5, label %_llgo_6 // CHECK-EMPTY: // CHECK-NEXT: _llgo_4: ; preds = %_llgo_1 @@ -457,14 +457,14 @@ type M interface { // CHECK-EMPTY: // CHECK-NEXT: _llgo_5: ; preds = %_llgo_3 // CHECK-NEXT: %88 = extractvalue %"{{.*}}/runtime/internal/runtime.eface" %77, 1 -// CHECK-NEXT: %89 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$uRUteI7wmSy7y7ODhGzk0FdDaxGKMhVSSu6HZEv9aa0", ptr %86) +// CHECK-NEXT: %89 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr %86) // CHECK-NEXT: %90 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %89, 0 // CHECK-NEXT: %91 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %90, ptr %88, 1 // CHECK-NEXT: call void @main.invoke(%"{{.*}}/runtime/internal/runtime.iface" %91) // CHECK-NEXT: ret void // CHECK-EMPTY: // CHECK-NEXT: _llgo_6: ; preds = %_llgo_3 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr null, ptr %86, ptr @"_llgo_iface$uRUteI7wmSy7y7ODhGzk0FdDaxGKMhVSSu6HZEv9aa0", %"{{.*}}/runtime/internal/runtime.String" { ptr @2, i64 6 }) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr null, ptr %86, ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", %"{{.*}}/runtime/internal/runtime.String" { ptr @2, i64 6 }) // CHECK-NEXT: unreachable // CHECK-NEXT: } diff --git a/cl/_testgo/makeslice/in.go b/cl/_testgo/makeslice/in.go index d0a9f3db0b..66fcfdab2a 100644 --- a/cl/_testgo/makeslice/in.go +++ b/cl/_testgo/makeslice/in.go @@ -126,7 +126,7 @@ func init() { // CHECK-LABEL: define void @"main.init#3"(){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %0 = call ptr @"{{.*}}/runtime/internal/runtime.GetThreadDefer"() -// CHECK-NEXT: %1 = alloca i8, i64 {{.*}}, align 1 +// CHECK-NEXT: %1 = alloca i8 // CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 48) // CHECK-NEXT: %3 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, i32 0, i32 0 // CHECK-NEXT: store ptr %1, ptr %3, align 8 @@ -199,7 +199,7 @@ func init() { // CHECK-LABEL: define void @"main.init#4"(){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %0 = call ptr @"{{.*}}/runtime/internal/runtime.GetThreadDefer"() -// CHECK-NEXT: %1 = alloca i8, i64 {{.*}}, align 1 +// CHECK-NEXT: %1 = alloca i8 // CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 48) // CHECK-NEXT: %3 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, i32 0, i32 0 // CHECK-NEXT: store ptr %1, ptr %3, align 8 @@ -272,7 +272,7 @@ func init() { // CHECK-LABEL: define void @"main.init#5"(){{.*}} { // CHECK-NEXT: _llgo_0: // CHECK-NEXT: %0 = call ptr @"{{.*}}/runtime/internal/runtime.GetThreadDefer"() -// CHECK-NEXT: %1 = alloca i8, i64 {{.*}}, align 1 +// CHECK-NEXT: %1 = alloca i8 // CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 48) // CHECK-NEXT: %3 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %2, i32 0, i32 0 // CHECK-NEXT: store ptr %1, ptr %3, align 8 diff --git a/cl/_testgo/reader/in.go b/cl/_testgo/reader/in.go index 5b26065806..a997583739 100644 --- a/cl/_testgo/reader/in.go +++ b/cl/_testgo/reader/in.go @@ -336,7 +336,7 @@ func main() { // CHECK-NEXT: %5 = load %main.nopCloserWriterTo, ptr %3, align 8 // CHECK-NEXT: %6 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) // CHECK-NEXT: store %main.nopCloserWriterTo %5, ptr %6, align 8 -// CHECK-NEXT: %7 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$2bmbYDBStAIdmbXPPn7qIaCcpVcj2I5k6AqgqwAfh84", ptr @_llgo_main.nopCloserWriterTo) +// CHECK-NEXT: %7 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @_llgo_main.nopCloserWriterTo) // CHECK-NEXT: %8 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %7, 0 // CHECK-NEXT: %9 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %8, ptr %6, 1 // CHECK-NEXT: ret %"{{.*}}/runtime/internal/runtime.iface" %9 @@ -349,14 +349,14 @@ func main() { // CHECK-NEXT: %12 = load %main.nopCloser, ptr %10, align 8 // CHECK-NEXT: %13 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 16) // CHECK-NEXT: store %main.nopCloser %12, ptr %13, align 8 -// CHECK-NEXT: %14 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$2bmbYDBStAIdmbXPPn7qIaCcpVcj2I5k6AqgqwAfh84", ptr @_llgo_main.nopCloser) +// CHECK-NEXT: %14 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @_llgo_main.nopCloser) // CHECK-NEXT: %15 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %14, 0 // CHECK-NEXT: %16 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %15, ptr %13, 1 // CHECK-NEXT: ret %"{{.*}}/runtime/internal/runtime.iface" %16 // CHECK-EMPTY: // CHECK-NEXT: _llgo_3: ; preds = %_llgo_0 // CHECK-NEXT: %17 = extractvalue %"{{.*}}/runtime/internal/runtime.iface" %0, 1 -// CHECK-NEXT: %18 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$eN81k1zqixGTyagHw_4nqH4mGfwwehTOCTXUlbT9kzk", ptr %1) +// CHECK-NEXT: %18 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr %1) // CHECK-NEXT: %19 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %18, 0 // CHECK-NEXT: %20 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %19, ptr %17, 1 // CHECK-NEXT: %21 = insertvalue { %"{{.*}}/runtime/internal/runtime.iface", i1 } undef, %"{{.*}}/runtime/internal/runtime.iface" %20, 0 @@ -499,7 +499,7 @@ func main() { // CHECK-EMPTY: // CHECK-NEXT: _llgo_3: ; preds = %_llgo_0 // CHECK-NEXT: %31 = extractvalue %"{{.*}}/runtime/internal/runtime.iface" %0, 1 -// CHECK-NEXT: %32 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$Ly4zXiUMEac-hYAMw6b6miJ1JEhGfLyBWyBOhpsRZcU", ptr %2) +// CHECK-NEXT: %32 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr %2) // CHECK-NEXT: %33 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %32, 0 // CHECK-NEXT: %34 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %33, ptr %31, 1 // CHECK-NEXT: %35 = insertvalue { %"{{.*}}/runtime/internal/runtime.iface", i1 } undef, %"{{.*}}/runtime/internal/runtime.iface" %34, 0 @@ -546,7 +546,7 @@ func main() { // CHECK-NEXT: %0 = call ptr @"{{.*}}/runtime/internal/runtime.AllocZ"(i64 32) // CHECK-NEXT: %1 = getelementptr inbounds %main.stringReader, ptr %0, i32 0, i32 0 // CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @30, i64 11 }, ptr %1, align 8 -// CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$uycIKA3bbxRhudEjW1hHKWKdLqHQsCVy8NdW1bkQmNw", ptr @"*_llgo_main.stringReader") +// CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @"*_llgo_main.stringReader") // CHECK-NEXT: %3 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %2, 0 // CHECK-NEXT: %4 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %3, ptr %0, 1 // CHECK-NEXT: %5 = call { %"{{.*}}/runtime/internal/runtime.Slice", %"{{.*}}/runtime/internal/runtime.iface" } @main.ReadAll(%"{{.*}}/runtime/internal/runtime.iface" %4) @@ -565,7 +565,7 @@ func main() { // CHECK-NEXT: %1 = call ptr @"{{.*}}/runtime/internal/runtime.AllocZ"(i64 16) // CHECK-NEXT: %2 = getelementptr inbounds %main.errorString, ptr %1, i32 0, i32 0 // CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" %0, ptr %2, align 8 -// CHECK-NEXT: %3 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$Fh8eUJ-Gw4e6TYuajcFIOSCuqSPKAt5nS4ow7xeGXEU", ptr @"*_llgo_main.errorString") +// CHECK-NEXT: %3 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @"*_llgo_main.errorString") // CHECK-NEXT: %4 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %3, 0 // CHECK-NEXT: %5 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %4, ptr %1, 1 // CHECK-NEXT: ret %"{{.*}}/runtime/internal/runtime.iface" %5 @@ -678,7 +678,7 @@ func main() { // CHECK-EMPTY: // CHECK-NEXT: _llgo_1: ; preds = %_llgo_0 // CHECK-NEXT: %7 = extractvalue %"{{.*}}/runtime/internal/runtime.iface" %4, 1 -// CHECK-NEXT: %8 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$eN81k1zqixGTyagHw_4nqH4mGfwwehTOCTXUlbT9kzk", ptr %5) +// CHECK-NEXT: %8 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr %5) // CHECK-NEXT: %9 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %8, 0 // CHECK-NEXT: %10 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %9, ptr %7, 1 // CHECK-NEXT: %11 = call ptr @"{{.*}}/runtime/internal/runtime.IfacePtrData"(%"{{.*}}/runtime/internal/runtime.iface" %10) diff --git a/cl/_testgo/reflect/in.go b/cl/_testgo/reflect/in.go index cdf7c84549..9e4f24a569 100644 --- a/cl/_testgo/reflect/in.go +++ b/cl/_testgo/reflect/in.go @@ -402,7 +402,7 @@ func mapDemo2() { // CHECK-NEXT: %0 = call ptr @"{{.*}}/runtime/internal/runtime.AllocZ"(i64 8) // CHECK-NEXT: %1 = getelementptr inbounds %main.T, ptr %0, i32 0, i32 0 // CHECK-NEXT: store i64 1, ptr %1, align 8 -// CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$VdBKYV8-gcMjZtZfcf-u2oKoj9Lu3VXwuG8TGCW2S4A", ptr @"*_llgo_main.T") +// CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @"*_llgo_main.T") // CHECK-NEXT: %3 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %2, 0 // CHECK-NEXT: %4 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %3, ptr %0, 1 // CHECK-NEXT: %5 = call ptr @"{{.*}}/runtime/internal/runtime.IfaceType"(%"{{.*}}/runtime/internal/runtime.iface" %4) diff --git a/cl/_testgo/reflectconv/in.go b/cl/_testgo/reflectconv/in.go index 179d464a64..421699c5fd 100644 --- a/cl/_testgo/reflectconv/in.go +++ b/cl/_testgo/reflectconv/in.go @@ -8204,7 +8204,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %4588 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %4589 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 8) // CHECK-NEXT: store { i64 } zeroinitializer, ptr %4589, align 8 -// CHECK-NEXT: %4590 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @"{{.*}}/cl/_testgo/reflectconv.struct$qCYMduDqkoVspSDbQftiUv7WF_sipKSWG3oLt28TNlI", ptr undef }, ptr %4589, 1 +// CHECK-NEXT: %4590 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @"{{.*}}/cl/_testgo/reflectconv.struct${{[-A-Za-z0-9_]+}}", ptr undef }, ptr %4589, 1 // CHECK-NEXT: %4591 = extractvalue { ptr, ptr } %4588, 1 // CHECK-NEXT: %4592 = extractvalue { ptr, ptr } %4588, 0 // CHECK-NEXT: %__llgo_funcval_code592 = call ptr asm "", "=r,0"(ptr %4592) @@ -8213,7 +8213,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %4595 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %4596 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 8) // CHECK-NEXT: store { i64 } zeroinitializer, ptr %4596, align 8 -// CHECK-NEXT: %4597 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @"{{.*}}/cl/_testgo/reflectconv.struct$8xdZyDeCx3tqPdt33CJnJ-JMAObkKtPXr9OL-lBc3yU", ptr undef }, ptr %4596, 1 +// CHECK-NEXT: %4597 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @"{{.*}}/cl/_testgo/reflectconv.struct${{[-A-Za-z0-9_]+}}", ptr undef }, ptr %4596, 1 // CHECK-NEXT: %4598 = extractvalue { ptr, ptr } %4595, 1 // CHECK-NEXT: %4599 = extractvalue { ptr, ptr } %4595, 0 // CHECK-NEXT: %__llgo_funcval_code593 = call ptr asm "", "=r,0"(ptr %4599) @@ -8225,7 +8225,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %4603 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %4604 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 8) // CHECK-NEXT: store { i64 } zeroinitializer, ptr %4604, align 8 -// CHECK-NEXT: %4605 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @"{{.*}}/cl/_testgo/reflectconv.struct$8xdZyDeCx3tqPdt33CJnJ-JMAObkKtPXr9OL-lBc3yU", ptr undef }, ptr %4604, 1 +// CHECK-NEXT: %4605 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @"{{.*}}/cl/_testgo/reflectconv.struct${{[-A-Za-z0-9_]+}}", ptr undef }, ptr %4604, 1 // CHECK-NEXT: %4606 = extractvalue { ptr, ptr } %4603, 1 // CHECK-NEXT: %4607 = extractvalue { ptr, ptr } %4603, 0 // CHECK-NEXT: %__llgo_funcval_code594 = call ptr asm "", "=r,0"(ptr %4607) @@ -8234,7 +8234,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %4610 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %4611 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 8) // CHECK-NEXT: store { i64 } zeroinitializer, ptr %4611, align 8 -// CHECK-NEXT: %4612 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @"{{.*}}/cl/_testgo/reflectconv.struct$qCYMduDqkoVspSDbQftiUv7WF_sipKSWG3oLt28TNlI", ptr undef }, ptr %4611, 1 +// CHECK-NEXT: %4612 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @"{{.*}}/cl/_testgo/reflectconv.struct${{[-A-Za-z0-9_]+}}", ptr undef }, ptr %4611, 1 // CHECK-NEXT: %4613 = extractvalue { ptr, ptr } %4610, 1 // CHECK-NEXT: %4614 = extractvalue { ptr, ptr } %4610, 0 // CHECK-NEXT: %__llgo_funcval_code595 = call ptr asm "", "=r,0"(ptr %4614) @@ -8255,7 +8255,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %4625 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %4626 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 8) // CHECK-NEXT: store { i64 } zeroinitializer, ptr %4626, align 8 -// CHECK-NEXT: %4627 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @"{{.*}}/cl/_testgo/reflectconv.struct$qCYMduDqkoVspSDbQftiUv7WF_sipKSWG3oLt28TNlI", ptr undef }, ptr %4626, 1 +// CHECK-NEXT: %4627 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @"{{.*}}/cl/_testgo/reflectconv.struct${{[-A-Za-z0-9_]+}}", ptr undef }, ptr %4626, 1 // CHECK-NEXT: %4628 = extractvalue { ptr, ptr } %4625, 1 // CHECK-NEXT: %4629 = extractvalue { ptr, ptr } %4625, 0 // CHECK-NEXT: %__llgo_funcval_code597 = call ptr asm "", "=r,0"(ptr %4629) @@ -8267,7 +8267,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %4633 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %4634 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 8) // CHECK-NEXT: store { i64 } zeroinitializer, ptr %4634, align 8 -// CHECK-NEXT: %4635 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @"{{.*}}/cl/_testgo/reflectconv.struct$qCYMduDqkoVspSDbQftiUv7WF_sipKSWG3oLt28TNlI", ptr undef }, ptr %4634, 1 +// CHECK-NEXT: %4635 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @"{{.*}}/cl/_testgo/reflectconv.struct${{[-A-Za-z0-9_]+}}", ptr undef }, ptr %4634, 1 // CHECK-NEXT: %4636 = extractvalue { ptr, ptr } %4633, 1 // CHECK-NEXT: %4637 = extractvalue { ptr, ptr } %4633, 0 // CHECK-NEXT: %__llgo_funcval_code598 = call ptr asm "", "=r,0"(ptr %4637) @@ -8297,7 +8297,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %4655 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %4656 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 8) // CHECK-NEXT: store { i64 } zeroinitializer, ptr %4656, align 8 -// CHECK-NEXT: %4657 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @"{{.*}}/cl/_testgo/reflectconv.struct$8xdZyDeCx3tqPdt33CJnJ-JMAObkKtPXr9OL-lBc3yU", ptr undef }, ptr %4656, 1 +// CHECK-NEXT: %4657 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @"{{.*}}/cl/_testgo/reflectconv.struct${{[-A-Za-z0-9_]+}}", ptr undef }, ptr %4656, 1 // CHECK-NEXT: %4658 = extractvalue { ptr, ptr } %4655, 1 // CHECK-NEXT: %4659 = extractvalue { ptr, ptr } %4655, 0 // CHECK-NEXT: %__llgo_funcval_code601 = call ptr asm "", "=r,0"(ptr %4659) @@ -8309,7 +8309,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %4663 = load { ptr, ptr }, ptr @main.V, align 8 // CHECK-NEXT: %4664 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 8) // CHECK-NEXT: store { i64 } zeroinitializer, ptr %4664, align 8 -// CHECK-NEXT: %4665 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @"{{.*}}/cl/_testgo/reflectconv.struct$8xdZyDeCx3tqPdt33CJnJ-JMAObkKtPXr9OL-lBc3yU", ptr undef }, ptr %4664, 1 +// CHECK-NEXT: %4665 = insertvalue %"{{.*}}/runtime/internal/runtime.eface" { ptr @"{{.*}}/cl/_testgo/reflectconv.struct${{[-A-Za-z0-9_]+}}", ptr undef }, ptr %4664, 1 // CHECK-NEXT: %4666 = extractvalue { ptr, ptr } %4663, 1 // CHECK-NEXT: %4667 = extractvalue { ptr, ptr } %4663, 0 // CHECK-NEXT: %__llgo_funcval_code602 = call ptr asm "", "=r,0"(ptr %4667) @@ -9414,7 +9414,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %5471 = call %reflect.Value %__llgo_funcval_code734(ptr {{(nest|swiftself)}} %5469, %"{{.*}}/runtime/internal/runtime.eface" %5468) // CHECK-NEXT: %5472 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %5464, i32 0, i32 1 // CHECK-NEXT: %5473 = call ptr @"{{.*}}/runtime/internal/runtime.AllocZ"(i64 40) -// CHECK-NEXT: %5474 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$uycIKA3bbxRhudEjW1hHKWKdLqHQsCVy8NdW1bkQmNw", ptr @"*_llgo_bytes.Buffer") +// CHECK-NEXT: %5474 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @"*_llgo_bytes.Buffer") // CHECK-NEXT: %5475 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %5474, 0 // CHECK-NEXT: %5476 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %5475, ptr %5473, 1 // CHECK-NEXT: %5477 = call %reflect.Value @main.ReaderV(%"{{.*}}/runtime/internal/runtime.iface" %5476) @@ -9423,13 +9423,13 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %5478 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %1, i64 369 // CHECK-NEXT: %5479 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %5478, i32 0, i32 0 // CHECK-NEXT: %5480 = call ptr @"{{.*}}/runtime/internal/runtime.AllocZ"(i64 40) -// CHECK-NEXT: %5481 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$Zutt7i_AwOTtBOIzyS7ZA5vhcNcbk0kRAoRC98HJDos", ptr @"*_llgo_bytes.Buffer") +// CHECK-NEXT: %5481 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @"*_llgo_bytes.Buffer") // CHECK-NEXT: %5482 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %5481, 0 // CHECK-NEXT: %5483 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %5482, ptr %5480, 1 // CHECK-NEXT: %5484 = call %reflect.Value @main.ReadWriterV(%"{{.*}}/runtime/internal/runtime.iface" %5483) // CHECK-NEXT: %5485 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %5478, i32 0, i32 1 // CHECK-NEXT: %5486 = call ptr @"{{.*}}/runtime/internal/runtime.AllocZ"(i64 40) -// CHECK-NEXT: %5487 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$uycIKA3bbxRhudEjW1hHKWKdLqHQsCVy8NdW1bkQmNw", ptr @"*_llgo_bytes.Buffer") +// CHECK-NEXT: %5487 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @"*_llgo_bytes.Buffer") // CHECK-NEXT: %5488 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %5487, 0 // CHECK-NEXT: %5489 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %5488, ptr %5486, 1 // CHECK-NEXT: %5490 = call %reflect.Value @main.ReaderV(%"{{.*}}/runtime/internal/runtime.iface" %5489) @@ -9446,7 +9446,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: %5498 = call %reflect.Value %__llgo_funcval_code735(ptr {{(nest|swiftself)}} %5496, %"{{.*}}/runtime/internal/runtime.eface" %5495) // CHECK-NEXT: %5499 = getelementptr inbounds { %reflect.Value, %reflect.Value }, ptr %5491, i32 0, i32 1 // CHECK-NEXT: %5500 = call ptr @"{{.*}}/runtime/internal/runtime.AllocZ"(i64 40) -// CHECK-NEXT: %5501 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$Zutt7i_AwOTtBOIzyS7ZA5vhcNcbk0kRAoRC98HJDos", ptr @"*_llgo_bytes.Buffer") +// CHECK-NEXT: %5501 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @"*_llgo_bytes.Buffer") // CHECK-NEXT: %5502 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %5501, 0 // CHECK-NEXT: %5503 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %5502, ptr %5500, 1 // CHECK-NEXT: %5504 = call %reflect.Value @main.ReadWriterV(%"{{.*}}/runtime/internal/runtime.iface" %5503) @@ -9480,7 +9480,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: store ptr %2, ptr %4, align 8 // CHECK-NEXT: %5 = insertvalue { ptr, ptr } { ptr @"main.shouldPanic$1", ptr undef }, ptr %3, 1 // CHECK-NEXT: %6 = call ptr @"{{.*}}/runtime/internal/runtime.GetThreadDefer"() -// CHECK-NEXT: %7 = alloca i8, i64 {{[0-9]+}}, align 1 +// CHECK-NEXT: %7 = alloca i8 // CHECK-NEXT: %8 = call ptr @"{{.*}}/runtime/internal/runtime.AllocU"(i64 48) // CHECK-NEXT: %9 = getelementptr inbounds %"{{.*}}/runtime/internal/runtime.Defer", ptr %8, i32 0, i32 0 // CHECK-NEXT: store ptr %7, ptr %9, align 8 diff --git a/cl/_testgo/tpinst/main.go b/cl/_testgo/tpinst/main.go index 32a2a51dde..5b065182b7 100644 --- a/cl/_testgo/tpinst/main.go +++ b/cl/_testgo/tpinst/main.go @@ -47,7 +47,7 @@ func (pt *M[T]) value() T { // CHECK-NEXT: %0 = call ptr @"{{.*}}/runtime/internal/runtime.AllocZ"(i64 8) // CHECK-NEXT: %1 = getelementptr inbounds %"main.M[int]", ptr %0, i32 0, i32 0 // CHECK-NEXT: store i64 100, ptr %1, align 8 -// CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$Jvxc0PCI_drlfK7S5npMGdZkQLeRkQ_x2e2CifPE6w8", ptr @"*_llgo_main.M[int]") +// CHECK-NEXT: %2 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @"*_llgo_main.M[int]") // CHECK-NEXT: %3 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %2, 0 // CHECK-NEXT: %4 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %3, ptr %0, 1 // CHECK-NEXT: %5 = call ptr @"{{.*}}/runtime/internal/runtime.IfacePtrData"(%"{{.*}}/runtime/internal/runtime.iface" %4) @@ -73,7 +73,7 @@ func (pt *M[T]) value() T { // CHECK-NEXT: %17 = call ptr @"{{.*}}/runtime/internal/runtime.AllocZ"(i64 8) // CHECK-NEXT: %18 = getelementptr inbounds %"main.M[float64]", ptr %17, i32 0, i32 0 // CHECK-NEXT: store double 1.001000e+02, ptr %18, align 8 -// CHECK-NEXT: %19 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$2dxw6yZ6V86Spb7J0dTDIoWqg7ba7UDXlAlpJv3-HLk", ptr @"*_llgo_main.M[float64]") +// CHECK-NEXT: %19 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @"*_llgo_main.M[float64]") // CHECK-NEXT: %20 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %19, 0 // CHECK-NEXT: %21 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %20, ptr %17, 1 // CHECK-NEXT: %22 = call ptr @"{{.*}}/runtime/internal/runtime.IfacePtrData"(%"{{.*}}/runtime/internal/runtime.iface" %21) @@ -97,7 +97,7 @@ func (pt *M[T]) value() T { // CHECK-EMPTY: // CHECK-NEXT: _llgo_4: ; preds = %_llgo_2 // CHECK-NEXT: %34 = call ptr @"{{.*}}/runtime/internal/runtime.IfaceType"(%"{{.*}}/runtime/internal/runtime.iface" %4) -// CHECK-NEXT: %35 = call i1 @"{{.*}}/runtime/internal/runtime.Implements"(ptr @"{{.*}}/cl/_testgo/tpinst.iface$2sV9fFeqOv1SzesvwIdhTqCFzDT8ZX5buKUSAoHNSww", ptr %34) +// CHECK-NEXT: %35 = call i1 @"{{.*}}/runtime/internal/runtime.Implements"(ptr @"{{.*}}/cl/_testgo/tpinst.iface${{[-A-Za-z0-9_]+}}", ptr %34) // CHECK-NEXT: br i1 %35, label %_llgo_7, label %_llgo_8 // CHECK-EMPTY: // CHECK-NEXT: _llgo_5: ; preds = %_llgo_7 @@ -112,7 +112,7 @@ func (pt *M[T]) value() T { // CHECK-EMPTY: // CHECK-NEXT: _llgo_7: ; preds = %_llgo_4 // CHECK-NEXT: %38 = extractvalue %"{{.*}}/runtime/internal/runtime.iface" %4, 1 -// CHECK-NEXT: %39 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"{{.*}}/cl/_testgo/tpinst.iface$2sV9fFeqOv1SzesvwIdhTqCFzDT8ZX5buKUSAoHNSww", ptr %34) +// CHECK-NEXT: %39 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"{{.*}}/cl/_testgo/tpinst.iface${{[-A-Za-z0-9_]+}}", ptr %34) // CHECK-NEXT: %40 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %39, 0 // CHECK-NEXT: %41 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %40, ptr %38, 1 // CHECK-NEXT: %42 = call ptr @"{{.*}}/runtime/internal/runtime.IfacePtrData"(%"{{.*}}/runtime/internal/runtime.iface" %41) @@ -128,7 +128,7 @@ func (pt *M[T]) value() T { // CHECK-NEXT: br i1 %51, label %_llgo_5, label %_llgo_6 // CHECK-EMPTY: // CHECK-NEXT: _llgo_8: ; preds = %_llgo_4 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr @"_llgo_main.I[int]", ptr %34, ptr @"{{.*}}/cl/_testgo/tpinst.iface$2sV9fFeqOv1SzesvwIdhTqCFzDT8ZX5buKUSAoHNSww", %"{{.*}}/runtime/internal/runtime.String" { ptr @16, i64 5 }) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr @"_llgo_main.I[int]", ptr %34, ptr @"{{.*}}/cl/_testgo/tpinst.iface${{[-A-Za-z0-9_]+}}", %"{{.*}}/runtime/internal/runtime.String" { ptr @16, i64 5 }) // CHECK-NEXT: unreachable // CHECK-NEXT: } diff --git a/cl/_testrt/tpabi/in.go b/cl/_testrt/tpabi/in.go index 52ff69bdae..f9c2f365d2 100644 --- a/cl/_testrt/tpabi/in.go +++ b/cl/_testrt/tpabi/in.go @@ -83,7 +83,7 @@ func main() { // CHECK-NEXT: %13 = getelementptr inbounds %"main.T[string,int]", ptr %11, i32 0, i32 1 // CHECK-NEXT: store %"{{.*}}/runtime/internal/runtime.String" { ptr @10, i64 5 }, ptr %12, align 8 // CHECK-NEXT: store i64 100, ptr %13, align 8 -// CHECK-NEXT: %14 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface$BP0p_lUsEd-IbbtJVukGmgrdQkqzcoYzSiwgUvgFvUs", ptr @"*_llgo_main.T[string,int]") +// CHECK-NEXT: %14 = call ptr @"{{.*}}/runtime/internal/runtime.NewItab"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr @"*_llgo_main.T[string,int]") // CHECK-NEXT: %15 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" undef, ptr %14, 0 // CHECK-NEXT: %16 = insertvalue %"{{.*}}/runtime/internal/runtime.iface" %15, ptr %11, 1 // CHECK-NEXT: %17 = call ptr @"{{.*}}/runtime/internal/runtime.IfacePtrData"(%"{{.*}}/runtime/internal/runtime.iface" %16) From 3d9a4933a40d13c4ed05e82e8312291ae915a9e2 Mon Sep 17 00:00:00 2001 From: Li Jie Date: Mon, 10 Aug 2026 22:03:59 +0800 Subject: [PATCH 15/21] test/go: cover Goexit replacing an active panic --- test/go/recover_defer_fixedbugs_test.go | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+) diff --git a/test/go/recover_defer_fixedbugs_test.go b/test/go/recover_defer_fixedbugs_test.go index e0e97a825c..9b193e4258 100644 --- a/test/go/recover_defer_fixedbugs_test.go +++ b/test/go/recover_defer_fixedbugs_test.go @@ -5,6 +5,7 @@ import ( "runtime" "strings" "testing" + "time" ) type fixedbug4066Panic struct{} @@ -249,6 +250,29 @@ func TestRecoverReflectCallRemainsIndirect(t *testing.T) { } } +func TestRecoverGoexitSupersedesSuspendedPanic(t *testing.T) { + result := make(chan any, 2) + go func() { + defer func() { + result <- recover() + }() + defer func() { + runtime.Goexit() + result <- "runtime.Goexit returned" + }() + panic("outer") + }() + + select { + case got := <-result: + if got != nil { + t.Fatalf("recover during Goexit = %v, want nil", got) + } + case <-time.After(5 * time.Second): + t.Fatal("Goexit did not run the remaining defer") + } +} + var fixedbugReturnedRecover any func fixedbugReturnedRecoverFunc() func() { From 57b5a318dab05e8d7fdb0ceb4c3faa7022bb9c27 Mon Sep 17 00:00:00 2001 From: Li Jie Date: Mon, 10 Aug 2026 22:05:37 +0800 Subject: [PATCH 16/21] runtime: document recover wrapper state --- cl/compile.go | 3 +++ runtime/internal/runtime/z_rt.go | 8 ++++++-- 2 files changed, 9 insertions(+), 2 deletions(-) diff --git a/cl/compile.go b/cl/compile.go index 43c9cf94e6..433f8eb4b9 100644 --- a/cl/compile.go +++ b/cl/compile.go @@ -1969,6 +1969,9 @@ func isRecoverTransparentWrapper(fn *ssa.Function) bool { if fn == nil { return false } + // These are the Go SSA forms of compiler-generated forwarding frames. + // Treating them as transparent mirrors the standard runtime's + // abi.FuncIDWrapper rule in gorecover. return strings.HasPrefix(fn.Synthetic, "wrapper for ") || strings.HasPrefix(fn.Synthetic, "thunk for ") || strings.HasPrefix(fn.Synthetic, "bound method wrapper for ") diff --git a/runtime/internal/runtime/z_rt.go b/runtime/internal/runtime/z_rt.go index da6b9e3ae7..4421f6fe00 100644 --- a/runtime/internal/runtime/z_rt.go +++ b/runtime/internal/runtime/z_rt.go @@ -35,6 +35,9 @@ type Defer struct { Args unsafe.Pointer // defer func and args links } +// panicNode is LLGo's longjmp-backed counterpart of the standard runtime's +// _panic record. prev is the _panic.link equivalent; defer_ records the +// explicit defer frame currently owning the unwind. type panicNode struct { prev unsafe.Pointer arg any @@ -131,8 +134,9 @@ func BindRecoverFrame(function, activation unsafe.Pointer) { } } -// StartRecoverFrameAlias maps a direct deferred closure wrapper to the wrapped -// function while the wrapper calls into it. +// StartRecoverFrameAlias maps a direct deferred transparent wrapper to the +// wrapped function while the wrapper calls into it. This is the explicit-defer +// analogue of gorecover ignoring abi.FuncIDWrapper frames. func StartRecoverFrameAlias(from, to unsafe.Pointer) unsafe.Pointer { gp := getg() old := gp.recoverFrame From fd65ec6c95b579eacad1280c19f3270479208456 Mon Sep 17 00:00:00 2001 From: Li Jie Date: Mon, 10 Aug 2026 22:08:02 +0800 Subject: [PATCH 17/21] runtime: let Goexit replace active panics --- runtime/internal/runtime/z_rt.go | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) diff --git a/runtime/internal/runtime/z_rt.go b/runtime/internal/runtime/z_rt.go index 4421f6fe00..9610a285eb 100644 --- a/runtime/internal/runtime/z_rt.go +++ b/runtime/internal/runtime/z_rt.go @@ -161,6 +161,24 @@ func (gp *g) panicIsSuspended(ptr unsafe.Pointer) bool { return ptr != nil && ptr == gp.recoverPanic } +// abortPanics discards panics superseded by Goexit. The standard runtime +// represents Goexit by a goexit _panic that aborts the linked panic records +// while unwinding. LLGo stores Goexit separately on g, so it performs the +// equivalent state transition before starting its longjmp unwind. +func (gp *g) abortPanics() { + discarded := gp.panic_ != nil + for gp.panic_ != nil { + node := (*panicNode)(gp.panic_) + gp.panic_ = node.prev + c.Free(unsafe.Pointer(node)) + } + gp.recoverFrame = nil + gp.recoverPanic = nil + if discarded && PanicRecovered != nil { + PanicRecovered() + } +} + // RecoverMark, set by the public runtime package, records the recovering // frame for panic-snapshot splicing. var RecoverMark func() @@ -191,6 +209,7 @@ func Panic(v any) { } func Goexit() { gp := getg() + gp.abortPanics() gp.goexit = true Rethrow(gp.defer_) } From 72e9f900d84bc533329f6eaa0ab3c3e2a215d95c Mon Sep 17 00:00:00 2001 From: Li Jie Date: Tue, 11 Aug 2026 00:44:12 +0800 Subject: [PATCH 18/21] test/goroot: enable remaining recover cases --- test/goroot/xfail.yaml | 28 ---------------------------- 1 file changed, 28 deletions(-) diff --git a/test/goroot/xfail.yaml b/test/goroot/xfail.yaml index 1cf72243aa..9ae9c70f2f 100644 --- a/test/goroot/xfail.yaml +++ b/test/goroot/xfail.yaml @@ -1375,14 +1375,6 @@ xfails: directive: run case: mallocfin.go reason: latest main goroot run failure on darwin/arm64 - - platform: darwin/arm64 - directive: run - case: recover.go - reason: latest main goroot run failure on darwin/arm64 - - platform: darwin/arm64 - directive: run - case: recover1.go - reason: latest main goroot run failure on darwin/arm64 - platform: darwin/arm64 directive: run case: stackobj.go @@ -1440,11 +1432,6 @@ xfails: directive: run case: heapsampling.go reason: go1.24 goroot run failure on linux/amd64 - - version: go1.24 - platform: linux/amd64 - directive: run - case: recover.go - reason: go1.24 goroot run failure on linux/amd64 - version: go1.24 platform: linux/amd64 directive: run @@ -1485,11 +1472,6 @@ xfails: directive: run case: mallocfin.go reason: go1.24 goroot run failure on linux/amd64 - - version: go1.24 - platform: linux/amd64 - directive: run - case: recover1.go - reason: go1.24 goroot run failure on linux/amd64 - version: go1.24 platform: linux/amd64 directive: run @@ -1530,11 +1512,6 @@ xfails: directive: run case: mallocfin.go reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: recover1.go - reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run @@ -1575,11 +1552,6 @@ xfails: directive: run case: heapsampling.go reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: recover.go - reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run From c703a24ca4e10e0a30a8b3f08946002ddd194878 Mon Sep 17 00:00:00 2001 From: Li Jie Date: Tue, 11 Aug 2026 08:49:00 +0800 Subject: [PATCH 19/21] cl,ssa,runtime: cache recover classification Keep may-recover facts in a compilation-scoped, concurrency-safe Go SSA cache so closure values and dependency archive cache hits are classified without LLVM attributes. Make the lower-level Builder conservative, report the actual missing interface method at runtime, document bare-metal Goexit behavior, and cover the cross-package cache path. --- cl/_testdata/vargs/in.go | 2 +- cl/_testgo/abimethod/in.go | 2 +- cl/_testgo/closureall/in.go | 2 +- cl/_testgo/closureenv/in.go | 2 +- cl/_testgo/defer4/in.go | 2 +- cl/_testgo/genericembediface/in.go | 2 +- cl/_testgo/ifaceprom/in.go | 8 +- cl/_testgo/invoke/in.go | 6 +- cl/_testgo/reader/in.go | 2 +- cl/_testgo/reflect/in.go | 2 +- cl/_testgo/reflectconv/in.go | 2 +- cl/_testgo/tpinst/main.go | 3 +- cl/_testlibc/defer/in.go | 60 ++++--- cl/_testrt/any/in.go | 4 +- cl/_testrt/funcdecl/in.go | 4 +- cl/_testrt/makemap/in.go | 6 +- cl/_testrt/tpabi/in.go | 2 +- cl/_testrt/typed/in.go | 2 +- cl/caller_tracking_precompute_test.go | 14 +- cl/cgo_test.go | 12 +- cl/compile.go | 74 +------- cl/instr.go | 32 ++-- cl/recover.go | 213 ++++++++++++++++++++++++ runtime/internal/runtime/errors.go | 6 +- runtime/internal/runtime/z_baremetal.go | 3 + runtime/internal/runtime/z_face.go | 36 ++-- ssa/eh.go | 7 +- ssa/expr.go | 23 --- ssa/interface.go | 9 +- ssa/recover_metadata_test.go | 71 ++++---- test/buildcache/dep1/dep1.go | 5 + test/buildcache/main.go | 9 + test/go/recover_defer_fixedbugs_test.go | 13 ++ test/go/recoverpkg/recover.go | 6 + test/go/runtime_error_recover_test.go | 17 ++ 35 files changed, 432 insertions(+), 231 deletions(-) create mode 100644 cl/recover.go create mode 100644 test/go/recoverpkg/recover.go diff --git a/cl/_testdata/vargs/in.go b/cl/_testdata/vargs/in.go index 6ea206b10f..482b98ce24 100644 --- a/cl/_testdata/vargs/in.go +++ b/cl/_testdata/vargs/in.go @@ -87,6 +87,6 @@ func test(a ...any) { // CHECK-NEXT: br label %_llgo_1 // CHECK-EMPTY: // CHECK-NEXT: _llgo_5: ; preds = %_llgo_2 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr null, ptr %12, ptr @_llgo_int, %"{{.*}}/runtime/internal/runtime.String" zeroinitializer) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr null, ptr %12, ptr @_llgo_int) // CHECK-NEXT: unreachable // CHECK-NEXT: } diff --git a/cl/_testgo/abimethod/in.go b/cl/_testgo/abimethod/in.go index 869387be3f..004bae1e66 100644 --- a/cl/_testgo/abimethod/in.go +++ b/cl/_testgo/abimethod/in.go @@ -733,7 +733,7 @@ type I2 interface { // CHECK-NEXT: br i1 %29, label %_llgo_1, label %_llgo_2 // CHECK-EMPTY: // CHECK-NEXT: _llgo_4: ; preds = %_llgo_0 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr null, ptr %23, ptr @_llgo_int, %"{{.*}}/runtime/internal/runtime.String" zeroinitializer) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr null, ptr %23, ptr @_llgo_int) // CHECK-NEXT: unreachable // CHECK-NEXT: } diff --git a/cl/_testgo/closureall/in.go b/cl/_testgo/closureall/in.go index 3b4dafe116..5f2ca4304b 100644 --- a/cl/_testgo/closureall/in.go +++ b/cl/_testgo/closureall/in.go @@ -189,7 +189,7 @@ func makeWithFree(base int) Fn { // CHECK-NEXT: ret void // CHECK-EMPTY: // CHECK-NEXT: _llgo_2: ; preds = %_llgo_0 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr %21, ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", %"{{.*}}/runtime/internal/runtime.String" { ptr @7, i64 3 }) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr %21, ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}") // CHECK-NEXT: unreachable // CHECK-NEXT: } diff --git a/cl/_testgo/closureenv/in.go b/cl/_testgo/closureenv/in.go index 91c91bf34a..ddea666991 100644 --- a/cl/_testgo/closureenv/in.go +++ b/cl/_testgo/closureenv/in.go @@ -173,7 +173,7 @@ func main() { // CHECK-NEXT: br i1 %42, label %_llgo_10, label %_llgo_9 // CHECK-EMPTY: // CHECK-NEXT: _llgo_12: ; preds = %_llgo_8 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr %33, ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", %"{{.*}}/runtime/internal/runtime.String" { ptr @6, i64 5 }) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", ptr %33, ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}") // CHECK-NEXT: unreachable // CHECK-NEXT: } diff --git a/cl/_testgo/defer4/in.go b/cl/_testgo/defer4/in.go index 8b42b91f67..40c9b764dc 100644 --- a/cl/_testgo/defer4/in.go +++ b/cl/_testgo/defer4/in.go @@ -156,7 +156,7 @@ func main() { // CHECK-NEXT: br label %_llgo_2 // CHECK-EMPTY: // CHECK-NEXT: _llgo_4: ; preds = %_llgo_1 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr null, ptr %4, ptr @_llgo_string, %"{{.*}}/runtime/internal/runtime.String" zeroinitializer) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr null, ptr %4, ptr @_llgo_string) // CHECK-NEXT: unreachable // CHECK-NEXT: } diff --git a/cl/_testgo/genericembediface/in.go b/cl/_testgo/genericembediface/in.go index adffded214..2b32b36ed5 100644 --- a/cl/_testgo/genericembediface/in.go +++ b/cl/_testgo/genericembediface/in.go @@ -68,7 +68,7 @@ func main() { // CHECK-NEXT: ret %"{{.*}}/runtime/internal/runtime.iface" %21 // CHECK-EMPTY: // CHECK-NEXT: _llgo_2: ; preds = %_llgo_0 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr null, ptr %2, ptr @_llgo_main.ReflectionServer, %"{{.*}}/runtime/internal/runtime.String" { ptr @2, i64 20 }) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr null, ptr %2, ptr @_llgo_main.ReflectionServer) // CHECK-NEXT: unreachable // CHECK-NEXT: } diff --git a/cl/_testgo/ifaceprom/in.go b/cl/_testgo/ifaceprom/in.go index 329a065825..ab0f5d1c36 100644 --- a/cl/_testgo/ifaceprom/in.go +++ b/cl/_testgo/ifaceprom/in.go @@ -364,7 +364,7 @@ func main() { // CHECK-NEXT: br i1 %94, label %_llgo_5, label %_llgo_6 // CHECK-EMPTY: // CHECK-NEXT: _llgo_18: ; preds = %_llgo_4 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr @_llgo_main.I, ptr %36, ptr @_llgo_main.I, %"{{.*}}/runtime/internal/runtime.String" { ptr @2, i64 3 }) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr @_llgo_main.I, ptr %36, ptr @_llgo_main.I) // CHECK-NEXT: unreachable // CHECK-EMPTY: // CHECK-NEXT: _llgo_19: ; preds = %_llgo_6 @@ -380,7 +380,7 @@ func main() { // CHECK-NEXT: br i1 %101, label %_llgo_7, label %_llgo_8 // CHECK-EMPTY: // CHECK-NEXT: _llgo_20: ; preds = %_llgo_6 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr @_llgo_main.I, ptr %42, ptr @_llgo_main.I, %"{{.*}}/runtime/internal/runtime.String" { ptr @2, i64 3 }) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr @_llgo_main.I, ptr %42, ptr @_llgo_main.I) // CHECK-NEXT: unreachable // CHECK-EMPTY: // CHECK-NEXT: _llgo_21: ; preds = %_llgo_12 @@ -397,7 +397,7 @@ func main() { // CHECK-NEXT: br i1 %109, label %_llgo_13, label %_llgo_14 // CHECK-EMPTY: // CHECK-NEXT: _llgo_22: ; preds = %_llgo_12 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr @_llgo_main.I, ptr %78, ptr @_llgo_main.I, %"{{.*}}/runtime/internal/runtime.String" { ptr @2, i64 3 }) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr @_llgo_main.I, ptr %78, ptr @_llgo_main.I) // CHECK-NEXT: unreachable // CHECK-EMPTY: // CHECK-NEXT: _llgo_23: ; preds = %_llgo_14 @@ -414,7 +414,7 @@ func main() { // CHECK-NEXT: br i1 %117, label %_llgo_15, label %_llgo_16 // CHECK-EMPTY: // CHECK-NEXT: _llgo_24: ; preds = %_llgo_14 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr @_llgo_main.I, ptr %84, ptr @_llgo_main.I, %"{{.*}}/runtime/internal/runtime.String" { ptr @2, i64 3 }) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr @_llgo_main.I, ptr %84, ptr @_llgo_main.I) // CHECK-NEXT: unreachable // CHECK-NEXT: } diff --git a/cl/_testgo/invoke/in.go b/cl/_testgo/invoke/in.go index 51f6f3f8ad..5d770df322 100644 --- a/cl/_testgo/invoke/in.go +++ b/cl/_testgo/invoke/in.go @@ -443,7 +443,7 @@ type M interface { // CHECK-NEXT: br i1 %85, label %_llgo_3, label %_llgo_4 // CHECK-EMPTY: // CHECK-NEXT: _llgo_2: ; preds = %_llgo_0 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr null, ptr %78, ptr @_llgo_main.I, %"{{.*}}/runtime/internal/runtime.String" { ptr @2, i64 6 }) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr null, ptr %78, ptr @_llgo_main.I) // CHECK-NEXT: unreachable // CHECK-EMPTY: // CHECK-NEXT: _llgo_3: ; preds = %_llgo_1 @@ -452,7 +452,7 @@ type M interface { // CHECK-NEXT: br i1 %87, label %_llgo_5, label %_llgo_6 // CHECK-EMPTY: // CHECK-NEXT: _llgo_4: ; preds = %_llgo_1 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr null, ptr %84, ptr @_llgo_any, %"{{.*}}/runtime/internal/runtime.String" zeroinitializer) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr null, ptr %84, ptr @_llgo_any) // CHECK-NEXT: unreachable // CHECK-EMPTY: // CHECK-NEXT: _llgo_5: ; preds = %_llgo_3 @@ -464,7 +464,7 @@ type M interface { // CHECK-NEXT: ret void // CHECK-EMPTY: // CHECK-NEXT: _llgo_6: ; preds = %_llgo_3 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr null, ptr %86, ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}", %"{{.*}}/runtime/internal/runtime.String" { ptr @2, i64 6 }) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr null, ptr %86, ptr @"_llgo_iface${{[-A-Za-z0-9_]+}}") // CHECK-NEXT: unreachable // CHECK-NEXT: } diff --git a/cl/_testgo/reader/in.go b/cl/_testgo/reader/in.go index a997583739..253b34cbfc 100644 --- a/cl/_testgo/reader/in.go +++ b/cl/_testgo/reader/in.go @@ -697,7 +697,7 @@ func main() { // CHECK-NEXT: ret { i64, %"{{.*}}/runtime/internal/runtime.iface" } %23 // CHECK-EMPTY: // CHECK-NEXT: _llgo_2: ; preds = %_llgo_0 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr @_llgo_main.Reader, ptr %5, ptr @_llgo_main.WriterTo, %"{{.*}}/runtime/internal/runtime.String" { ptr @2, i64 7 }) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr @_llgo_main.Reader, ptr %5, ptr @_llgo_main.WriterTo) // CHECK-NEXT: unreachable // CHECK-NEXT: } diff --git a/cl/_testgo/reflect/in.go b/cl/_testgo/reflect/in.go index 9e4f24a569..1f5c414dd6 100644 --- a/cl/_testgo/reflect/in.go +++ b/cl/_testgo/reflect/in.go @@ -804,7 +804,7 @@ func mapDemo2() { // CHECK-NEXT: br label %_llgo_1 // CHECK-EMPTY: // CHECK-NEXT: _llgo_5: ; preds = %_llgo_2 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr null, ptr %22, ptr @_llgo_int, %"{{.*}}/runtime/internal/runtime.String" zeroinitializer) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr null, ptr %22, ptr @_llgo_int) // CHECK-NEXT: unreachable // CHECK-NEXT: } diff --git a/cl/_testgo/reflectconv/in.go b/cl/_testgo/reflectconv/in.go index 421699c5fd..16f210cd5d 100644 --- a/cl/_testgo/reflectconv/in.go +++ b/cl/_testgo/reflectconv/in.go @@ -1573,7 +1573,7 @@ func shouldPanic(expect string, f func()) { // CHECK-NEXT: br i1 %42, label %_llgo_3, label %_llgo_4 // CHECK-EMPTY: // CHECK-NEXT: _llgo_6: ; preds = %_llgo_2 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr null, ptr %27, ptr @_llgo_float32, %"{{.*}}/runtime/internal/runtime.String" zeroinitializer) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr null, ptr %27, ptr @_llgo_float32) // CHECK-NEXT: unreachable // CHECK-NEXT: } diff --git a/cl/_testgo/tpinst/main.go b/cl/_testgo/tpinst/main.go index 5b065182b7..258dc8cd93 100644 --- a/cl/_testgo/tpinst/main.go +++ b/cl/_testgo/tpinst/main.go @@ -2,7 +2,6 @@ package main // CHECK: {{^}}@8 = private unnamed_addr constant [5 x i8] c"error", align 1{{$}} -// CHECK: {{^}}@16 = private unnamed_addr constant [5 x i8] c"value", align 1{{$}} type M[T interface{}] struct { v T @@ -128,7 +127,7 @@ func (pt *M[T]) value() T { // CHECK-NEXT: br i1 %51, label %_llgo_5, label %_llgo_6 // CHECK-EMPTY: // CHECK-NEXT: _llgo_8: ; preds = %_llgo_4 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr @"_llgo_main.I[int]", ptr %34, ptr @"{{.*}}/cl/_testgo/tpinst.iface${{[-A-Za-z0-9_]+}}", %"{{.*}}/runtime/internal/runtime.String" { ptr @16, i64 5 }) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr @"_llgo_main.I[int]", ptr %34, ptr @"{{.*}}/cl/_testgo/tpinst.iface${{[-A-Za-z0-9_]+}}") // CHECK-NEXT: unreachable // CHECK-NEXT: } diff --git a/cl/_testlibc/defer/in.go b/cl/_testlibc/defer/in.go index b6279ee4f9..efebce573e 100644 --- a/cl/_testlibc/defer/in.go +++ b/cl/_testlibc/defer/in.go @@ -160,54 +160,60 @@ func main() { // CHECK-NEXT: store ptr %49, ptr %12, align 8 // CHECK-NEXT: %50 = extractvalue { ptr, i64, ptr } %48, 2 // CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.FreeDeferNode"(ptr %47) -// CHECK-NEXT: %51 = call i32 (ptr, ...) @printf(ptr %50) +// CHECK-NEXT: %51 = call %"{{.*}}/runtime/internal/runtime.recoverState" @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr @printf) +// CHECK-NEXT: %52 = call i32 (ptr, ...) @printf(ptr %50) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(%"{{.*}}/runtime/internal/runtime.recoverState" %51) // CHECK-NEXT: br label %_llgo_13 // CHECK-EMPTY: // CHECK-NEXT: _llgo_13: ; preds = %_llgo_12, %_llgo_6 // CHECK-NEXT: br label %_llgo_11 // CHECK-EMPTY: // CHECK-NEXT: _llgo_14: ; preds = %_llgo_11 -// CHECK-NEXT: %52 = load ptr, ptr %12, align 8 -// CHECK-NEXT: %53 = icmp ne ptr %52, null -// CHECK-NEXT: br i1 %53, label %_llgo_16, label %_llgo_17 +// CHECK-NEXT: %53 = load ptr, ptr %12, align 8 +// CHECK-NEXT: %54 = icmp ne ptr %53, null +// CHECK-NEXT: br i1 %54, label %_llgo_16, label %_llgo_17 // CHECK-EMPTY: // CHECK-NEXT: _llgo_15: ; preds = %_llgo_17, %_llgo_11 // CHECK-NEXT: br label %_llgo_10 // CHECK-EMPTY: // CHECK-NEXT: _llgo_16: ; preds = %_llgo_14 -// CHECK-NEXT: %54 = load ptr, ptr %12, align 8 -// CHECK-NEXT: %55 = load { ptr, i64, ptr }, ptr %54, align 8 -// CHECK-NEXT: %56 = extractvalue { ptr, i64, ptr } %55, 0 -// CHECK-NEXT: store ptr %56, ptr %12, align 8 -// CHECK-NEXT: %57 = extractvalue { ptr, i64, ptr } %55, 2 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.FreeDeferNode"(ptr %54) -// CHECK-NEXT: %58 = call i32 (ptr, ...) @printf(ptr %57) +// CHECK-NEXT: %55 = load ptr, ptr %12, align 8 +// CHECK-NEXT: %56 = load { ptr, i64, ptr }, ptr %55, align 8 +// CHECK-NEXT: %57 = extractvalue { ptr, i64, ptr } %56, 0 +// CHECK-NEXT: store ptr %57, ptr %12, align 8 +// CHECK-NEXT: %58 = extractvalue { ptr, i64, ptr } %56, 2 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.FreeDeferNode"(ptr %55) +// CHECK-NEXT: %59 = call %"{{.*}}/runtime/internal/runtime.recoverState" @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr @printf) +// CHECK-NEXT: %60 = call i32 (ptr, ...) @printf(ptr %58) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(%"{{.*}}/runtime/internal/runtime.recoverState" %59) // CHECK-NEXT: br label %_llgo_17 // CHECK-EMPTY: // CHECK-NEXT: _llgo_17: ; preds = %_llgo_16, %_llgo_14 // CHECK-NEXT: br label %_llgo_15 // CHECK-EMPTY: // CHECK-NEXT: _llgo_18: ; preds = %_llgo_10 -// CHECK-NEXT: %59 = load ptr, ptr %12, align 8 -// CHECK-NEXT: %60 = icmp ne ptr %59, null -// CHECK-NEXT: br i1 %60, label %_llgo_20, label %_llgo_21 +// CHECK-NEXT: %61 = load ptr, ptr %12, align 8 +// CHECK-NEXT: %62 = icmp ne ptr %61, null +// CHECK-NEXT: br i1 %62, label %_llgo_20, label %_llgo_21 // CHECK-EMPTY: // CHECK-NEXT: _llgo_19: ; preds = %_llgo_21, %_llgo_10 -// CHECK-NEXT: %61 = load %"{{.*}}/runtime/internal/runtime.Defer", ptr %4, align 8 -// CHECK-NEXT: %62 = extractvalue %"{{.*}}/runtime/internal/runtime.Defer" %61, 2 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.SetThreadDefer"(ptr %62) -// CHECK-NEXT: %63 = load ptr, ptr %11, align 8 -// CHECK-NEXT: indirectbr ptr %63, [label %_llgo_7, label %_llgo_9] +// CHECK-NEXT: %63 = load %"{{.*}}/runtime/internal/runtime.Defer", ptr %4, align 8 +// CHECK-NEXT: %64 = extractvalue %"{{.*}}/runtime/internal/runtime.Defer" %63, 2 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.SetThreadDefer"(ptr %64) +// CHECK-NEXT: %65 = load ptr, ptr %11, align 8 +// CHECK-NEXT: indirectbr ptr %65, [label %_llgo_7, label %_llgo_9] // CHECK-EMPTY: // CHECK-NEXT: _llgo_20: ; preds = %_llgo_18 -// CHECK-NEXT: %64 = load ptr, ptr %12, align 8 -// CHECK-NEXT: %65 = load { ptr, i64, ptr, ptr }, ptr %64, align 8 -// CHECK-NEXT: %66 = extractvalue { ptr, i64, ptr, ptr } %65, 0 -// CHECK-NEXT: store ptr %66, ptr %12, align 8 -// CHECK-NEXT: %67 = extractvalue { ptr, i64, ptr, ptr } %65, 2 -// CHECK-NEXT: %68 = extractvalue { ptr, i64, ptr, ptr } %65, 3 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.FreeDeferNode"(ptr %64) -// CHECK-NEXT: %69 = call i32 (ptr, ...) @printf(ptr %67, ptr %68) +// CHECK-NEXT: %66 = load ptr, ptr %12, align 8 +// CHECK-NEXT: %67 = load { ptr, i64, ptr, ptr }, ptr %66, align 8 +// CHECK-NEXT: %68 = extractvalue { ptr, i64, ptr, ptr } %67, 0 +// CHECK-NEXT: store ptr %68, ptr %12, align 8 +// CHECK-NEXT: %69 = extractvalue { ptr, i64, ptr, ptr } %67, 2 +// CHECK-NEXT: %70 = extractvalue { ptr, i64, ptr, ptr } %67, 3 +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.FreeDeferNode"(ptr %66) +// CHECK-NEXT: %71 = call %"{{.*}}/runtime/internal/runtime.recoverState" @"{{.*}}/runtime/internal/runtime.StartRecoverFrame"(ptr @printf) +// CHECK-NEXT: %72 = call i32 (ptr, ...) @printf(ptr %69, ptr %70) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.EndRecoverFrame"(%"{{.*}}/runtime/internal/runtime.recoverState" %71) // CHECK-NEXT: br label %_llgo_21 // CHECK-EMPTY: // CHECK-NEXT: _llgo_21: ; preds = %_llgo_20, %_llgo_18 diff --git a/cl/_testrt/any/in.go b/cl/_testrt/any/in.go index 370e0cea8a..3cbfc346ed 100644 --- a/cl/_testrt/any/in.go +++ b/cl/_testrt/any/in.go @@ -31,7 +31,7 @@ func main() { // CHECK-NEXT: ret ptr %3 // CHECK-EMPTY: // CHECK-NEXT: _llgo_2: ; preds = %_llgo_0 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr null, ptr %1, ptr @"*_llgo_int8", %"{{.*}}/runtime/internal/runtime.String" zeroinitializer) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr null, ptr %1, ptr @"*_llgo_int8") // CHECK-NEXT: unreachable // CHECK-NEXT: } @@ -48,7 +48,7 @@ func main() { // CHECK-NEXT: ret i64 %5 // CHECK-EMPTY: // CHECK-NEXT: _llgo_2: ; preds = %_llgo_0 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr null, ptr %1, ptr @_llgo_int, %"{{.*}}/runtime/internal/runtime.String" zeroinitializer) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr null, ptr %1, ptr @_llgo_int) // CHECK-NEXT: unreachable // CHECK-NEXT: } diff --git a/cl/_testrt/funcdecl/in.go b/cl/_testrt/funcdecl/in.go index 203301731e..5423e7c192 100644 --- a/cl/_testrt/funcdecl/in.go +++ b/cl/_testrt/funcdecl/in.go @@ -58,7 +58,7 @@ func main() { // CHECK-NEXT: br i1 %10, label %_llgo_3, label %_llgo_4 // CHECK-EMPTY: // CHECK-NEXT: _llgo_2: ; preds = %_llgo_0 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr null, ptr %5, ptr @"_llgo_closure$b7Su1hWaFih-M0M9hMk6nO_RD1K_GQu5WjIXQp6Q2e8", %"{{.*}}/runtime/internal/runtime.String" zeroinitializer) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr null, ptr %5, ptr @"_llgo_closure$b7Su1hWaFih-M0M9hMk6nO_RD1K_GQu5WjIXQp6Q2e8") // CHECK-NEXT: unreachable // CHECK-EMPTY: // CHECK-NEXT: _llgo_3: ; preds = %_llgo_1 @@ -87,7 +87,7 @@ func main() { // CHECK-NEXT: ret void // CHECK-EMPTY: // CHECK-NEXT: _llgo_4: ; preds = %_llgo_1 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr null, ptr %9, ptr @"_llgo_closure$b7Su1hWaFih-M0M9hMk6nO_RD1K_GQu5WjIXQp6Q2e8", %"{{.*}}/runtime/internal/runtime.String" zeroinitializer) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr null, ptr %9, ptr @"_llgo_closure$b7Su1hWaFih-M0M9hMk6nO_RD1K_GQu5WjIXQp6Q2e8") // CHECK-NEXT: unreachable // CHECK-NEXT: } diff --git a/cl/_testrt/makemap/in.go b/cl/_testrt/makemap/in.go index 8b901275fe..818ca16950 100644 --- a/cl/_testrt/makemap/in.go +++ b/cl/_testrt/makemap/in.go @@ -459,7 +459,7 @@ func make7() { // CHECK-NEXT: br label %_llgo_1 // CHECK-EMPTY: // CHECK-NEXT: _llgo_8: ; preds = %_llgo_2 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr null, ptr %39, ptr @_llgo_main.N1, %"{{.*}}/runtime/internal/runtime.String" zeroinitializer) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr null, ptr %39, ptr @_llgo_main.N1) // CHECK-NEXT: unreachable // CHECK-NEXT: } @@ -573,7 +573,7 @@ func make7() { // CHECK-NEXT: br label %_llgo_1 // CHECK-EMPTY: // CHECK-NEXT: _llgo_8: ; preds = %_llgo_2 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr null, ptr %39, ptr @_llgo_main.K, %"{{.*}}/runtime/internal/runtime.String" zeroinitializer) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr null, ptr %39, ptr @_llgo_main.K) // CHECK-NEXT: unreachable // CHECK-NEXT: } @@ -692,7 +692,7 @@ func make7() { // CHECK-NEXT: br label %_llgo_1 // CHECK-EMPTY: // CHECK-NEXT: _llgo_8: ; preds = %_llgo_2 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr null, ptr %43, ptr @_llgo_main.K2, %"{{.*}}/runtime/internal/runtime.String" zeroinitializer) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr null, ptr %43, ptr @_llgo_main.K2) // CHECK-NEXT: unreachable // CHECK-NEXT: } diff --git a/cl/_testrt/tpabi/in.go b/cl/_testrt/tpabi/in.go index f9c2f365d2..e73ff3f116 100644 --- a/cl/_testrt/tpabi/in.go +++ b/cl/_testrt/tpabi/in.go @@ -113,7 +113,7 @@ func main() { // CHECK-NEXT: ret void // CHECK-EMPTY: // CHECK-NEXT: _llgo_2: ; preds = %_llgo_0 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr null, ptr %6, ptr @"_llgo_main.T[string,int]", %"{{.*}}/runtime/internal/runtime.String" zeroinitializer) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr null, ptr %6, ptr @"_llgo_main.T[string,int]") // CHECK-NEXT: unreachable // CHECK-NEXT: } diff --git a/cl/_testrt/typed/in.go b/cl/_testrt/typed/in.go index a03b85c8be..8be3288183 100644 --- a/cl/_testrt/typed/in.go +++ b/cl/_testrt/typed/in.go @@ -49,7 +49,7 @@ func main() { // CHECK-NEXT: br i1 %7, label %_llgo_3, label %_llgo_4 // CHECK-EMPTY: // CHECK-NEXT: _llgo_2: ; preds = %_llgo_0 -// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr null, ptr %2, ptr @_llgo_main.T, %"{{.*}}/runtime/internal/runtime.String" zeroinitializer) +// CHECK-NEXT: call void @"{{.*}}/runtime/internal/runtime.PanicTypeAssert"(ptr null, ptr %2, ptr @_llgo_main.T) // CHECK-NEXT: unreachable // CHECK-EMPTY: // CHECK-NEXT: _llgo_3: ; preds = %_llgo_1 diff --git a/cl/caller_tracking_precompute_test.go b/cl/caller_tracking_precompute_test.go index f99428580b..419c46c88d 100644 --- a/cl/caller_tracking_precompute_test.go +++ b/cl/caller_tracking_precompute_test.go @@ -32,6 +32,8 @@ func TestCallerTrackingPrecomputeSupportsConcurrentReads(t *testing.T) { "example.com/dep", `package dep import "runtime" func Where() { runtime.Caller(0) } +func Recovering() any { return recover() } +func Plain() {} `, "example.com/root", `package root import "example.com/dep" @@ -45,6 +47,14 @@ func Logs() { dep.Where() } if !runtimeCallerFuncSet(tracking, root)[root.Func("Logs")] { t.Fatal("precomputed extended set lost cross-package caller") } + recovering := dep.Func("Recovering") + plain := dep.Func("Plain") + if needs, ok := tracking.recover.scopes[recovering]; !ok || !needs { + t.Fatal("precompute did not cache the dependency's recover scope") + } + if needs, ok := tracking.recover.scopes[plain]; !ok || needs { + t.Fatal("precompute did not cache the dependency's plain function") + } var wg sync.WaitGroup for range 32 { @@ -52,7 +62,9 @@ func Logs() { dep.Where() } go func() { defer wg.Done() if !runtimeCallerBaseSet(tracking, dep)[dep.Func("Where")] || - !runtimeCallerFuncSet(tracking, root)[root.Func("Logs")] { + !runtimeCallerFuncSet(tracking, root)[root.Func("Logs")] || + !tracking.recover.needsRecoverScope(recovering) || + tracking.recover.needsRecoverScope(plain) { t.Error("concurrent read lost precomputed caller tracking data") } }() diff --git a/cl/cgo_test.go b/cl/cgo_test.go index 289b68a809..921f4a4620 100644 --- a/cl/cgo_test.go +++ b/cl/cgo_test.go @@ -208,7 +208,8 @@ func findStaticCall(t *testing.T, fn *gossa.Function, name string) *gossa.Call { } func TestRecoverCallClassificationHelpers(t *testing.T) { - if functionUsesRecover(nil) { + ctx := &context{} + if ctx.functionUsesRecover(nil) { t.Fatal("nil function should not report recover use") } @@ -223,12 +224,10 @@ func plain() {} `) usesRecover := ssaPkg.Members["usesRecover"].(*gossa.Function) plain := ssaPkg.Members["plain"].(*gossa.Function) - ctx := &context{} - - if !functionUsesRecover(usesRecover) { + if !ctx.functionUsesRecover(usesRecover) { t.Fatal("usesRecover should report direct recover use") } - if functionUsesRecover(plain) { + if ctx.functionUsesRecover(plain) { t.Fatal("plain should not report recover use") } if !ctx.callMayRecover(usesRecover) { @@ -246,6 +245,9 @@ func plain() {} if !ctx.callMayRecover(nil) { t.Fatal("unknown call value should conservatively be recover-capable") } + if !ctx.callMayRecover(&gossa.Function{}) { + t.Fatal("bodyless function should conservatively be recover-capable") + } } func TestCgoCgocall_InitArgsFromParams(t *testing.T) { diff --git a/cl/compile.go b/cl/compile.go index 433f8eb4b9..ed0f24e3a4 100644 --- a/cl/compile.go +++ b/cl/compile.go @@ -207,6 +207,7 @@ type context struct { linkOnceFns map[*ssa.Function]none stackDefers map[*ssa.Function]bool anonDefers map[*ssa.Function]bool + recoverFacts *recoverFacts debugDIVars map[*types.Var]llssa.DIVar debugAllocVars map[*ssa.Alloc]*types.Var runtimeCallerFuncs map[*ssa.Function]bool @@ -659,16 +660,13 @@ func (p *context) compileFuncDecl(pkg llssa.Package, f *ssa.Function) (llssa.Fun noInlineDirective := hasNoInlineDirective(f) runtimeStackNoInline := needsRuntimeStackNoInline(pkgTypes, f) pcLineNoInline := p.needsPCLineNoInline(f) - usesRecover := functionUsesRecover(f) + usesRecover := p.functionUsesRecover(f) if disableInline || noInlineDirective || runtimeStackNoInline || pcLineNoInline || usesRecover { fn.Inline(llssa.NoInline) } if noInlineDirective || runtimeStackNoInline || pcLineNoInline || usesRecover { fn.DisableTailCalls() } - if functionMayRecover(f) { - fn.Expr = fn.Expr.MarkMayRecover() - } p.funcs[f] = fn isCgo := isCgoExternSymbol(f) if nblk := len(f.Blocks); nblk > 0 { @@ -951,7 +949,7 @@ func (p *context) compileBlock(b llssa.Builder, block *ssa.BasicBlock, n int, do var instrs = block.Instrs[n:] var ret = fn.Block(block.Index) b.SetBlock(ret) - if block.Index == 0 && functionUsesRecover(block.Parent()) { + if block.Index == 0 && p.functionUsesRecover(block.Parent()) { b.BindRecoverFrame() } if block.Index == 0 { @@ -1946,71 +1944,6 @@ func (p *context) getLocalVariable(b llssa.Builder, fn *ssa.Function, v *types.V return div } -func functionUsesRecover(fn *ssa.Function) bool { - if fn == nil { - return false - } - for _, block := range fn.Blocks { - for _, instr := range block.Instrs { - call, ok := instr.(ssa.CallInstruction) - if !ok { - continue - } - builtin, ok := call.Common().Value.(*ssa.Builtin) - if ok && builtin.Name() == "recover" { - return true - } - } - } - return false -} - -func isRecoverTransparentWrapper(fn *ssa.Function) bool { - if fn == nil { - return false - } - // These are the Go SSA forms of compiler-generated forwarding frames. - // Treating them as transparent mirrors the standard runtime's - // abi.FuncIDWrapper rule in gorecover. - return strings.HasPrefix(fn.Synthetic, "wrapper for ") || - strings.HasPrefix(fn.Synthetic, "thunk for ") || - strings.HasPrefix(fn.Synthetic, "bound method wrapper for ") -} - -func functionMayRecover(fn *ssa.Function) bool { - return functionMayRecoverSeen(fn, make(map[*ssa.Function]bool)) -} - -func functionMayRecoverSeen(fn *ssa.Function, seen map[*ssa.Function]bool) bool { - if fn == nil || seen[fn] { - return false - } - seen[fn] = true - if functionUsesRecover(fn) { - return true - } - if !isRecoverTransparentWrapper(fn) { - return false - } - for _, block := range fn.Blocks { - for _, instr := range block.Instrs { - call, ok := instr.(ssa.CallInstruction) - if !ok { - continue - } - common := call.Common() - if common.Method != nil { - // An interface wrapper can dispatch to a recover-capable method. - return true - } - if functionMayRecoverSeen(common.StaticCallee(), seen) { - return true - } - } - } - return false -} - func (p *context) compileFunction(v *ssa.Function) (goFn llssa.Function, pyFn llssa.PyObjRef, kind int) { // TODO(xsw) v.Pkg == nil: means auto generated function? if v.Pkg == p.goPkg || v.Pkg == nil { @@ -2384,6 +2317,7 @@ func newPackageEx(prog llssa.Program, ct *CallerTracking, patches Patches, rewri vargs: make(map[*ssa.Alloc][]llssa.Expr), funcs: make(map[*ssa.Function]llssa.Function), linkOnceFns: make(map[*ssa.Function]none), + recoverFacts: ct.recoverAnalysis(), addrOfFieldAddrs: collectAddrOfFieldSelectors(files), loaded: map[*types.Package]*pkgInfo{ types.Unsafe: {kind: PkgDeclOnly}, // TODO(xsw): PkgNoInit or PkgDeclOnly? diff --git a/cl/instr.go b/cl/instr.go index 24f8b11cc1..c649fe0ee2 100644 --- a/cl/instr.go +++ b/cl/instr.go @@ -973,27 +973,29 @@ func runtimeCallerFuncSet(c *CallerTracking, pkg *ssa.Package) map[*ssa.Function return out } -// CallerTracking memoizes the per-package caller-tracking sets for one -// compilation. Like Patches, it is compilation-scoped state owned by the -// driver: create one per compilation and pass it to every -// NewPackageExWithEmbed call of that compilation, so cross-package -// queries (criterion 2 below) hit the memoization. It must not outlive -// the compilation — the maps are keyed by *ssa.Package with -// *ssa.Function values, so anything longer-lived would pin every +// CallerTracking memoizes frontend analyses for one compilation. Like Patches, +// it is compilation-scoped state owned by the driver: create one per +// compilation and pass it to every NewPackageExWithEmbed call of that +// compilation, so cross-package queries hit the same caller-tracking and +// recover facts. It must not outlive the compilation — the caches are keyed by +// *ssa.Package and *ssa.Function, so anything longer-lived would pin every // compiled package's go/types and go/ssa graphs. Concurrent drivers call -// Precompute before workers start and then share the plain maps read-only. +// Precompute before workers start; recover facts also synchronize lazy queries +// for nested and synthetic functions that are not package members. type CallerTracking struct { base map[*ssa.Package]map[*ssa.Function]bool extended map[*ssa.Package]map[*ssa.Function]bool + recover *recoverFacts } -// Precompute resolves caller-tracking data before package backends start. -// Once it returns, callers may share c for concurrent read-only lookups as long -// as pkgs contains every package that can be passed to this compilation. +// Precompute resolves caller-tracking and recover data before package backends +// start. Once it returns, callers may share c for concurrent lookups as long as +// pkgs contains every package that can be passed to this compilation. func (c *CallerTracking) Precompute(pkgs []*ssa.Package) { if c == nil { return } + c.recoverAnalysis().precompute(pkgs) for _, pkg := range pkgs { if pkg != nil { runtimeCallerBaseSet(c, pkg) @@ -1006,12 +1008,12 @@ func (c *CallerTracking) Precompute(pkgs []*ssa.Package) { } } -// NewCallerTracking creates the caller-tracking memoization for one -// compilation. +// NewCallerTracking creates the frontend-analysis caches for one compilation. func NewCallerTracking() *CallerTracking { return &CallerTracking{ base: make(map[*ssa.Package]map[*ssa.Function]bool), extended: make(map[*ssa.Package]map[*ssa.Function]bool), + recover: newRecoverFacts(), } } @@ -1827,10 +1829,10 @@ func (p *context) callMayRecover(v ssa.Value) bool { case *ssa.Builtin: return false case *ssa.Function: - return functionMayRecover(v) + return p.needsRecoverScope(v) case *ssa.MakeClosure: if fn, ok := v.Fn.(*ssa.Function); ok { - return functionMayRecover(fn) + return p.needsRecoverScope(fn) } return true case *ssa.Call: diff --git a/cl/recover.go b/cl/recover.go new file mode 100644 index 0000000000..0c787dd541 --- /dev/null +++ b/cl/recover.go @@ -0,0 +1,213 @@ +/* + * Copyright (c) 2026 The XGo Authors (xgo.dev). All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package cl + +import ( + "strings" + "sync" + + "golang.org/x/tools/go/ssa" +) + +// recoverFacts caches recover classification for one LLGo compilation. The +// build driver constructs all dependency Go SSA before consulting its package +// archive cache, so these facts remain available when a dependency backend is +// skipped on a cache hit. Keeping them here also avoids encoding frontend +// semantics in LLVM function attributes, which do not describe closure values. +type recoverFacts struct { + mu sync.RWMutex + uses map[*ssa.Function]bool + scopes map[*ssa.Function]bool +} + +func newRecoverFacts() *recoverFacts { + return &recoverFacts{ + uses: make(map[*ssa.Function]bool), + scopes: make(map[*ssa.Function]bool), + } +} + +func (c *CallerTracking) recoverAnalysis() *recoverFacts { + if c.recover == nil { + c.recover = newRecoverFacts() + } + return c.recover +} + +func (p *context) recoverAnalysis() *recoverFacts { + if p.recoverFacts == nil { + p.recoverFacts = newRecoverFacts() + } + return p.recoverFacts +} + +func (r *recoverFacts) precompute(pkgs []*ssa.Package) { + r.mu.Lock() + defer r.mu.Unlock() + for _, pkg := range pkgs { + if pkg == nil { + continue + } + for _, member := range pkg.Members { + if fn, ok := member.(*ssa.Function); ok { + r.needsRecoverScopeLocked(fn) + } + } + } +} + +func (p *context) functionUsesRecover(fn *ssa.Function) bool { + return p.recoverAnalysis().functionUsesRecover(fn) +} + +func (r *recoverFacts) functionUsesRecover(fn *ssa.Function) bool { + if fn == nil { + return false + } + r.mu.RLock() + uses, ok := r.uses[fn] + r.mu.RUnlock() + if ok { + return uses + } + r.mu.Lock() + defer r.mu.Unlock() + return r.functionUsesRecoverLocked(fn) +} + +func (r *recoverFacts) functionUsesRecoverLocked(fn *ssa.Function) bool { + if fn == nil { + return false + } + if uses, ok := r.uses[fn]; ok { + return uses + } + uses := false + for _, block := range fn.Blocks { + for _, instr := range block.Instrs { + call, ok := instr.(ssa.CallInstruction) + if !ok { + continue + } + builtin, ok := call.Common().Value.(*ssa.Builtin) + if ok && builtin.Name() == "recover" { + uses = true + break + } + } + if uses { + break + } + } + r.uses[fn] = uses + return uses +} + +func (p *context) needsRecoverScope(fn *ssa.Function) bool { + return p.recoverAnalysis().needsRecoverScope(fn) +} + +func (r *recoverFacts) needsRecoverScope(fn *ssa.Function) bool { + if fn == nil { + return false + } + r.mu.RLock() + needs, ok := r.scopes[fn] + r.mu.RUnlock() + if ok { + return needs + } + r.mu.Lock() + defer r.mu.Unlock() + return r.needsRecoverScopeLocked(fn) +} + +func (r *recoverFacts) needsRecoverScopeLocked(fn *ssa.Function) bool { + if fn == nil { + return false + } + if needs, ok := r.scopes[fn]; ok { + return needs + } + + seen := make(map[*ssa.Function]bool) + work := []*ssa.Function{fn} + for len(work) > 0 { + last := len(work) - 1 + current := work[last] + work = work[:last] + if current == nil || seen[current] { + continue + } + if needs, ok := r.scopes[current]; ok { + if needs { + r.scopes[fn] = true + return true + } + continue + } + seen[current] = true + if r.functionUsesRecoverLocked(current) { + r.scopes[fn] = true + return true + } + if len(current.Blocks) == 0 { + // Source-backed builds normally have every dependency body even + // when its archive is cached. Be conservative for declarations from + // isolated/allow-no-body compilation modes. + r.scopes[fn] = true + return true + } + if !isRecoverTransparentWrapper(current) { + continue + } + for _, block := range current.Blocks { + for _, instr := range block.Instrs { + call, ok := instr.(ssa.CallInstruction) + if !ok { + continue + } + common := call.Common() + if common.Method != nil { + // An interface wrapper can dispatch to a recover-capable method. + r.scopes[fn] = true + return true + } + work = append(work, common.StaticCallee()) + } + } + } + + // A fully explored negative graph is safe to cache for every visited + // function, including cycles of synthetic wrappers. + for current := range seen { + r.scopes[current] = false + } + return false +} + +func isRecoverTransparentWrapper(fn *ssa.Function) bool { + if fn == nil { + return false + } + // These are the Go SSA forms of compiler-generated forwarding frames. + // Treating them as transparent mirrors the standard runtime's + // abi.FuncIDWrapper rule in gorecover. + return strings.HasPrefix(fn.Synthetic, "wrapper for ") || + strings.HasPrefix(fn.Synthetic, "thunk for ") || + strings.HasPrefix(fn.Synthetic, "bound method wrapper for ") +} diff --git a/runtime/internal/runtime/errors.go b/runtime/internal/runtime/errors.go index 90e5267dd1..370e4faecb 100644 --- a/runtime/internal/runtime/errors.go +++ b/runtime/internal/runtime/errors.go @@ -164,7 +164,11 @@ type TypeAssertionError struct { func (*TypeAssertionError) RuntimeError() {} -func PanicTypeAssert(source, concrete, asserted *_type, missingMethod string) { +func PanicTypeAssert(source, concrete, asserted *_type) { + missingMethod := "" + if concrete != nil { + missingMethod = missingInterfaceMethod(asserted, concrete) + } panic(&TypeAssertionError{ _interface: source, concrete: concrete, diff --git a/runtime/internal/runtime/z_baremetal.go b/runtime/internal/runtime/z_baremetal.go index 5fe5d37d27..b98990d802 100644 --- a/runtime/internal/runtime/z_baremetal.go +++ b/runtime/internal/runtime/z_baremetal.go @@ -21,6 +21,9 @@ func Rethrow(link *Defer) { return } if link == nil { + // Bare-metal has one execution context and no goroutine-exit + // transition. Goexit still drains every defer through the longjmp + // path, then retains the backend's existing fatal termination here. c.Printf(c.Str("fatal error\n")) c.Exit(2) } else { diff --git a/runtime/internal/runtime/z_face.go b/runtime/internal/runtime/z_face.go index a578529db7..47856f6d42 100644 --- a/runtime/internal/runtime/z_face.go +++ b/runtime/internal/runtime/z_face.go @@ -258,18 +258,17 @@ func identicalFuncType(T, V *abi.Type) bool { return true } -// Implements reports whether the type V implements the interface type T. -func Implements(T, V *abi.Type) bool { - if V == nil { - return false - } - if T.Kind() != abi.Interface { - return false +func missingInterfaceMethod(T, V *abi.Type) string { + if T == nil || T.Kind() != abi.Interface { + return "" } t := (*abi.InterfaceType)(unsafe.Pointer(T)) if len(t.Methods) == 0 { - return true + return "" + } + if V == nil { + return t.Methods[0].Name() } // The same algorithm applies in both cases, but the @@ -292,16 +291,16 @@ func Implements(T, V *abi.Type) bool { vm := &v.Methods[j] if vm.Name_ == tm.Name_ && vm.Typ_ == tm.Typ_ { if i++; i >= len(t.Methods) { - return true + return "" } } } - return false + return t.Methods[i].Name() } v := V.Uncommon() if v == nil { - return false + return t.Methods[0].Name() } i := 0 vmethods := v.Methods() @@ -310,11 +309,16 @@ func Implements(T, V *abi.Type) bool { vm := vmethods[j] if vm.Name_ == tm.Name_ && vm.Mtyp_ == tm.Typ_ { if i++; i >= len(t.Methods) { - return true + return "" } } } - return false + return t.Methods[i].Name() +} + +// Implements reports whether the type V implements the interface type T. +func Implements(T, V *abi.Type) bool { + return T != nil && V != nil && T.Kind() == abi.Interface && missingInterfaceMethod(T, V) == "" } func EfaceEqual(v, u eface) bool { @@ -401,7 +405,11 @@ func getitab(inter *interfacetype, typ *_type, canfail bool) *itab { if canfail { return nil } - panic(&TypeAssertionError{concrete: typ, asserted: &inter.Type, missingMethod: ""}) + panic(&TypeAssertionError{ + concrete: typ, + asserted: &inter.Type, + missingMethod: missingInterfaceMethod(&inter.Type, typ), + }) } // ----------------------------------------------------------------------------- diff --git a/ssa/eh.go b/ssa/eh.go index 7e386e1a0f..0435edc7f1 100644 --- a/ssa/eh.go +++ b/ssa/eh.go @@ -639,9 +639,10 @@ func deferMayRecover(fn Expr) bool { return false } switch fn.kind { - case vkClosure, vkFuncDecl: - return fn.mayRecover() - case vkIfaceMethod, vkFuncPtr: + case vkClosure, vkFuncDecl, vkIfaceMethod, vkFuncPtr: + // The lower-level Builder API has no Go SSA or compilation-wide + // analysis cache. Conservatively scope every callable value; the Go + // frontend uses DeferRecover/DeferToRecover with its precise result. return true } return false diff --git a/ssa/expr.go b/ssa/expr.go index 97d91cd852..dc7c5b5f19 100644 --- a/ssa/expr.go +++ b/ssa/expr.go @@ -48,8 +48,6 @@ type Expr struct { var Nil Expr // Zero value is a nil Expr -const mayRecoverAttr = "llgo.may-recover" - // IsNil checks if the expression is nil or not. func (v Expr) IsNil() bool { return v.Type == nil @@ -67,27 +65,6 @@ func (v Expr) SetVolatile(volatile bool) Expr { return v } -// MarkMayRecover marks a function or closure that may call recover directly. -func (v Expr) MarkMayRecover() Expr { - if v.Type == nil || v.impl.IsNil() { - return v - } - fn := v.impl.IsAFunction() - if !fn.IsNil() && fn.GetStringAttributeAtIndex(-1, mayRecoverAttr).IsNil() { - ctx := fn.GlobalParent().Context() - fn.AddFunctionAttr(ctx.CreateStringAttribute(mayRecoverAttr, "true")) - } - return v -} - -func (v Expr) mayRecover() bool { - if v.Type == nil || v.impl.IsNil() { - return false - } - fn := v.impl.IsAFunction() - return !fn.IsNil() && !fn.GetStringAttributeAtIndex(-1, mayRecoverAttr).IsNil() -} - func (v Expr) SetName(alias string) Expr { v.impl.SetName(alias) return v diff --git a/ssa/interface.go b/ssa/interface.go index c2cf57ad0d..c62e789797 100644 --- a/ssa/interface.go +++ b/ssa/interface.go @@ -394,20 +394,13 @@ func (b Builder) TypeAssert(x Expr, assertedTyp Type, commaOk bool) Expr { } else { source = b.Prog.Nil(b.Prog.AbiTypePtr()) } - b.Call(b.Pkg.rtFunc("PanicTypeAssert"), source, tx, tabi, b.Str(typeAssertMissingMethod(assertedTyp))) + b.Call(b.Pkg.rtFunc("PanicTypeAssert"), source, tx, tabi) b.Unreachable() b.SetBlockEx(blks[0], AtEnd, false) b.blk.last = blks[0].last return val() } -func typeAssertMissingMethod(assertedTyp Type) string { - if rawIntf, ok := assertedTyp.RawType().Underlying().(*types.Interface); ok && rawIntf.NumMethods() > 0 { - return rawIntf.Method(0).Name() - } - return "" -} - // ChangeInterface constructs a value of one interface type from a // value of another interface type known to be assignable to it. // This operation cannot fail. diff --git a/ssa/recover_metadata_test.go b/ssa/recover_metadata_test.go index a744765e44..91381126a1 100644 --- a/ssa/recover_metadata_test.go +++ b/ssa/recover_metadata_test.go @@ -4,41 +4,10 @@ package ssa import ( "go/types" + "strings" "testing" ) -func TestRecoverMetadataHandlesNonFunctions(t *testing.T) { - prog := NewProgram(nil) - values := []Expr{ - Nil, - {Type: prog.Int()}, - prog.Val(1), - } - for i, value := range values { - if got := value.MarkMayRecover(); got.Type != value.Type { - t.Fatalf("value %d: MarkMayRecover changed the expression type", i) - } - if value.mayRecover() { - t.Fatalf("value %d: non-function marked as recover-capable", i) - } - } - - pkg := prog.NewPackage("p", "example.com/p") - fn := pkg.NewFunc("recovering", NoArgsNoRet, InGo) - if fn.Expr.mayRecover() { - t.Fatal("new function unexpectedly marked as recover-capable") - } - fn.Expr.MarkMayRecover() - if !fn.Expr.mayRecover() { - t.Fatal("marked function is not recover-capable") - } - // Marking a function twice must preserve the existing attribute. - fn.Expr.MarkMayRecover() - if !fn.Expr.mayRecover() { - t.Fatal("re-marked function lost recover capability") - } -} - func TestRecoverDeferClassificationFallbacks(t *testing.T) { prog := NewProgram(nil) pkg := prog.NewPackage("p", "example.com/p") @@ -47,6 +16,7 @@ func TestRecoverDeferClassificationFallbacks(t *testing.T) { b := caller.MakeBody(1) fnPtr := b.ChangeType(prog.rawType(NoArgsNoRet), callee.Expr) + closure := b.MakeClosure(callee.Expr, nil) ifaceMethod := Expr{Type: &aType{kind: vkIfaceMethod}} ordinary := prog.Val(1) @@ -57,7 +27,8 @@ func TestRecoverDeferClassificationFallbacks(t *testing.T) { }{ {name: "nil", fn: Nil, want: false}, {name: "ordinary", fn: ordinary, want: false}, - {name: "function declaration", fn: callee.Expr, want: false}, + {name: "function declaration", fn: callee.Expr, want: true}, + {name: "closure", fn: closure, want: true}, {name: "function pointer", fn: fnPtr, want: true}, {name: "interface method", fn: ifaceMethod, want: true}, } { @@ -68,10 +39,6 @@ func TestRecoverDeferClassificationFallbacks(t *testing.T) { }) } - callee.Expr.MarkMayRecover() - if !deferMayRecover(callee.Expr) { - t.Fatal("marked function declaration is not recover-capable") - } if token := b.recoverDeferToken(fnPtr, false); token.IsNil() { t.Fatal("function pointer did not produce a recover token") } @@ -96,3 +63,33 @@ func TestRecoverDeferClassificationFallbacks(t *testing.T) { b.Return() b.EndBuild() } + +func TestDefaultDeferConservativelyScopesRecoveringClosure(t *testing.T) { + prog := NewProgram(nil) + setTestRuntime(t, prog) + pkg := prog.NewPackage("p", "example.com/p") + + callee := pkg.NewFunc("recovering", NoArgsNoRet, InGo) + cb := callee.MakeBody(1) + cb.BindRecoverFrame() + _ = cb.Recover() + cb.Return() + cb.EndBuild() + + caller := pkg.NewFunc("caller", NoArgsNoRet, InGo) + b := caller.MakeBody(1) + caller.SetRecover(caller.MakeBlock()) + closure := b.MakeClosure(callee.Expr, nil) + b.Defer(DeferAlways, closure, Builder.Call) + b.RunDefers() + b.Return() + b.EndBuild() + + ir := pkg.String() + if !strings.Contains(ir, "StartRecoverFrame") { + t.Fatalf("default closure defer did not open a recover scope:\n%s", ir) + } + if strings.Contains(ir, "llgo.may-recover") { + t.Fatalf("recover classification leaked into an LLVM attribute:\n%s", ir) + } +} diff --git a/test/buildcache/dep1/dep1.go b/test/buildcache/dep1/dep1.go index 7c6ea1c9ff..9df0ee1472 100644 --- a/test/buildcache/dep1/dep1.go +++ b/test/buildcache/dep1/dep1.go @@ -12,3 +12,8 @@ func Add(a, b int) int { func Msg() string { return "dep1" } + +// Recover stores the panic value seen by a directly deferred dependency call. +func Recover(dst *any) { + *dst = recover() +} diff --git a/test/buildcache/main.go b/test/buildcache/main.go index 3863a7f71d..b870265d59 100644 --- a/test/buildcache/main.go +++ b/test/buildcache/main.go @@ -12,6 +12,15 @@ import ( ) func main() { + var recovered any + func() { + defer dep1.Recover(&recovered) + panic("cached recover") + }() + if recovered != "cached recover" { + panic("dependency recover failed after cache lookup") + } + c.Printf(c.Str("dep1.Add(1,2) = %d\n"), dep1.Add(1, 2)) c.Printf(c.Str("dep2.Double(1,2) = %d\n"), dep2.Double(1, 2)) c.Printf(c.Str("dep3.Triple(1,2) = %d\n"), dep3.Triple(1, 2)) diff --git a/test/go/recover_defer_fixedbugs_test.go b/test/go/recover_defer_fixedbugs_test.go index 9b193e4258..002d36fa58 100644 --- a/test/go/recover_defer_fixedbugs_test.go +++ b/test/go/recover_defer_fixedbugs_test.go @@ -6,8 +6,21 @@ import ( "strings" "testing" "time" + + "github.com/goplus/llgo/test/go/recoverpkg" ) +func TestRecoverCrossPackageDeferredFunction(t *testing.T) { + var recovered any + func() { + defer recoverpkg.Store(&recovered) + panic("cross-package") + }() + if recovered != "cross-package" { + t.Fatalf("cross-package recover = %v, want cross-package", recovered) + } +} + type fixedbug4066Panic struct{} func fixedbug4066NamedReturn() (val int) { diff --git a/test/go/recoverpkg/recover.go b/test/go/recoverpkg/recover.go new file mode 100644 index 0000000000..94a525856a --- /dev/null +++ b/test/go/recoverpkg/recover.go @@ -0,0 +1,6 @@ +package recoverpkg + +// Store records a panic recovered by this directly deferred cross-package call. +func Store(dst *any) { + *dst = recover() +} diff --git a/test/go/runtime_error_recover_test.go b/test/go/runtime_error_recover_test.go index 546deee367..03307101ce 100644 --- a/test/go/runtime_error_recover_test.go +++ b/test/go/runtime_error_recover_test.go @@ -20,6 +20,7 @@ func TestRecoverRuntimeErrorClassification(t *testing.T) { arrayPtr := new([10]int) var slice []int var iface any = 1 + var partialInterface any = runtimeErrorFirstMethodOnly{} tests := []struct { name string @@ -89,6 +90,13 @@ func TestRecoverRuntimeErrorClassification(t *testing.T) { runtimeErrorAnySink = iface.(runtimeErrorMissingMethod) }, }, + { + name: "type-interface-second-method", + want: "missing method runtimeErrorMethodB", + f: func() { + runtimeErrorAnySink = partialInterface.(runtimeErrorTwoMethods) + }, + }, } for _, tt := range tests { @@ -119,3 +127,12 @@ func expectRecoverRuntimeError(t *testing.T, want string, f func()) { type runtimeErrorMissingMethod interface { runtimeErrorMissingMethod() } + +type runtimeErrorTwoMethods interface { + runtimeErrorMethodA() + runtimeErrorMethodB() +} + +type runtimeErrorFirstMethodOnly struct{} + +func (runtimeErrorFirstMethodOnly) runtimeErrorMethodA() {} From 54da2a1747662905fe76dbf0db142e8a1d67ee83 Mon Sep 17 00:00:00 2001 From: Li Jie Date: Tue, 11 Aug 2026 09:36:02 +0800 Subject: [PATCH 20/21] test/buildcache: run recover check on native iwasm does not provide the setjmp/longjmp imports used by LLGo defer. Keep the WASM fixture free of that defer path, and execute native artifacts after every cache scenario so dependency archive hits still validate cross-package recover. --- test/buildcache/dep1/dep1.go | 5 ----- test/buildcache/dep1/recover.go | 8 ++++++++ test/buildcache/main.go | 9 +-------- test/buildcache/recover.go | 16 ++++++++++++++++ test/buildcache/recover_wasip1.go | 8 ++++++++ test/buildcache/test.sh | 5 ++++- 6 files changed, 37 insertions(+), 14 deletions(-) create mode 100644 test/buildcache/dep1/recover.go create mode 100644 test/buildcache/recover.go create mode 100644 test/buildcache/recover_wasip1.go diff --git a/test/buildcache/dep1/dep1.go b/test/buildcache/dep1/dep1.go index 9df0ee1472..7c6ea1c9ff 100644 --- a/test/buildcache/dep1/dep1.go +++ b/test/buildcache/dep1/dep1.go @@ -12,8 +12,3 @@ func Add(a, b int) int { func Msg() string { return "dep1" } - -// Recover stores the panic value seen by a directly deferred dependency call. -func Recover(dst *any) { - *dst = recover() -} diff --git a/test/buildcache/dep1/recover.go b/test/buildcache/dep1/recover.go new file mode 100644 index 0000000000..8a7dd3cbea --- /dev/null +++ b/test/buildcache/dep1/recover.go @@ -0,0 +1,8 @@ +//go:build llgo && !wasip1 + +package dep1 + +// Recover stores the panic value seen by a directly deferred dependency call. +func Recover(dst *any) { + *dst = recover() +} diff --git a/test/buildcache/main.go b/test/buildcache/main.go index b870265d59..719373bcba 100644 --- a/test/buildcache/main.go +++ b/test/buildcache/main.go @@ -12,14 +12,7 @@ import ( ) func main() { - var recovered any - func() { - defer dep1.Recover(&recovered) - panic("cached recover") - }() - if recovered != "cached recover" { - panic("dependency recover failed after cache lookup") - } + verifyRecoverCache() c.Printf(c.Str("dep1.Add(1,2) = %d\n"), dep1.Add(1, 2)) c.Printf(c.Str("dep2.Double(1,2) = %d\n"), dep2.Double(1, 2)) diff --git a/test/buildcache/recover.go b/test/buildcache/recover.go new file mode 100644 index 0000000000..66e99aff27 --- /dev/null +++ b/test/buildcache/recover.go @@ -0,0 +1,16 @@ +//go:build llgo && !wasip1 + +package main + +import "github.com/goplus/llgo/test/buildcache/dep1" + +func verifyRecoverCache() { + var recovered any + func() { + defer dep1.Recover(&recovered) + panic("cached recover") + }() + if recovered != "cached recover" { + panic("dependency recover failed after cache lookup") + } +} diff --git a/test/buildcache/recover_wasip1.go b/test/buildcache/recover_wasip1.go new file mode 100644 index 0000000000..73d4baf00e --- /dev/null +++ b/test/buildcache/recover_wasip1.go @@ -0,0 +1,8 @@ +//go:build llgo && wasip1 + +package main + +// The build-cache WASM suite runs under iwasm, which does not provide the +// setjmp/longjmp imports needed by LLGo's defer implementation. Native cache +// runs exercise the cross-package recover path instead. +func verifyRecoverCache() {} diff --git a/test/buildcache/test.sh b/test/buildcache/test.sh index 9fd141f304..47cbb3ffd7 100755 --- a/test/buildcache/test.sh +++ b/test/buildcache/test.sh @@ -282,7 +282,10 @@ echo "Snapshots directory: $SNAPSHOTS_DIR" echo "Build temp directory: $BUILD_TEMP_DIR" # Run native tests -run_test_suite "native" "llgo build -o $BUILD_TEMP_DIR/buildcache.out -compiler-verbose ." "" +run_test_suite "native" \ + "llgo build -o $BUILD_TEMP_DIR/buildcache.out -compiler-verbose ." \ + "" \ + "$BUILD_TEMP_DIR/buildcache.out" # Run WASM tests - always use iwasm from llgo cache directory # Determine cache directory based on platform From c952ad8a1b1d5730ed2468e958b5085c4dae7b20 Mon Sep 17 00:00:00 2001 From: Li Jie Date: Tue, 11 Aug 2026 10:45:50 +0800 Subject: [PATCH 21/21] runtime: make interface implementation result explicit Return the first missing interface method separately from the implementation boolean. This removes the empty-string sentinel from Implements and only resolves the method name on type-assertion error paths. --- runtime/internal/runtime/errors.go | 4 +++- runtime/internal/runtime/z_face.go | 34 ++++++++++++++++++------------ 2 files changed, 23 insertions(+), 15 deletions(-) diff --git a/runtime/internal/runtime/errors.go b/runtime/internal/runtime/errors.go index 370e4faecb..cb7d5fd686 100644 --- a/runtime/internal/runtime/errors.go +++ b/runtime/internal/runtime/errors.go @@ -167,7 +167,9 @@ func (*TypeAssertionError) RuntimeError() {} func PanicTypeAssert(source, concrete, asserted *_type) { missingMethod := "" if concrete != nil { - missingMethod = missingInterfaceMethod(asserted, concrete) + if missing, _ := interfaceImplementation(asserted, concrete); missing != nil { + missingMethod = missing.Name() + } } panic(&TypeAssertionError{ _interface: source, diff --git a/runtime/internal/runtime/z_face.go b/runtime/internal/runtime/z_face.go index 47856f6d42..6d888cf688 100644 --- a/runtime/internal/runtime/z_face.go +++ b/runtime/internal/runtime/z_face.go @@ -258,17 +258,17 @@ func identicalFuncType(T, V *abi.Type) bool { return true } -func missingInterfaceMethod(T, V *abi.Type) string { - if T == nil || T.Kind() != abi.Interface { - return "" +// interfaceImplementation reports whether V implements the interface T. On +// failure, missing is the first unmatched method in T's sorted method table, +// when such a method exists. +func interfaceImplementation(T, V *abi.Type) (missing *abi.Imethod, ok bool) { + if T == nil || V == nil || T.Kind() != abi.Interface { + return nil, false } t := (*abi.InterfaceType)(unsafe.Pointer(T)) if len(t.Methods) == 0 { - return "" - } - if V == nil { - return t.Methods[0].Name() + return nil, true } // The same algorithm applies in both cases, but the @@ -291,16 +291,16 @@ func missingInterfaceMethod(T, V *abi.Type) string { vm := &v.Methods[j] if vm.Name_ == tm.Name_ && vm.Typ_ == tm.Typ_ { if i++; i >= len(t.Methods) { - return "" + return nil, true } } } - return t.Methods[i].Name() + return &t.Methods[i], false } v := V.Uncommon() if v == nil { - return t.Methods[0].Name() + return &t.Methods[0], false } i := 0 vmethods := v.Methods() @@ -309,16 +309,17 @@ func missingInterfaceMethod(T, V *abi.Type) string { vm := vmethods[j] if vm.Name_ == tm.Name_ && vm.Mtyp_ == tm.Typ_ { if i++; i >= len(t.Methods) { - return "" + return nil, true } } } - return t.Methods[i].Name() + return &t.Methods[i], false } // Implements reports whether the type V implements the interface type T. func Implements(T, V *abi.Type) bool { - return T != nil && V != nil && T.Kind() == abi.Interface && missingInterfaceMethod(T, V) == "" + _, ok := interfaceImplementation(T, V) + return ok } func EfaceEqual(v, u eface) bool { @@ -405,10 +406,15 @@ func getitab(inter *interfacetype, typ *_type, canfail bool) *itab { if canfail { return nil } + missing, _ := interfaceImplementation(&inter.Type, typ) + missingMethod := "" + if missing != nil { + missingMethod = missing.Name() + } panic(&TypeAssertionError{ concrete: typ, asserted: &inter.Type, - missingMethod: missingInterfaceMethod(&inter.Type, typ), + missingMethod: missingMethod, }) }