mirror of
https://github.com/golang/go.git
synced 2025-10-19 11:03:18 +00:00
cmd/compile: move loong64 over to new bounds check strategy
Change-Id: I5dec33d10d16a5d5c0dc7231cd1f764a6d1d7598 Reviewed-on: https://go-review.googlesource.com/c/go/+/682399 LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com> Reviewed-by: abner chenc <chenguoqi@loongson.cn> Reviewed-by: Keith Randall <khr@google.com> Reviewed-by: Michael Knyszek <mknyszek@google.com> Reviewed-by: sophie zhao <zhaoxiaolin@loongson.cn>
This commit is contained in:
Keith Randall
parent
89a0af86b8
commit
5216fd570e
6 changed files with 236 additions and 161 deletions
|
|
@ -16,6 +16,7 @@ import (
|
|||
"cmd/compile/internal/types"
|
||||
"cmd/internal/obj"
|
||||
"cmd/internal/obj/loong64"
|
||||
"internal/abi"
|
||||
)
|
||||
|
||||
// isFPreg reports whether r is an FP register.
|
||||
|
|
@ -663,12 +664,92 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
|
|||
p.From.Type = obj.TYPE_CONST
|
||||
p.From.Offset = 0x1A
|
||||
|
||||
case ssa.OpLOONG64LoweredPanicBoundsA, ssa.OpLOONG64LoweredPanicBoundsB, ssa.OpLOONG64LoweredPanicBoundsC:
|
||||
p := s.Prog(obj.ACALL)
|
||||
case ssa.OpLOONG64LoweredPanicBoundsRR, ssa.OpLOONG64LoweredPanicBoundsRC, ssa.OpLOONG64LoweredPanicBoundsCR, ssa.OpLOONG64LoweredPanicBoundsCC:
|
||||
// Compute the constant we put in the PCData entry for this call.
|
||||
code, signed := ssa.BoundsKind(v.AuxInt).Code()
|
||||
xIsReg := false
|
||||
yIsReg := false
|
||||
xVal := 0
|
||||
yVal := 0
|
||||
switch v.Op {
|
||||
case ssa.OpLOONG64LoweredPanicBoundsRR:
|
||||
xIsReg = true
|
||||
xVal = int(v.Args[0].Reg() - loong64.REG_R4)
|
||||
yIsReg = true
|
||||
yVal = int(v.Args[1].Reg() - loong64.REG_R4)
|
||||
case ssa.OpLOONG64LoweredPanicBoundsRC:
|
||||
xIsReg = true
|
||||
xVal = int(v.Args[0].Reg() - loong64.REG_R4)
|
||||
c := v.Aux.(ssa.PanicBoundsC).C
|
||||
if c >= 0 && c <= abi.BoundsMaxConst {
|
||||
yVal = int(c)
|
||||
} else {
|
||||
// Move constant to a register
|
||||
yIsReg = true
|
||||
if yVal == xVal {
|
||||
yVal = 1
|
||||
}
|
||||
p := s.Prog(loong64.AMOVV)
|
||||
p.From.Type = obj.TYPE_CONST
|
||||
p.From.Offset = c
|
||||
p.To.Type = obj.TYPE_REG
|
||||
p.To.Reg = loong64.REG_R4 + int16(yVal)
|
||||
}
|
||||
case ssa.OpLOONG64LoweredPanicBoundsCR:
|
||||
yIsReg = true
|
||||
yVal := int(v.Args[0].Reg() - loong64.REG_R4)
|
||||
c := v.Aux.(ssa.PanicBoundsC).C
|
||||
if c >= 0 && c <= abi.BoundsMaxConst {
|
||||
xVal = int(c)
|
||||
} else {
|
||||
// Move constant to a register
|
||||
xIsReg = true
|
||||
if xVal == yVal {
|
||||
xVal = 1
|
||||
}
|
||||
p := s.Prog(loong64.AMOVV)
|
||||
p.From.Type = obj.TYPE_CONST
|
||||
p.From.Offset = c
|
||||
p.To.Type = obj.TYPE_REG
|
||||
p.To.Reg = loong64.REG_R4 + int16(xVal)
|
||||
}
|
||||
case ssa.OpLOONG64LoweredPanicBoundsCC:
|
||||
c := v.Aux.(ssa.PanicBoundsCC).Cx
|
||||
if c >= 0 && c <= abi.BoundsMaxConst {
|
||||
xVal = int(c)
|
||||
} else {
|
||||
// Move constant to a register
|
||||
xIsReg = true
|
||||
p := s.Prog(loong64.AMOVV)
|
||||
p.From.Type = obj.TYPE_CONST
|
||||
p.From.Offset = c
|
||||
p.To.Type = obj.TYPE_REG
|
||||
p.To.Reg = loong64.REG_R4 + int16(xVal)
|
||||
}
|
||||
c = v.Aux.(ssa.PanicBoundsCC).Cy
|
||||
if c >= 0 && c <= abi.BoundsMaxConst {
|
||||
yVal = int(c)
|
||||
} else {
|
||||
// Move constant to a register
|
||||
yIsReg = true
|
||||
yVal = 1
|
||||
p := s.Prog(loong64.AMOVV)
|
||||
p.From.Type = obj.TYPE_CONST
|
||||
p.From.Offset = c
|
||||
p.To.Type = obj.TYPE_REG
|
||||
p.To.Reg = loong64.REG_R4 + int16(yVal)
|
||||
}
|
||||
}
|
||||
c := abi.BoundsEncode(code, signed, xIsReg, yIsReg, xVal, yVal)
|
||||
|
||||
p := s.Prog(obj.APCDATA)
|
||||
p.From.SetConst(abi.PCDATA_PanicBounds)
|
||||
p.To.SetConst(int64(c))
|
||||
p = s.Prog(obj.ACALL)
|
||||
p.To.Type = obj.TYPE_MEM
|
||||
p.To.Name = obj.NAME_EXTERN
|
||||
p.To.Sym = ssagen.BoundsCheckFunc[v.AuxInt]
|
||||
s.UseArgs(16) // space used in callee args area by assembly stubs
|
||||
p.To.Sym = ir.Syms.PanicBounds
|
||||
|
||||
case ssa.OpLOONG64LoweredAtomicLoad8, ssa.OpLOONG64LoweredAtomicLoad32, ssa.OpLOONG64LoweredAtomicLoad64:
|
||||
// MOVB (Rarg0), Rout
|
||||
// DBAR 0x14
|
||||
|
|
|
|||
|
|
@ -527,9 +527,11 @@
|
|||
// Publication barrier as intrinsic
|
||||
(PubBarrier ...) => (LoweredPubBarrier ...)
|
||||
|
||||
(PanicBounds [kind] x y mem) && boundsABI(kind) == 0 => (LoweredPanicBoundsA [kind] x y mem)
|
||||
(PanicBounds [kind] x y mem) && boundsABI(kind) == 1 => (LoweredPanicBoundsB [kind] x y mem)
|
||||
(PanicBounds [kind] x y mem) && boundsABI(kind) == 2 => (LoweredPanicBoundsC [kind] x y mem)
|
||||
(PanicBounds ...) => (LoweredPanicBoundsRR ...)
|
||||
(LoweredPanicBoundsRR [kind] x (MOVVconst [c]) mem) => (LoweredPanicBoundsRC [kind] x {PanicBoundsC{C:c}} mem)
|
||||
(LoweredPanicBoundsRR [kind] (MOVVconst [c]) y mem) => (LoweredPanicBoundsCR [kind] {PanicBoundsC{C:c}} y mem)
|
||||
(LoweredPanicBoundsRC [kind] {p} (MOVVconst [c]) mem) => (LoweredPanicBoundsCC [kind] {PanicBoundsCC{Cx:c, Cy:p.C}} mem)
|
||||
(LoweredPanicBoundsCR [kind] {p} (MOVVconst [c]) mem) => (LoweredPanicBoundsCC [kind] {PanicBoundsCC{Cx:p.C, Cy:c}} mem)
|
||||
|
||||
(CondSelect <t> x y cond) => (OR (MASKEQZ <t> x cond) (MASKNEZ <t> y cond))
|
||||
|
||||
|
|
|
|||
|
|
@ -130,10 +130,7 @@ func init() {
|
|||
gpspsbg = gpspg | buildReg("SB")
|
||||
fp = buildReg("F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 F13 F14 F15 F16 F17 F18 F19 F20 F21 F22 F23 F24 F25 F26 F27 F28 F29 F30 F31")
|
||||
callerSave = gp | fp | buildReg("g") // runtime.setg (and anything calling it) may clobber g
|
||||
r1 = buildReg("R20")
|
||||
r2 = buildReg("R21")
|
||||
r3 = buildReg("R23")
|
||||
r4 = buildReg("R24")
|
||||
first16 = buildReg("R4 R5 R6 R7 R8 R9 R10 R11 R12 R13 R14 R15 R16 R17 R18 R19")
|
||||
)
|
||||
// Common regInfo
|
||||
var (
|
||||
|
|
@ -563,12 +560,15 @@ func init() {
|
|||
// Do data barrier. arg0=memorys
|
||||
{name: "LoweredPubBarrier", argLength: 1, asm: "DBAR", hasSideEffects: true},
|
||||
|
||||
// There are three of these functions so that they can have three different register inputs.
|
||||
// When we check 0 <= c <= cap (A), then 0 <= b <= c (B), then 0 <= a <= b (C), we want the
|
||||
// default registers to match so we don't need to copy registers around unnecessarily.
|
||||
{name: "LoweredPanicBoundsA", argLength: 3, aux: "Int64", reg: regInfo{inputs: []regMask{r3, r4}}, typ: "Mem", call: true}, // arg0=idx, arg1=len, arg2=mem, returns memory. AuxInt contains report code (see PanicBounds in genericOps.go).
|
||||
{name: "LoweredPanicBoundsB", argLength: 3, aux: "Int64", reg: regInfo{inputs: []regMask{r2, r3}}, typ: "Mem", call: true}, // arg0=idx, arg1=len, arg2=mem, returns memory. AuxInt contains report code (see PanicBounds in genericOps.go).
|
||||
{name: "LoweredPanicBoundsC", argLength: 3, aux: "Int64", reg: regInfo{inputs: []regMask{r1, r2}}, typ: "Mem", call: true}, // arg0=idx, arg1=len, arg2=mem, returns memory. AuxInt contains report code (see PanicBounds in genericOps.go).
|
||||
// LoweredPanicBoundsRR takes x and y, two values that caused a bounds check to fail.
|
||||
// the RC and CR versions are used when one of the arguments is a constant. CC is used
|
||||
// when both are constant (normally both 0, as prove derives the fact that a [0] bounds
|
||||
// failure means the length must have also been 0).
|
||||
// AuxInt contains a report code (see PanicBounds in genericOps.go).
|
||||
{name: "LoweredPanicBoundsRR", argLength: 3, aux: "Int64", reg: regInfo{inputs: []regMask{first16, first16}}, typ: "Mem", call: true}, // arg0=x, arg1=y, arg2=mem, returns memory.
|
||||
{name: "LoweredPanicBoundsRC", argLength: 2, aux: "PanicBoundsC", reg: regInfo{inputs: []regMask{first16}}, typ: "Mem", call: true}, // arg0=x, arg1=mem, returns memory.
|
||||
{name: "LoweredPanicBoundsCR", argLength: 2, aux: "PanicBoundsC", reg: regInfo{inputs: []regMask{first16}}, typ: "Mem", call: true}, // arg0=y, arg1=mem, returns memory.
|
||||
{name: "LoweredPanicBoundsCC", argLength: 1, aux: "PanicBoundsCC", reg: regInfo{}, typ: "Mem", call: true}, // arg0=mem, returns memory.
|
||||
|
||||
// Prefetch instruction
|
||||
// Do prefetch arg0 address with option aux. arg0=addr, arg1=memory, aux=option.
|
||||
|
|
|
|||
|
|
@ -1963,9 +1963,10 @@ const (
|
|||
OpLOONG64LoweredGetCallerPC
|
||||
OpLOONG64LoweredWB
|
||||
OpLOONG64LoweredPubBarrier
|
||||
OpLOONG64LoweredPanicBoundsA
|
||||
OpLOONG64LoweredPanicBoundsB
|
||||
OpLOONG64LoweredPanicBoundsC
|
||||
OpLOONG64LoweredPanicBoundsRR
|
||||
OpLOONG64LoweredPanicBoundsRC
|
||||
OpLOONG64LoweredPanicBoundsCR
|
||||
OpLOONG64LoweredPanicBoundsCC
|
||||
OpLOONG64PRELD
|
||||
OpLOONG64PRELDX
|
||||
|
||||
|
|
@ -26439,41 +26440,46 @@ var opcodeTable = [...]opInfo{
|
|||
reg: regInfo{},
|
||||
},
|
||||
{
|
||||
name: "LoweredPanicBoundsA",
|
||||
name: "LoweredPanicBoundsRR",
|
||||
auxType: auxInt64,
|
||||
argLen: 3,
|
||||
call: true,
|
||||
reg: regInfo{
|
||||
inputs: []inputInfo{
|
||||
{0, 4194304}, // R23
|
||||
{1, 8388608}, // R24
|
||||
{0, 524280}, // R4 R5 R6 R7 R8 R9 R10 R11 R12 R13 R14 R15 R16 R17 R18 R19
|
||||
{1, 524280}, // R4 R5 R6 R7 R8 R9 R10 R11 R12 R13 R14 R15 R16 R17 R18 R19
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
name: "LoweredPanicBoundsB",
|
||||
auxType: auxInt64,
|
||||
argLen: 3,
|
||||
name: "LoweredPanicBoundsRC",
|
||||
auxType: auxPanicBoundsC,
|
||||
argLen: 2,
|
||||
call: true,
|
||||
reg: regInfo{
|
||||
inputs: []inputInfo{
|
||||
{0, 1048576}, // R21
|
||||
{1, 4194304}, // R23
|
||||
{0, 524280}, // R4 R5 R6 R7 R8 R9 R10 R11 R12 R13 R14 R15 R16 R17 R18 R19
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
name: "LoweredPanicBoundsC",
|
||||
auxType: auxInt64,
|
||||
argLen: 3,
|
||||
name: "LoweredPanicBoundsCR",
|
||||
auxType: auxPanicBoundsC,
|
||||
argLen: 2,
|
||||
call: true,
|
||||
reg: regInfo{
|
||||
inputs: []inputInfo{
|
||||
{0, 524288}, // R20
|
||||
{1, 1048576}, // R21
|
||||
{0, 524280}, // R4 R5 R6 R7 R8 R9 R10 R11 R12 R13 R14 R15 R16 R17 R18 R19
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
name: "LoweredPanicBoundsCC",
|
||||
auxType: auxPanicBoundsCC,
|
||||
argLen: 1,
|
||||
call: true,
|
||||
reg: regInfo{},
|
||||
},
|
||||
{
|
||||
name: "PRELD",
|
||||
auxType: auxInt64,
|
||||
|
|
|
|||
|
|
@ -330,6 +330,12 @@ func rewriteValueLOONG64(v *Value) bool {
|
|||
return rewriteValueLOONG64_OpLOONG64DIVV(v)
|
||||
case OpLOONG64DIVVU:
|
||||
return rewriteValueLOONG64_OpLOONG64DIVVU(v)
|
||||
case OpLOONG64LoweredPanicBoundsCR:
|
||||
return rewriteValueLOONG64_OpLOONG64LoweredPanicBoundsCR(v)
|
||||
case OpLOONG64LoweredPanicBoundsRC:
|
||||
return rewriteValueLOONG64_OpLOONG64LoweredPanicBoundsRC(v)
|
||||
case OpLOONG64LoweredPanicBoundsRR:
|
||||
return rewriteValueLOONG64_OpLOONG64LoweredPanicBoundsRR(v)
|
||||
case OpLOONG64MASKEQZ:
|
||||
return rewriteValueLOONG64_OpLOONG64MASKEQZ(v)
|
||||
case OpLOONG64MASKNEZ:
|
||||
|
|
@ -669,7 +675,8 @@ func rewriteValueLOONG64(v *Value) bool {
|
|||
v.Op = OpLOONG64OR
|
||||
return true
|
||||
case OpPanicBounds:
|
||||
return rewriteValueLOONG64_OpPanicBounds(v)
|
||||
v.Op = OpLOONG64LoweredPanicBoundsRR
|
||||
return true
|
||||
case OpPopCount16:
|
||||
return rewriteValueLOONG64_OpPopCount16(v)
|
||||
case OpPopCount32:
|
||||
|
|
@ -2070,6 +2077,86 @@ func rewriteValueLOONG64_OpLOONG64DIVVU(v *Value) bool {
|
|||
}
|
||||
return false
|
||||
}
|
||||
func rewriteValueLOONG64_OpLOONG64LoweredPanicBoundsCR(v *Value) bool {
|
||||
v_1 := v.Args[1]
|
||||
v_0 := v.Args[0]
|
||||
// match: (LoweredPanicBoundsCR [kind] {p} (MOVVconst [c]) mem)
|
||||
// result: (LoweredPanicBoundsCC [kind] {PanicBoundsCC{Cx:p.C, Cy:c}} mem)
|
||||
for {
|
||||
kind := auxIntToInt64(v.AuxInt)
|
||||
p := auxToPanicBoundsC(v.Aux)
|
||||
if v_0.Op != OpLOONG64MOVVconst {
|
||||
break
|
||||
}
|
||||
c := auxIntToInt64(v_0.AuxInt)
|
||||
mem := v_1
|
||||
v.reset(OpLOONG64LoweredPanicBoundsCC)
|
||||
v.AuxInt = int64ToAuxInt(kind)
|
||||
v.Aux = panicBoundsCCToAux(PanicBoundsCC{Cx: p.C, Cy: c})
|
||||
v.AddArg(mem)
|
||||
return true
|
||||
}
|
||||
return false
|
||||
}
|
||||
func rewriteValueLOONG64_OpLOONG64LoweredPanicBoundsRC(v *Value) bool {
|
||||
v_1 := v.Args[1]
|
||||
v_0 := v.Args[0]
|
||||
// match: (LoweredPanicBoundsRC [kind] {p} (MOVVconst [c]) mem)
|
||||
// result: (LoweredPanicBoundsCC [kind] {PanicBoundsCC{Cx:c, Cy:p.C}} mem)
|
||||
for {
|
||||
kind := auxIntToInt64(v.AuxInt)
|
||||
p := auxToPanicBoundsC(v.Aux)
|
||||
if v_0.Op != OpLOONG64MOVVconst {
|
||||
break
|
||||
}
|
||||
c := auxIntToInt64(v_0.AuxInt)
|
||||
mem := v_1
|
||||
v.reset(OpLOONG64LoweredPanicBoundsCC)
|
||||
v.AuxInt = int64ToAuxInt(kind)
|
||||
v.Aux = panicBoundsCCToAux(PanicBoundsCC{Cx: c, Cy: p.C})
|
||||
v.AddArg(mem)
|
||||
return true
|
||||
}
|
||||
return false
|
||||
}
|
||||
func rewriteValueLOONG64_OpLOONG64LoweredPanicBoundsRR(v *Value) bool {
|
||||
v_2 := v.Args[2]
|
||||
v_1 := v.Args[1]
|
||||
v_0 := v.Args[0]
|
||||
// match: (LoweredPanicBoundsRR [kind] x (MOVVconst [c]) mem)
|
||||
// result: (LoweredPanicBoundsRC [kind] x {PanicBoundsC{C:c}} mem)
|
||||
for {
|
||||
kind := auxIntToInt64(v.AuxInt)
|
||||
x := v_0
|
||||
if v_1.Op != OpLOONG64MOVVconst {
|
||||
break
|
||||
}
|
||||
c := auxIntToInt64(v_1.AuxInt)
|
||||
mem := v_2
|
||||
v.reset(OpLOONG64LoweredPanicBoundsRC)
|
||||
v.AuxInt = int64ToAuxInt(kind)
|
||||
v.Aux = panicBoundsCToAux(PanicBoundsC{C: c})
|
||||
v.AddArg2(x, mem)
|
||||
return true
|
||||
}
|
||||
// match: (LoweredPanicBoundsRR [kind] (MOVVconst [c]) y mem)
|
||||
// result: (LoweredPanicBoundsCR [kind] {PanicBoundsC{C:c}} y mem)
|
||||
for {
|
||||
kind := auxIntToInt64(v.AuxInt)
|
||||
if v_0.Op != OpLOONG64MOVVconst {
|
||||
break
|
||||
}
|
||||
c := auxIntToInt64(v_0.AuxInt)
|
||||
y := v_1
|
||||
mem := v_2
|
||||
v.reset(OpLOONG64LoweredPanicBoundsCR)
|
||||
v.AuxInt = int64ToAuxInt(kind)
|
||||
v.Aux = panicBoundsCToAux(PanicBoundsC{C: c})
|
||||
v.AddArg2(y, mem)
|
||||
return true
|
||||
}
|
||||
return false
|
||||
}
|
||||
func rewriteValueLOONG64_OpLOONG64MASKEQZ(v *Value) bool {
|
||||
v_1 := v.Args[1]
|
||||
v_0 := v.Args[0]
|
||||
|
|
@ -9106,60 +9193,6 @@ func rewriteValueLOONG64_OpOffPtr(v *Value) bool {
|
|||
return true
|
||||
}
|
||||
}
|
||||
func rewriteValueLOONG64_OpPanicBounds(v *Value) bool {
|
||||
v_2 := v.Args[2]
|
||||
v_1 := v.Args[1]
|
||||
v_0 := v.Args[0]
|
||||
// match: (PanicBounds [kind] x y mem)
|
||||
// cond: boundsABI(kind) == 0
|
||||
// result: (LoweredPanicBoundsA [kind] x y mem)
|
||||
for {
|
||||
kind := auxIntToInt64(v.AuxInt)
|
||||
x := v_0
|
||||
y := v_1
|
||||
mem := v_2
|
||||
if !(boundsABI(kind) == 0) {
|
||||
break
|
||||
}
|
||||
v.reset(OpLOONG64LoweredPanicBoundsA)
|
||||
v.AuxInt = int64ToAuxInt(kind)
|
||||
v.AddArg3(x, y, mem)
|
||||
return true
|
||||
}
|
||||
// match: (PanicBounds [kind] x y mem)
|
||||
// cond: boundsABI(kind) == 1
|
||||
// result: (LoweredPanicBoundsB [kind] x y mem)
|
||||
for {
|
||||
kind := auxIntToInt64(v.AuxInt)
|
||||
x := v_0
|
||||
y := v_1
|
||||
mem := v_2
|
||||
if !(boundsABI(kind) == 1) {
|
||||
break
|
||||
}
|
||||
v.reset(OpLOONG64LoweredPanicBoundsB)
|
||||
v.AuxInt = int64ToAuxInt(kind)
|
||||
v.AddArg3(x, y, mem)
|
||||
return true
|
||||
}
|
||||
// match: (PanicBounds [kind] x y mem)
|
||||
// cond: boundsABI(kind) == 2
|
||||
// result: (LoweredPanicBoundsC [kind] x y mem)
|
||||
for {
|
||||
kind := auxIntToInt64(v.AuxInt)
|
||||
x := v_0
|
||||
y := v_1
|
||||
mem := v_2
|
||||
if !(boundsABI(kind) == 2) {
|
||||
break
|
||||
}
|
||||
v.reset(OpLOONG64LoweredPanicBoundsC)
|
||||
v.AuxInt = int64ToAuxInt(kind)
|
||||
v.AddArg3(x, y, mem)
|
||||
return true
|
||||
}
|
||||
return false
|
||||
}
|
||||
func rewriteValueLOONG64_OpPopCount16(v *Value) bool {
|
||||
v_0 := v.Args[0]
|
||||
b := v.Block
|
||||
|
|
|
|||
|
|
@ -1135,76 +1135,29 @@ TEXT runtime·debugCallPanicked(SB),NOSPLIT,$16-16
|
|||
BREAK
|
||||
RET
|
||||
|
||||
// Note: these functions use a special calling convention to save generated code space.
|
||||
// Arguments are passed in registers, but the space for those arguments are allocated
|
||||
// in the caller's stack frame. These stubs write the args into that stack space and
|
||||
// then tail call to the corresponding runtime handler.
|
||||
// The tail call makes these stubs disappear in backtraces.
|
||||
TEXT runtime·panicIndex<ABIInternal>(SB),NOSPLIT,$0-16
|
||||
MOVV R20, R4
|
||||
MOVV R21, R5
|
||||
JMP runtime·goPanicIndex<ABIInternal>(SB)
|
||||
TEXT runtime·panicIndexU<ABIInternal>(SB),NOSPLIT,$0-16
|
||||
MOVV R20, R4
|
||||
MOVV R21, R5
|
||||
JMP runtime·goPanicIndexU<ABIInternal>(SB)
|
||||
TEXT runtime·panicSliceAlen<ABIInternal>(SB),NOSPLIT,$0-16
|
||||
MOVV R21, R4
|
||||
MOVV R23, R5
|
||||
JMP runtime·goPanicSliceAlen<ABIInternal>(SB)
|
||||
TEXT runtime·panicSliceAlenU<ABIInternal>(SB),NOSPLIT,$0-16
|
||||
MOVV R21, R4
|
||||
MOVV R23, R5
|
||||
JMP runtime·goPanicSliceAlenU<ABIInternal>(SB)
|
||||
TEXT runtime·panicSliceAcap<ABIInternal>(SB),NOSPLIT,$0-16
|
||||
MOVV R21, R4
|
||||
MOVV R23, R5
|
||||
JMP runtime·goPanicSliceAcap<ABIInternal>(SB)
|
||||
TEXT runtime·panicSliceAcapU<ABIInternal>(SB),NOSPLIT,$0-16
|
||||
MOVV R21, R4
|
||||
MOVV R23, R5
|
||||
JMP runtime·goPanicSliceAcapU<ABIInternal>(SB)
|
||||
TEXT runtime·panicSliceB<ABIInternal>(SB),NOSPLIT,$0-16
|
||||
MOVV R20, R4
|
||||
MOVV R21, R5
|
||||
JMP runtime·goPanicSliceB<ABIInternal>(SB)
|
||||
TEXT runtime·panicSliceBU<ABIInternal>(SB),NOSPLIT,$0-16
|
||||
MOVV R20, R4
|
||||
MOVV R21, R5
|
||||
JMP runtime·goPanicSliceBU<ABIInternal>(SB)
|
||||
TEXT runtime·panicSlice3Alen<ABIInternal>(SB),NOSPLIT,$0-16
|
||||
MOVV R23, R4
|
||||
MOVV R24, R5
|
||||
JMP runtime·goPanicSlice3Alen<ABIInternal>(SB)
|
||||
TEXT runtime·panicSlice3AlenU<ABIInternal>(SB),NOSPLIT,$0-16
|
||||
MOVV R23, R4
|
||||
MOVV R24, R5
|
||||
JMP runtime·goPanicSlice3AlenU<ABIInternal>(SB)
|
||||
TEXT runtime·panicSlice3Acap<ABIInternal>(SB),NOSPLIT,$0-16
|
||||
MOVV R23, R4
|
||||
MOVV R24, R5
|
||||
JMP runtime·goPanicSlice3Acap<ABIInternal>(SB)
|
||||
TEXT runtime·panicSlice3AcapU<ABIInternal>(SB),NOSPLIT,$0-16
|
||||
MOVV R23, R4
|
||||
MOVV R24, R5
|
||||
JMP runtime·goPanicSlice3AcapU<ABIInternal>(SB)
|
||||
TEXT runtime·panicSlice3B<ABIInternal>(SB),NOSPLIT,$0-16
|
||||
MOVV R21, R4
|
||||
MOVV R23, R5
|
||||
JMP runtime·goPanicSlice3B<ABIInternal>(SB)
|
||||
TEXT runtime·panicSlice3BU<ABIInternal>(SB),NOSPLIT,$0-16
|
||||
MOVV R21, R4
|
||||
MOVV R23, R5
|
||||
JMP runtime·goPanicSlice3BU<ABIInternal>(SB)
|
||||
TEXT runtime·panicSlice3C<ABIInternal>(SB),NOSPLIT,$0-16
|
||||
MOVV R20, R4
|
||||
MOVV R21, R5
|
||||
JMP runtime·goPanicSlice3C<ABIInternal>(SB)
|
||||
TEXT runtime·panicSlice3CU<ABIInternal>(SB),NOSPLIT,$0-16
|
||||
MOVV R20, R4
|
||||
MOVV R21, R5
|
||||
JMP runtime·goPanicSlice3CU<ABIInternal>(SB)
|
||||
TEXT runtime·panicSliceConvert<ABIInternal>(SB),NOSPLIT,$0-16
|
||||
MOVV R23, R4
|
||||
MOVV R24, R5
|
||||
JMP runtime·goPanicSliceConvert<ABIInternal>(SB)
|
||||
TEXT runtime·panicBounds<ABIInternal>(SB),NOSPLIT,$144-0
|
||||
NO_LOCAL_POINTERS
|
||||
// Save all 16 int registers that could have an index in them.
|
||||
// They may be pointers, but if they are they are dead.
|
||||
// Skip R0 aka ZERO, R1 aka LR, R2 aka thread pointer, R3 aka SP.
|
||||
MOVV R4, 24(R3)
|
||||
MOVV R5, 32(R3)
|
||||
MOVV R6, 40(R3)
|
||||
MOVV R7, 48(R3)
|
||||
MOVV R8, 56(R3)
|
||||
MOVV R9, 64(R3)
|
||||
MOVV R10, 72(R3)
|
||||
MOVV R11, 80(R3)
|
||||
MOVV R12, 88(R3)
|
||||
MOVV R13, 96(R3)
|
||||
MOVV R14, 104(R3)
|
||||
MOVV R15, 112(R3)
|
||||
MOVV R16, 120(R3)
|
||||
MOVV R17, 128(R3)
|
||||
MOVV R18, 136(R3)
|
||||
MOVV R19, 144(R3)
|
||||
|
||||
MOVV R1, R4 // PC immediately after call to panicBounds
|
||||
ADDV $24, R3, R5 // pointer to save area
|
||||
CALL runtime·panicBounds64<ABIInternal>(SB)
|
||||
RET
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue