Text file
src/runtime/asm_loong64.s
1 // Copyright 2022 The Go Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style
3 // license that can be found in the LICENSE file.
4
5 #include "go_asm.h"
6 #include "go_tls.h"
7 #include "funcdata.h"
8 #include "textflag.h"
9
10 #define REGCTXT R29
11
12 TEXT runtime·rt0_go(SB),NOSPLIT|TOPFRAME,$0
13 // R3 = stack; R4 = argc; R5 = argv
14
15 ADDV $-24, R3
16 MOVW R4, 8(R3) // argc
17 MOVV R5, 16(R3) // argv
18
19 // create istack out of the given (operating system) stack.
20 // _cgo_init may update stackguard.
21 MOVV $runtime·g0(SB), g
22 MOVV $(-64*1024), R30
23 ADDV R30, R3, R19
24 MOVV R19, g_stackguard0(g)
25 MOVV R19, g_stackguard1(g)
26 MOVV R19, (g_stack+stack_lo)(g)
27 MOVV R3, (g_stack+stack_hi)(g)
28
29 // if there is a _cgo_init, call it using the gcc ABI.
30 MOVV _cgo_init(SB), R25
31 BEQ R25, nocgo
32
33 MOVV R0, R7 // arg 3: not used
34 MOVV R0, R6 // arg 2: not used
35 MOVV $setg_gcc<>(SB), R5 // arg 1: setg
36 MOVV g, R4 // arg 0: G
37 JAL (R25)
38
39 nocgo:
40 // update stackguard after _cgo_init
41 MOVV (g_stack+stack_lo)(g), R19
42 ADDV $const_stackGuard, R19
43 MOVV R19, g_stackguard0(g)
44 MOVV R19, g_stackguard1(g)
45
46 // set the per-goroutine and per-mach "registers"
47 MOVV $runtime·m0(SB), R19
48
49 // save m->g0 = g0
50 MOVV g, m_g0(R19)
51 // save m0 to g0->m
52 MOVV R19, g_m(g)
53
54 JAL runtime·check(SB)
55
56 // args are already prepared
57 JAL runtime·args(SB)
58 JAL runtime·osinit(SB)
59 JAL runtime·schedinit(SB)
60
61 // create a new goroutine to start program
62 MOVV $runtime·mainPC(SB), R19 // entry
63 ADDV $-16, R3
64 MOVV R19, 8(R3)
65 MOVV R0, 0(R3)
66 JAL runtime·newproc(SB)
67 ADDV $16, R3
68
69 // start this M
70 JAL runtime·mstart(SB)
71
72 // Prevent dead-code elimination of debugCallV2, which is
73 // intended to be called by debuggers.
74 MOVV $runtime·debugCallV2<ABIInternal>(SB), R0
75
76 MOVV R0, 1(R0)
77 RET
78
79 DATA runtime·mainPC+0(SB)/8,$runtime·main<ABIInternal>(SB)
80 GLOBL runtime·mainPC(SB),RODATA,$8
81
82 TEXT runtime·breakpoint(SB),NOSPLIT|NOFRAME,$0-0
83 BREAK
84 RET
85
86 TEXT runtime·asminit(SB),NOSPLIT|NOFRAME,$0-0
87 RET
88
89 TEXT runtime·mstart(SB),NOSPLIT|TOPFRAME,$0
90 JAL runtime·mstart0(SB)
91 RET // not reached
92
93 // func cputicks() int64
94 TEXT runtime·cputicks<ABIInternal>(SB),NOSPLIT,$0-8
95 RDTIMED R0, R4
96 RET
97
98 /*
99 * go-routine
100 */
101
102 // void gogo(Gobuf*)
103 // restore state from Gobuf; longjmp
104 TEXT runtime·gogo(SB), NOSPLIT|NOFRAME, $0-8
105 MOVV buf+0(FP), R4
106 MOVV gobuf_g(R4), R5
107 MOVV 0(R5), R0 // make sure g != nil
108 JMP gogo<>(SB)
109
110 TEXT gogo<>(SB), NOSPLIT|NOFRAME, $0
111 MOVV R5, g
112 JAL runtime·save_g(SB)
113
114 MOVV gobuf_sp(R4), R3
115 MOVV gobuf_lr(R4), R1
116 MOVV gobuf_ctxt(R4), REGCTXT
117 MOVV R0, gobuf_sp(R4)
118 MOVV R0, gobuf_lr(R4)
119 MOVV R0, gobuf_ctxt(R4)
120 MOVV gobuf_pc(R4), R6
121 JMP (R6)
122
123 // void mcall(fn func(*g))
124 // Switch to m->g0's stack, call fn(g).
125 // Fn must never return. It should gogo(&g->sched)
126 // to keep running g.
127 TEXT runtime·mcall<ABIInternal>(SB), NOSPLIT|NOFRAME, $0-8
128 MOVV R4, REGCTXT
129 // Save caller state in g->sched
130 MOVV R3, (g_sched+gobuf_sp)(g)
131 MOVV R1, (g_sched+gobuf_pc)(g)
132 MOVV R0, (g_sched+gobuf_lr)(g)
133
134 // Switch to m->g0 & its stack, call fn.
135 MOVV g, R4 // arg = g
136 MOVV g_m(g), R20
137 MOVV m_g0(R20), g
138 JAL runtime·save_g(SB)
139 BNE g, R4, 2(PC)
140 JMP runtime·badmcall(SB)
141 MOVV 0(REGCTXT), R20 // code pointer
142 MOVV (g_sched+gobuf_sp)(g), R3 // sp = m->g0->sched.sp
143 ADDV $-16, R3
144 MOVV R4, 8(R3)
145 MOVV R0, 0(R3)
146 JAL (R20)
147 JMP runtime·badmcall2(SB)
148
149 // systemstack_switch is a dummy routine that systemstack leaves at the bottom
150 // of the G stack. We need to distinguish the routine that
151 // lives at the bottom of the G stack from the one that lives
152 // at the top of the system stack because the one at the top of
153 // the system stack terminates the stack walk (see topofstack()).
154 TEXT runtime·systemstack_switch(SB), NOSPLIT, $0-0
155 UNDEF
156 JAL (R1) // make sure this function is not leaf
157 RET
158
159 // func systemstack(fn func())
160 TEXT runtime·systemstack(SB), NOSPLIT, $0-8
161 MOVV fn+0(FP), R19 // R19 = fn
162 MOVV R19, REGCTXT // context
163 MOVV g_m(g), R4 // R4 = m
164
165 MOVV m_gsignal(R4), R5 // R5 = gsignal
166 BEQ g, R5, noswitch
167
168 MOVV m_g0(R4), R5 // R5 = g0
169 BEQ g, R5, noswitch
170
171 MOVV m_curg(R4), R6
172 BEQ g, R6, switch
173
174 // Bad: g is not gsignal, not g0, not curg. What is it?
175 // Hide call from linker nosplit analysis.
176 MOVV $runtime·badsystemstack(SB), R7
177 JAL (R7)
178 JAL runtime·abort(SB)
179
180 switch:
181 // save our state in g->sched. Pretend to
182 // be systemstack_switch if the G stack is scanned.
183 JAL gosave_systemstack_switch<>(SB)
184
185 // switch to g0
186 MOVV R5, g
187 JAL runtime·save_g(SB)
188 MOVV (g_sched+gobuf_sp)(g), R19
189 MOVV R19, R3
190
191 // call target function
192 MOVV 0(REGCTXT), R6 // code pointer
193 JAL (R6)
194
195 // switch back to g
196 MOVV g_m(g), R4
197 MOVV m_curg(R4), g
198 JAL runtime·save_g(SB)
199 MOVV (g_sched+gobuf_sp)(g), R3
200 MOVV R0, (g_sched+gobuf_sp)(g)
201 RET
202
203 noswitch:
204 // already on m stack, just call directly
205 // Using a tail call here cleans up tracebacks since we won't stop
206 // at an intermediate systemstack.
207 MOVV 0(REGCTXT), R4 // code pointer
208 MOVV 0(R3), R1 // restore LR
209 ADDV $8, R3
210 JMP (R4)
211
212 // func switchToCrashStack0(fn func())
213 TEXT runtime·switchToCrashStack0<ABIInternal>(SB),NOSPLIT,$0-8
214 MOVV R4, REGCTXT // context register
215 MOVV g_m(g), R5 // curm
216
217 // set g to gcrash
218 MOVV $runtime·gcrash(SB), g // g = &gcrash
219 JAL runtime·save_g(SB)
220 MOVV R5, g_m(g) // g.m = curm
221 MOVV g, m_g0(R5) // curm.g0 = g
222
223 // switch to crashstack
224 MOVV (g_stack+stack_hi)(g), R5
225 ADDV $(-4*8), R5, R3
226
227 // call target function
228 MOVV 0(REGCTXT), R6
229 JAL (R6)
230
231 // should never return
232 JAL runtime·abort(SB)
233 UNDEF
234
235 /*
236 * support for morestack
237 */
238
239 // Called during function prolog when more stack is needed.
240 // Caller has already loaded:
241 // loong64: R31: LR
242 //
243 // The traceback routines see morestack on a g0 as being
244 // the top of a stack (for example, morestack calling newstack
245 // calling the scheduler calling newm calling gc), so we must
246 // record an argument size. For that purpose, it has no arguments.
247 TEXT runtime·morestack(SB),NOSPLIT|NOFRAME,$0-0
248 // Called from f.
249 // Set g->sched to context in f.
250 MOVV R3, (g_sched+gobuf_sp)(g)
251 MOVV R1, (g_sched+gobuf_pc)(g)
252 MOVV R31, (g_sched+gobuf_lr)(g)
253 MOVV REGCTXT, (g_sched+gobuf_ctxt)(g)
254
255 // Cannot grow scheduler stack (m->g0).
256 MOVV g_m(g), R7
257 MOVV m_g0(R7), R8
258 BNE g, R8, 3(PC)
259 JAL runtime·badmorestackg0(SB)
260 JAL runtime·abort(SB)
261
262 // Cannot grow signal stack (m->gsignal).
263 MOVV m_gsignal(R7), R8
264 BNE g, R8, 3(PC)
265 JAL runtime·badmorestackgsignal(SB)
266 JAL runtime·abort(SB)
267
268 // Called from f.
269 // Set m->morebuf to f's caller.
270 MOVV R31, (m_morebuf+gobuf_pc)(R7) // f's caller's PC
271 MOVV R3, (m_morebuf+gobuf_sp)(R7) // f's caller's SP
272 MOVV g, (m_morebuf+gobuf_g)(R7)
273
274 // Call newstack on m->g0's stack.
275 MOVV m_g0(R7), g
276 JAL runtime·save_g(SB)
277 MOVV (g_sched+gobuf_sp)(g), R3
278 // Create a stack frame on g0 to call newstack.
279 MOVV R0, -8(R3) // Zero saved LR in frame
280 ADDV $-8, R3
281 JAL runtime·newstack(SB)
282
283 // Not reached, but make sure the return PC from the call to newstack
284 // is still in this function, and not the beginning of the next.
285 UNDEF
286
287 TEXT runtime·morestack_noctxt(SB),NOSPLIT|NOFRAME,$0-0
288 // Force SPWRITE. This function doesn't actually write SP,
289 // but it is called with a special calling convention where
290 // the caller doesn't save LR on stack but passes it as a
291 // register (R5), and the unwinder currently doesn't understand.
292 // Make it SPWRITE to stop unwinding. (See issue 54332)
293 MOVV R3, R3
294
295 MOVV R0, REGCTXT
296 JMP runtime·morestack(SB)
297
298 // reflectcall: call a function with the given argument list
299 // func call(stackArgsType *_type, f *FuncVal, stackArgs *byte, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs).
300 // we don't have variable-sized frames, so we use a small number
301 // of constant-sized-frame functions to encode a few bits of size in the pc.
302 // Caution: ugly multiline assembly macros in your future!
303
304 #define DISPATCH(NAME,MAXSIZE) \
305 MOVV $MAXSIZE, R30; \
306 SGTU R19, R30, R30; \
307 BNE R30, 3(PC); \
308 MOVV $NAME(SB), R4; \
309 JMP (R4)
310 // Note: can't just "BR NAME(SB)" - bad inlining results.
311
312 TEXT ·reflectcall(SB), NOSPLIT|NOFRAME, $0-48
313 MOVWU frameSize+32(FP), R19
314 DISPATCH(runtime·call32, 32)
315 DISPATCH(runtime·call64, 64)
316 DISPATCH(runtime·call128, 128)
317 DISPATCH(runtime·call256, 256)
318 DISPATCH(runtime·call512, 512)
319 DISPATCH(runtime·call1024, 1024)
320 DISPATCH(runtime·call2048, 2048)
321 DISPATCH(runtime·call4096, 4096)
322 DISPATCH(runtime·call8192, 8192)
323 DISPATCH(runtime·call16384, 16384)
324 DISPATCH(runtime·call32768, 32768)
325 DISPATCH(runtime·call65536, 65536)
326 DISPATCH(runtime·call131072, 131072)
327 DISPATCH(runtime·call262144, 262144)
328 DISPATCH(runtime·call524288, 524288)
329 DISPATCH(runtime·call1048576, 1048576)
330 DISPATCH(runtime·call2097152, 2097152)
331 DISPATCH(runtime·call4194304, 4194304)
332 DISPATCH(runtime·call8388608, 8388608)
333 DISPATCH(runtime·call16777216, 16777216)
334 DISPATCH(runtime·call33554432, 33554432)
335 DISPATCH(runtime·call67108864, 67108864)
336 DISPATCH(runtime·call134217728, 134217728)
337 DISPATCH(runtime·call268435456, 268435456)
338 DISPATCH(runtime·call536870912, 536870912)
339 DISPATCH(runtime·call1073741824, 1073741824)
340 MOVV $runtime·badreflectcall(SB), R4
341 JMP (R4)
342
343 #define CALLFN(NAME,MAXSIZE) \
344 TEXT NAME(SB), WRAPPER, $MAXSIZE-48; \
345 NO_LOCAL_POINTERS; \
346 /* copy arguments to stack */ \
347 MOVV arg+16(FP), R4; \
348 MOVWU argsize+24(FP), R5; \
349 MOVV R3, R12; \
350 MOVV $16, R13; \
351 ADDV $8, R12; \
352 BLT R5, R13, check8; \
353 /* copy 16 bytes a time */ \
354 MOVBU internal∕cpu·Loong64+const_offsetLOONG64HasLSX(SB), R16; \
355 BEQ R16, copy16_again; \
356 loop16:; \
357 VMOVQ (R4), V0; \
358 ADDV $16, R4; \
359 ADDV $-16, R5; \
360 VMOVQ V0, (R12); \
361 ADDV $16, R12; \
362 BGE R5, R13, loop16; \
363 JMP check8; \
364 copy16_again:; \
365 MOVV (R4), R14; \
366 MOVV 8(R4), R15; \
367 ADDV $16, R4; \
368 ADDV $-16, R5; \
369 MOVV R14, (R12); \
370 MOVV R15, 8(R12); \
371 ADDV $16, R12; \
372 BGE R5, R13, copy16_again; \
373 check8:; \
374 /* R13 = 8 */; \
375 SRLV $1, R13; \
376 BLT R5, R13, 6(PC); \
377 /* copy 8 bytes a time */ \
378 MOVV (R4), R14; \
379 ADDV $8, R4; \
380 ADDV $-8, R5; \
381 MOVV R14, (R12); \
382 ADDV $8, R12; \
383 BEQ R5, R0, 7(PC); \
384 /* copy 1 byte a time for the rest */ \
385 MOVBU (R4), R14; \
386 ADDV $1, R4; \
387 ADDV $-1, R5; \
388 MOVBU R14, (R12); \
389 ADDV $1, R12; \
390 JMP -6(PC); \
391 /* set up argument registers */ \
392 MOVV regArgs+40(FP), R25; \
393 JAL ·unspillArgs(SB); \
394 /* call function */ \
395 MOVV f+8(FP), REGCTXT; \
396 MOVV (REGCTXT), R25; \
397 PCDATA $PCDATA_StackMapIndex, $0; \
398 JAL (R25); \
399 /* copy return values back */ \
400 MOVV regArgs+40(FP), R25; \
401 JAL ·spillArgs(SB); \
402 MOVV argtype+0(FP), R7; \
403 MOVV arg+16(FP), R4; \
404 MOVWU n+24(FP), R5; \
405 MOVWU retoffset+28(FP), R6; \
406 ADDV $8, R3, R12; \
407 ADDV R6, R12; \
408 ADDV R6, R4; \
409 SUBVU R6, R5; \
410 JAL callRet<>(SB); \
411 RET
412
413 // callRet copies return values back at the end of call*. This is a
414 // separate function so it can allocate stack space for the arguments
415 // to reflectcallmove. It does not follow the Go ABI; it expects its
416 // arguments in registers.
417 TEXT callRet<>(SB), NOSPLIT, $40-0
418 NO_LOCAL_POINTERS
419 MOVV R7, 8(R3)
420 MOVV R4, 16(R3)
421 MOVV R12, 24(R3)
422 MOVV R5, 32(R3)
423 MOVV R25, 40(R3)
424 JAL runtime·reflectcallmove(SB)
425 RET
426
427 CALLFN(·call16, 16)
428 CALLFN(·call32, 32)
429 CALLFN(·call64, 64)
430 CALLFN(·call128, 128)
431 CALLFN(·call256, 256)
432 CALLFN(·call512, 512)
433 CALLFN(·call1024, 1024)
434 CALLFN(·call2048, 2048)
435 CALLFN(·call4096, 4096)
436 CALLFN(·call8192, 8192)
437 CALLFN(·call16384, 16384)
438 CALLFN(·call32768, 32768)
439 CALLFN(·call65536, 65536)
440 CALLFN(·call131072, 131072)
441 CALLFN(·call262144, 262144)
442 CALLFN(·call524288, 524288)
443 CALLFN(·call1048576, 1048576)
444 CALLFN(·call2097152, 2097152)
445 CALLFN(·call4194304, 4194304)
446 CALLFN(·call8388608, 8388608)
447 CALLFN(·call16777216, 16777216)
448 CALLFN(·call33554432, 33554432)
449 CALLFN(·call67108864, 67108864)
450 CALLFN(·call134217728, 134217728)
451 CALLFN(·call268435456, 268435456)
452 CALLFN(·call536870912, 536870912)
453 CALLFN(·call1073741824, 1073741824)
454
455 TEXT runtime·procyield(SB),NOSPLIT,$0-0
456 RET
457
458 // Save state of caller into g->sched.
459 // but using fake PC from systemstack_switch.
460 // Must only be called from functions with no locals ($0)
461 // or else unwinding from systemstack_switch is incorrect.
462 // Smashes R19.
463 TEXT gosave_systemstack_switch<>(SB),NOSPLIT|NOFRAME,$0
464 MOVV $runtime·systemstack_switch(SB), R19
465 ADDV $8, R19
466 MOVV R19, (g_sched+gobuf_pc)(g)
467 MOVV R3, (g_sched+gobuf_sp)(g)
468 MOVV R0, (g_sched+gobuf_lr)(g)
469 // Assert ctxt is zero. See func save.
470 MOVV (g_sched+gobuf_ctxt)(g), R19
471 BEQ R19, 2(PC)
472 JAL runtime·abort(SB)
473 RET
474
475 // func asmcgocall(fn, arg unsafe.Pointer) int32
476 // Call fn(arg) on the scheduler stack,
477 // aligned appropriately for the gcc ABI.
478 // See cgocall.go for more details.
479 TEXT ·asmcgocall(SB),NOSPLIT,$0-20
480 MOVV fn+0(FP), R25
481 MOVV arg+8(FP), R4
482
483 MOVV R3, R12 // save original stack pointer
484 MOVV g, R13
485
486 // Figure out if we need to switch to m->g0 stack.
487 // We get called to create new OS threads too, and those
488 // come in on the m->g0 stack already.
489 MOVV g_m(g), R5
490 MOVV m_gsignal(R5), R6
491 BEQ R6, g, g0
492 MOVV m_g0(R5), R6
493 BEQ R6, g, g0
494
495 JAL gosave_systemstack_switch<>(SB)
496 MOVV R6, g
497 JAL runtime·save_g(SB)
498 MOVV (g_sched+gobuf_sp)(g), R3
499
500 // Now on a scheduling stack (a pthread-created stack).
501 g0:
502 // Save room for two of our pointers.
503 ADDV $-16, R3
504 MOVV R13, 0(R3) // save old g on stack
505 MOVV (g_stack+stack_hi)(R13), R13
506 SUBVU R12, R13
507 MOVV R13, 8(R3) // save depth in old g stack (can't just save SP, as stack might be copied during a callback)
508 JAL (R25)
509
510 // Restore g, stack pointer. R4 is return value.
511 MOVV 0(R3), g
512 JAL runtime·save_g(SB)
513 MOVV (g_stack+stack_hi)(g), R5
514 MOVV 8(R3), R6
515 SUBVU R6, R5
516 MOVV R5, R3
517
518 MOVW R4, ret+16(FP)
519 RET
520
521 // func cgocallback(fn, frame unsafe.Pointer, ctxt uintptr)
522 // See cgocall.go for more details.
523 TEXT ·cgocallback(SB),NOSPLIT,$24-24
524 NO_LOCAL_POINTERS
525
526 // Skip cgocallbackg, just dropm when fn is nil, and frame is the saved g.
527 // It is used to dropm while thread is exiting.
528 MOVV fn+0(FP), R5
529 BNE R5, loadg
530 // Restore the g from frame.
531 MOVV frame+8(FP), g
532 JMP dropm
533
534 loadg:
535 // Load m and g from thread-local storage.
536 MOVB runtime·iscgo(SB), R19
537 BEQ R19, nocgo
538 JAL runtime·load_g(SB)
539 nocgo:
540
541 // If g is nil, Go did not create the current thread,
542 // or if this thread never called into Go on pthread platforms.
543 // Call needm to obtain one for temporary use.
544 // In this case, we're running on the thread stack, so there's
545 // lots of space, but the linker doesn't know. Hide the call from
546 // the linker analysis by using an indirect call.
547 BEQ g, needm
548
549 MOVV g_m(g), R12
550 MOVV R12, savedm-8(SP)
551 JMP havem
552
553 needm:
554 MOVV g, savedm-8(SP) // g is zero, so is m.
555 MOVV $runtime·needAndBindM(SB), R4
556 JAL (R4)
557
558 // Set m->sched.sp = SP, so that if a panic happens
559 // during the function we are about to execute, it will
560 // have a valid SP to run on the g0 stack.
561 // The next few lines (after the havem label)
562 // will save this SP onto the stack and then write
563 // the same SP back to m->sched.sp. That seems redundant,
564 // but if an unrecovered panic happens, unwindm will
565 // restore the g->sched.sp from the stack location
566 // and then systemstack will try to use it. If we don't set it here,
567 // that restored SP will be uninitialized (typically 0) and
568 // will not be usable.
569 MOVV g_m(g), R12
570 MOVV m_g0(R12), R19
571 MOVV R3, (g_sched+gobuf_sp)(R19)
572
573 havem:
574 // Now there's a valid m, and we're running on its m->g0.
575 // Save current m->g0->sched.sp on stack and then set it to SP.
576 // Save current sp in m->g0->sched.sp in preparation for
577 // switch back to m->curg stack.
578 // NOTE: unwindm knows that the saved g->sched.sp is at 8(R29) aka savedsp-16(SP).
579 MOVV m_g0(R12), R19
580 MOVV (g_sched+gobuf_sp)(R19), R13
581 MOVV R13, savedsp-24(SP) // must match frame size
582 MOVV R3, (g_sched+gobuf_sp)(R19)
583
584 // Switch to m->curg stack and call runtime.cgocallbackg.
585 // Because we are taking over the execution of m->curg
586 // but *not* resuming what had been running, we need to
587 // save that information (m->curg->sched) so we can restore it.
588 // We can restore m->curg->sched.sp easily, because calling
589 // runtime.cgocallbackg leaves SP unchanged upon return.
590 // To save m->curg->sched.pc, we push it onto the stack.
591 // This has the added benefit that it looks to the traceback
592 // routine like cgocallbackg is going to return to that
593 // PC (because the frame we allocate below has the same
594 // size as cgocallback_gofunc's frame declared above)
595 // so that the traceback will seamlessly trace back into
596 // the earlier calls.
597 MOVV m_curg(R12), g
598 JAL runtime·save_g(SB)
599 MOVV (g_sched+gobuf_sp)(g), R13 // prepare stack as R13
600 MOVV (g_sched+gobuf_pc)(g), R4
601 MOVV R4, -(24+8)(R13) // "saved LR"; must match frame size
602 MOVV fn+0(FP), R5
603 MOVV frame+8(FP), R6
604 MOVV ctxt+16(FP), R7
605 MOVV $-(24+8)(R13), R3
606 MOVV R5, 8(R3)
607 MOVV R6, 16(R3)
608 MOVV R7, 24(R3)
609 JAL runtime·cgocallbackg(SB)
610
611 // Restore g->sched (== m->curg->sched) from saved values.
612 MOVV 0(R3), R4
613 MOVV R4, (g_sched+gobuf_pc)(g)
614 MOVV $(24+8)(R3), R13 // must match frame size
615 MOVV R13, (g_sched+gobuf_sp)(g)
616
617 // Switch back to m->g0's stack and restore m->g0->sched.sp.
618 // (Unlike m->curg, the g0 goroutine never uses sched.pc,
619 // so we do not have to restore it.)
620 MOVV g_m(g), R12
621 MOVV m_g0(R12), g
622 JAL runtime·save_g(SB)
623 MOVV (g_sched+gobuf_sp)(g), R3
624 MOVV savedsp-24(SP), R13 // must match frame size
625 MOVV R13, (g_sched+gobuf_sp)(g)
626
627 // If the m on entry was nil, we called needm above to borrow an m,
628 // 1. for the duration of the call on non-pthread platforms,
629 // 2. or the duration of the C thread alive on pthread platforms.
630 // If the m on entry wasn't nil,
631 // 1. the thread might be a Go thread,
632 // 2. or it wasn't the first call from a C thread on pthread platforms,
633 // since then we skip dropm to resue the m in the first call.
634 MOVV savedm-8(SP), R12
635 BNE R12, droppedm
636
637 // Skip dropm to reuse it in the next call, when a pthread key has been created.
638 MOVV _cgo_pthread_key_created(SB), R12
639 // It means cgo is disabled when _cgo_pthread_key_created is a nil pointer, need dropm.
640 BEQ R12, dropm
641 MOVV (R12), R12
642 BNE R12, droppedm
643
644 dropm:
645 MOVV $runtime·dropm(SB), R4
646 JAL (R4)
647 droppedm:
648
649 // Done!
650 RET
651
652 // void setg(G*); set g. for use by needm.
653 TEXT runtime·setg(SB), NOSPLIT, $0-8
654 MOVV gg+0(FP), g
655 // This only happens if iscgo, so jump straight to save_g
656 JAL runtime·save_g(SB)
657 RET
658
659 // void setg_gcc(G*); set g called from gcc with g in R4
660 TEXT setg_gcc<>(SB),NOSPLIT,$0-0
661 MOVV R4, g
662 JAL runtime·save_g(SB)
663 RET
664
665 TEXT runtime·abort(SB),NOSPLIT|NOFRAME,$0-0
666 MOVW (R0), R0
667 UNDEF
668
669 // AES hashing not implemented for loong64
670 TEXT runtime·memhash<ABIInternal>(SB),NOSPLIT|NOFRAME,$0-32
671 JMP runtime·memhashFallback<ABIInternal>(SB)
672 TEXT runtime·strhash<ABIInternal>(SB),NOSPLIT|NOFRAME,$0-24
673 JMP runtime·strhashFallback<ABIInternal>(SB)
674 TEXT runtime·memhash32<ABIInternal>(SB),NOSPLIT|NOFRAME,$0-24
675 JMP runtime·memhash32Fallback<ABIInternal>(SB)
676 TEXT runtime·memhash64<ABIInternal>(SB),NOSPLIT|NOFRAME,$0-24
677 JMP runtime·memhash64Fallback<ABIInternal>(SB)
678
679 // Called from cgo wrappers, this function returns g->m->curg.stack.hi.
680 // Must obey the gcc calling convention.
681 TEXT _cgo_topofstack(SB),NOSPLIT,$16
682 // g (R22) and REGTMP (R30) might be clobbered by load_g. They
683 // are callee-save in the gcc calling convention, so save them.
684 MOVV R30, savedREGTMP-16(SP)
685 MOVV g, savedG-8(SP)
686
687 JAL runtime·load_g(SB)
688 MOVV g_m(g), R19
689 MOVV m_curg(R19), R19
690 MOVV (g_stack+stack_hi)(R19), R4 // return value in R4
691
692 MOVV savedG-8(SP), g
693 MOVV savedREGTMP-16(SP), R30
694 RET
695
696 // The top-most function running on a goroutine
697 // returns to goexit+PCQuantum.
698 TEXT runtime·goexit(SB),NOSPLIT|NOFRAME|TOPFRAME,$0-0
699 NOOP
700 JAL runtime·goexit1(SB) // does not return
701 // traceback from goexit1 must hit code range of goexit
702 NOOP
703
704 // This is called from .init_array and follows the platform, not Go, ABI.
705 TEXT runtime·addmoduledata(SB),NOSPLIT,$0-0
706 ADDV $-0x10, R3
707 MOVV R30, 8(R3) // The access to global variables below implicitly uses R30, which is callee-save
708 MOVV runtime·lastmoduledatap(SB), R12
709 MOVV R4, moduledata_next(R12)
710 MOVV R4, runtime·lastmoduledatap(SB)
711 MOVV 8(R3), R30
712 ADDV $0x10, R3
713 RET
714
715 TEXT ·checkASM(SB),NOSPLIT,$0-1
716 MOVW $1, R19
717 MOVB R19, ret+0(FP)
718 RET
719
720 // spillArgs stores return values from registers to a *internal/abi.RegArgs in R25.
721 TEXT ·spillArgs(SB),NOSPLIT,$0-0
722 MOVV R4, (0*8)(R25)
723 MOVV R5, (1*8)(R25)
724 MOVV R6, (2*8)(R25)
725 MOVV R7, (3*8)(R25)
726 MOVV R8, (4*8)(R25)
727 MOVV R9, (5*8)(R25)
728 MOVV R10, (6*8)(R25)
729 MOVV R11, (7*8)(R25)
730 MOVV R12, (8*8)(R25)
731 MOVV R13, (9*8)(R25)
732 MOVV R14, (10*8)(R25)
733 MOVV R15, (11*8)(R25)
734 MOVV R16, (12*8)(R25)
735 MOVV R17, (13*8)(R25)
736 MOVV R18, (14*8)(R25)
737 MOVV R19, (15*8)(R25)
738 MOVD F0, (16*8)(R25)
739 MOVD F1, (17*8)(R25)
740 MOVD F2, (18*8)(R25)
741 MOVD F3, (19*8)(R25)
742 MOVD F4, (20*8)(R25)
743 MOVD F5, (21*8)(R25)
744 MOVD F6, (22*8)(R25)
745 MOVD F7, (23*8)(R25)
746 MOVD F8, (24*8)(R25)
747 MOVD F9, (25*8)(R25)
748 MOVD F10, (26*8)(R25)
749 MOVD F11, (27*8)(R25)
750 MOVD F12, (28*8)(R25)
751 MOVD F13, (29*8)(R25)
752 MOVD F14, (30*8)(R25)
753 MOVD F15, (31*8)(R25)
754 RET
755
756 // unspillArgs loads args into registers from a *internal/abi.RegArgs in R25.
757 TEXT ·unspillArgs(SB),NOSPLIT,$0-0
758 MOVV (0*8)(R25), R4
759 MOVV (1*8)(R25), R5
760 MOVV (2*8)(R25), R6
761 MOVV (3*8)(R25), R7
762 MOVV (4*8)(R25), R8
763 MOVV (5*8)(R25), R9
764 MOVV (6*8)(R25), R10
765 MOVV (7*8)(R25), R11
766 MOVV (8*8)(R25), R12
767 MOVV (9*8)(R25), R13
768 MOVV (10*8)(R25), R14
769 MOVV (11*8)(R25), R15
770 MOVV (12*8)(R25), R16
771 MOVV (13*8)(R25), R17
772 MOVV (14*8)(R25), R18
773 MOVV (15*8)(R25), R19
774 MOVD (16*8)(R25), F0
775 MOVD (17*8)(R25), F1
776 MOVD (18*8)(R25), F2
777 MOVD (19*8)(R25), F3
778 MOVD (20*8)(R25), F4
779 MOVD (21*8)(R25), F5
780 MOVD (22*8)(R25), F6
781 MOVD (23*8)(R25), F7
782 MOVD (24*8)(R25), F8
783 MOVD (25*8)(R25), F9
784 MOVD (26*8)(R25), F10
785 MOVD (27*8)(R25), F11
786 MOVD (28*8)(R25), F12
787 MOVD (29*8)(R25), F13
788 MOVD (30*8)(R25), F14
789 MOVD (31*8)(R25), F15
790 RET
791
792 // gcWriteBarrier informs the GC about heap pointer writes.
793 //
794 // gcWriteBarrier does NOT follow the Go ABI. It accepts the
795 // number of bytes of buffer needed in R29, and returns a pointer
796 // to the buffer space in R29.
797 // It clobbers R30 (the linker temp register).
798 // The act of CALLing gcWriteBarrier will clobber R1 (LR).
799 // It does not clobber any other general-purpose registers,
800 // but may clobber others (e.g., floating point registers).
801 TEXT gcWriteBarrier<>(SB),NOSPLIT,$216
802 // Save the registers clobbered by the fast path.
803 MOVV R19, 208(R3)
804 MOVV R13, 216(R3)
805 retry:
806 MOVV g_m(g), R19
807 MOVV m_p(R19), R19
808 MOVV (p_wbBuf+wbBuf_next)(R19), R13
809 MOVV (p_wbBuf+wbBuf_end)(R19), R30 // R30 is linker temp register
810 // Increment wbBuf.next position.
811 ADDV R29, R13
812 // Is the buffer full?
813 BLTU R30, R13, flush
814 // Commit to the larger buffer.
815 MOVV R13, (p_wbBuf+wbBuf_next)(R19)
816 // Make return value (the original next position)
817 SUBV R29, R13, R29
818 // Restore registers.
819 MOVV 208(R3), R19
820 MOVV 216(R3), R13
821 RET
822
823 flush:
824 // Save all general purpose registers since these could be
825 // clobbered by wbBufFlush and were not saved by the caller.
826 MOVV R27, 8(R3)
827 MOVV R28, 16(R3)
828 // R1 is LR, which was saved by the prologue.
829 MOVV R2, 24(R3)
830 // R3 is SP.
831 MOVV R4, 32(R3)
832 MOVV R5, 40(R3)
833 MOVV R6, 48(R3)
834 MOVV R7, 56(R3)
835 MOVV R8, 64(R3)
836 MOVV R9, 72(R3)
837 MOVV R10, 80(R3)
838 MOVV R11, 88(R3)
839 MOVV R12, 96(R3)
840 // R13 already saved
841 MOVV R14, 104(R3)
842 MOVV R15, 112(R3)
843 MOVV R16, 120(R3)
844 MOVV R17, 128(R3)
845 MOVV R18, 136(R3)
846 // R19 already saved
847 MOVV R20, 144(R3)
848 MOVV R21, 152(R3)
849 // R22 is g.
850 MOVV R23, 160(R3)
851 MOVV R24, 168(R3)
852 MOVV R25, 176(R3)
853 MOVV R26, 184(R3)
854 // R27 already saved
855 // R28 already saved.
856 MOVV R29, 192(R3)
857 // R30 is tmp register.
858 MOVV R31, 200(R3)
859
860 CALL runtime·wbBufFlush(SB)
861
862 MOVV 8(R3), R27
863 MOVV 16(R3), R28
864 MOVV 24(R3), R2
865 MOVV 32(R3), R4
866 MOVV 40(R3), R5
867 MOVV 48(R3), R6
868 MOVV 56(R3), R7
869 MOVV 64(R3), R8
870 MOVV 72(R3), R9
871 MOVV 80(R3), R10
872 MOVV 88(R3), R11
873 MOVV 96(R3), R12
874 MOVV 104(R3), R14
875 MOVV 112(R3), R15
876 MOVV 120(R3), R16
877 MOVV 128(R3), R17
878 MOVV 136(R3), R18
879 MOVV 144(R3), R20
880 MOVV 152(R3), R21
881 MOVV 160(R3), R23
882 MOVV 168(R3), R24
883 MOVV 176(R3), R25
884 MOVV 184(R3), R26
885 MOVV 192(R3), R29
886 MOVV 200(R3), R31
887 JMP retry
888
889 TEXT runtime·gcWriteBarrier1<ABIInternal>(SB),NOSPLIT,$0
890 MOVV $8, R29
891 JMP gcWriteBarrier<>(SB)
892 TEXT runtime·gcWriteBarrier2<ABIInternal>(SB),NOSPLIT,$0
893 MOVV $16, R29
894 JMP gcWriteBarrier<>(SB)
895 TEXT runtime·gcWriteBarrier3<ABIInternal>(SB),NOSPLIT,$0
896 MOVV $24, R29
897 JMP gcWriteBarrier<>(SB)
898 TEXT runtime·gcWriteBarrier4<ABIInternal>(SB),NOSPLIT,$0
899 MOVV $32, R29
900 JMP gcWriteBarrier<>(SB)
901 TEXT runtime·gcWriteBarrier5<ABIInternal>(SB),NOSPLIT,$0
902 MOVV $40, R29
903 JMP gcWriteBarrier<>(SB)
904 TEXT runtime·gcWriteBarrier6<ABIInternal>(SB),NOSPLIT,$0
905 MOVV $48, R29
906 JMP gcWriteBarrier<>(SB)
907 TEXT runtime·gcWriteBarrier7<ABIInternal>(SB),NOSPLIT,$0
908 MOVV $56, R29
909 JMP gcWriteBarrier<>(SB)
910 TEXT runtime·gcWriteBarrier8<ABIInternal>(SB),NOSPLIT,$0
911 MOVV $64, R29
912 JMP gcWriteBarrier<>(SB)
913
914 DATA debugCallFrameTooLarge<>+0x00(SB)/20, $"call frame too large"
915 GLOBL debugCallFrameTooLarge<>(SB), RODATA, $20 // Size duplicated below
916
917 // debugCallV2 is the entry point for debugger-injected function
918 // calls on running goroutines. It informs the runtime that a
919 // debug call has been injected and creates a call frame for the
920 // debugger to fill in.
921 //
922 // To inject a function call, a debugger should:
923 // 1. Check that the goroutine is in state _Grunning and that
924 // there are at least 280 bytes free on the stack.
925 // 2. Set SP as SP-8.
926 // 3. Store the current LR in (SP) (using the SP after step 2).
927 // 4. Store the current PC in the LR register.
928 // 5. Write the desired argument frame size at SP-8
929 // 6. Save all machine registers so they can be restored later by the debugger.
930 // 7. Set the PC to debugCallV2 and resume execution.
931 //
932 // If the goroutine is in state _Grunnable, then it's not generally
933 // safe to inject a call because it may return out via other runtime
934 // operations. Instead, the debugger should unwind the stack to find
935 // the return to non-runtime code, add a temporary breakpoint there,
936 // and inject the call once that breakpoint is hit.
937 //
938 // If the goroutine is in any other state, it's not safe to inject a call.
939 //
940 // This function communicates back to the debugger by setting R19 and
941 // invoking BREAK to raise a breakpoint signal. Note that the signal PC of
942 // the signal triggered by the BREAK instruction is the PC where the signal
943 // is trapped, not the next PC, so to resume execution, the debugger needs
944 // to set the signal PC to PC+4. See the comments in the implementation for
945 // the protocol the debugger is expected to follow. InjectDebugCall in the
946 // runtime tests demonstrates this protocol.
947 //
948 // The debugger must ensure that any pointers passed to the function
949 // obey escape analysis requirements. Specifically, it must not pass
950 // a stack pointer to an escaping argument. debugCallV2 cannot check
951 // this invariant.
952 //
953 // This is ABIInternal because Go code injects its PC directly into new
954 // goroutine stacks.
955 TEXT runtime·debugCallV2<ABIInternal>(SB),NOSPLIT|NOFRAME,$0-0
956 MOVV R1, -272(R3)
957 ADDV $-272, R3
958
959 // We can't do anything that might clobber any of these
960 // registers before this.
961 MOVV R2, (4*8)(R3)
962 MOVV R4, (5*8)(R3)
963 MOVV R5, (6*8)(R3)
964 MOVV R6, (7*8)(R3)
965 MOVV R7, (8*8)(R3)
966 MOVV R8, (9*8)(R3)
967 MOVV R9, (10*8)(R3)
968 MOVV R10, (11*8)(R3)
969 MOVV R11, (12*8)(R3)
970 MOVV R12, (13*8)(R3)
971 MOVV R13, (14*8)(R3)
972 MOVV R14, (15*8)(R3)
973 MOVV R15, (16*8)(R3)
974 MOVV R16, (17*8)(R3)
975 MOVV R17, (18*8)(R3)
976 MOVV R18, (19*8)(R3)
977 MOVV R19, (20*8)(R3)
978 MOVV R20, (21*8)(R3)
979 MOVV R21, (22*8)(R3)
980 MOVV g, (23*8)(R3)
981 MOVV R23, (24*8)(R3)
982 MOVV R24, (25*8)(R3)
983 MOVV R25, (26*8)(R3)
984 MOVV R26, (27*8)(R3)
985 MOVV R27, (28*8)(R3)
986 MOVV R28, (29*8)(R3)
987 MOVV R29, (30*8)(R3)
988 MOVV R30, (31*8)(R3)
989 MOVV R31, (32*8)(R3)
990
991 // Perform a safe-point check.
992 MOVV R1, 8(R3)
993 CALL runtime·debugCallCheck(SB)
994 MOVV 16(R3), R30
995 BEQ R30, good
996
997 // The safety check failed. Put the reason string at the top
998 // of the stack.
999 MOVV R30, 8(R3)
1000
1001 MOVV 24(R3), R30
1002 MOVV R30, 16(R3)
1003
1004 MOVV $8, R19
1005 BREAK
1006 JMP restore
1007
1008 good:
1009 // Registers are saved and it's safe to make a call.
1010 // Open up a call frame, moving the stack if necessary.
1011 //
1012 // Once the frame is allocated, this will set R19 to 0 and
1013 // invoke BREAK. The debugger should write the argument
1014 // frame for the call at SP+8, set up argument registers,
1015 // set the LR as the signal PC + 4, set the PC to the function
1016 // to call, set R29 to point to the closure (if a closure call),
1017 // and resume execution.
1018 //
1019 // If the function returns, this will set R19 to 1 and invoke
1020 // BREAK. The debugger can then inspect any return value saved
1021 // on the stack at SP+8 and in registers. To resume execution,
1022 // the debugger should restore the LR from (SP).
1023 //
1024 // If the function panics, this will set R19 to 2 and invoke BREAK.
1025 // The interface{} value of the panic will be at SP+8. The debugger
1026 // can inspect the panic value and resume execution again.
1027 #define DEBUG_CALL_DISPATCH(NAME,MAXSIZE) \
1028 MOVV $MAXSIZE, R27; \
1029 BLT R27, R30, 5(PC); \
1030 MOVV $NAME(SB), R28; \
1031 MOVV R28, 8(R3); \
1032 CALL runtime·debugCallWrap(SB); \
1033 JMP restore
1034
1035 MOVV 264(R3), R30 // the argument frame size
1036 DEBUG_CALL_DISPATCH(debugCall32<>, 32)
1037 DEBUG_CALL_DISPATCH(debugCall64<>, 64)
1038 DEBUG_CALL_DISPATCH(debugCall128<>, 128)
1039 DEBUG_CALL_DISPATCH(debugCall256<>, 256)
1040 DEBUG_CALL_DISPATCH(debugCall512<>, 512)
1041 DEBUG_CALL_DISPATCH(debugCall1024<>, 1024)
1042 DEBUG_CALL_DISPATCH(debugCall2048<>, 2048)
1043 DEBUG_CALL_DISPATCH(debugCall4096<>, 4096)
1044 DEBUG_CALL_DISPATCH(debugCall8192<>, 8192)
1045 DEBUG_CALL_DISPATCH(debugCall16384<>, 16384)
1046 DEBUG_CALL_DISPATCH(debugCall32768<>, 32768)
1047 DEBUG_CALL_DISPATCH(debugCall65536<>, 65536)
1048 // The frame size is too large. Report the error.
1049 MOVV $debugCallFrameTooLarge<>(SB), R30
1050 MOVV R30, 8(R3)
1051 MOVV $20, R30
1052 MOVV R30, 16(R3) // length of debugCallFrameTooLarge string
1053 MOVV $8, R19
1054 BREAK
1055 JMP restore
1056
1057 restore:
1058 // Calls and failures resume here.
1059 //
1060 // Set R19 to 16 and invoke BREAK. The debugger should restore
1061 // all registers except for PC and SP and resume execution.
1062 MOVV $16, R19
1063 BREAK
1064 // We must not modify flags after this point.
1065
1066 // Restore pointer-containing registers, which may have been
1067 // modified from the debugger's copy by stack copying.
1068 MOVV (4*8)(R3), R2
1069 MOVV (5*8)(R3), R4
1070 MOVV (6*8)(R3), R5
1071 MOVV (7*8)(R3), R6
1072 MOVV (8*8)(R3), R7
1073 MOVV (9*8)(R3), R8
1074 MOVV (10*8)(R3), R9
1075 MOVV (11*8)(R3), R10
1076 MOVV (12*8)(R3), R11
1077 MOVV (13*8)(R3), R12
1078 MOVV (14*8)(R3), R13
1079 MOVV (15*8)(R3), R14
1080 MOVV (16*8)(R3), R15
1081 MOVV (17*8)(R3), R16
1082 MOVV (18*8)(R3), R17
1083 MOVV (19*8)(R3), R18
1084 MOVV (20*8)(R3), R19
1085 MOVV (21*8)(R3), R20
1086 MOVV (22*8)(R3), R21
1087 MOVV (23*8)(R3), g
1088 MOVV (24*8)(R3), R23
1089 MOVV (25*8)(R3), R24
1090 MOVV (26*8)(R3), R25
1091 MOVV (27*8)(R3), R26
1092 MOVV (28*8)(R3), R27
1093 MOVV (29*8)(R3), R28
1094 MOVV (30*8)(R3), R29
1095 MOVV (31*8)(R3), R30
1096 MOVV (32*8)(R3), R31
1097
1098 MOVV 0(R3), R30
1099 ADDV $280, R3 // Add 8 more bytes, see saveSigContext
1100 MOVV -8(R3), R1
1101 JMP (R30)
1102
1103 // runtime.debugCallCheck assumes that functions defined with the
1104 // DEBUG_CALL_FN macro are safe points to inject calls.
1105 #define DEBUG_CALL_FN(NAME,MAXSIZE) \
1106 TEXT NAME(SB),WRAPPER,$MAXSIZE-0; \
1107 NO_LOCAL_POINTERS; \
1108 MOVV $0, R19; \
1109 BREAK; \
1110 MOVV $1, R19; \
1111 BREAK; \
1112 RET
1113 DEBUG_CALL_FN(debugCall32<>, 32)
1114 DEBUG_CALL_FN(debugCall64<>, 64)
1115 DEBUG_CALL_FN(debugCall128<>, 128)
1116 DEBUG_CALL_FN(debugCall256<>, 256)
1117 DEBUG_CALL_FN(debugCall512<>, 512)
1118 DEBUG_CALL_FN(debugCall1024<>, 1024)
1119 DEBUG_CALL_FN(debugCall2048<>, 2048)
1120 DEBUG_CALL_FN(debugCall4096<>, 4096)
1121 DEBUG_CALL_FN(debugCall8192<>, 8192)
1122 DEBUG_CALL_FN(debugCall16384<>, 16384)
1123 DEBUG_CALL_FN(debugCall32768<>, 32768)
1124 DEBUG_CALL_FN(debugCall65536<>, 65536)
1125
1126 // func debugCallPanicked(val interface{})
1127 TEXT runtime·debugCallPanicked(SB),NOSPLIT,$16-16
1128 // Copy the panic value to the top of stack at SP+8.
1129 MOVV val_type+0(FP), R30
1130 MOVV R30, 8(R3)
1131 MOVV val_data+8(FP), R30
1132 MOVV R30, 16(R3)
1133 MOVV $2, R19
1134 BREAK
1135 RET
1136
1137 // Note: these functions use a special calling convention to save generated code space.
1138 // Arguments are passed in registers, but the space for those arguments are allocated
1139 // in the caller's stack frame. These stubs write the args into that stack space and
1140 // then tail call to the corresponding runtime handler.
1141 // The tail call makes these stubs disappear in backtraces.
1142 TEXT runtime·panicIndex<ABIInternal>(SB),NOSPLIT,$0-16
1143 MOVV R20, R4
1144 MOVV R21, R5
1145 JMP runtime·goPanicIndex<ABIInternal>(SB)
1146 TEXT runtime·panicIndexU<ABIInternal>(SB),NOSPLIT,$0-16
1147 MOVV R20, R4
1148 MOVV R21, R5
1149 JMP runtime·goPanicIndexU<ABIInternal>(SB)
1150 TEXT runtime·panicSliceAlen<ABIInternal>(SB),NOSPLIT,$0-16
1151 MOVV R21, R4
1152 MOVV R23, R5
1153 JMP runtime·goPanicSliceAlen<ABIInternal>(SB)
1154 TEXT runtime·panicSliceAlenU<ABIInternal>(SB),NOSPLIT,$0-16
1155 MOVV R21, R4
1156 MOVV R23, R5
1157 JMP runtime·goPanicSliceAlenU<ABIInternal>(SB)
1158 TEXT runtime·panicSliceAcap<ABIInternal>(SB),NOSPLIT,$0-16
1159 MOVV R21, R4
1160 MOVV R23, R5
1161 JMP runtime·goPanicSliceAcap<ABIInternal>(SB)
1162 TEXT runtime·panicSliceAcapU<ABIInternal>(SB),NOSPLIT,$0-16
1163 MOVV R21, R4
1164 MOVV R23, R5
1165 JMP runtime·goPanicSliceAcapU<ABIInternal>(SB)
1166 TEXT runtime·panicSliceB<ABIInternal>(SB),NOSPLIT,$0-16
1167 MOVV R20, R4
1168 MOVV R21, R5
1169 JMP runtime·goPanicSliceB<ABIInternal>(SB)
1170 TEXT runtime·panicSliceBU<ABIInternal>(SB),NOSPLIT,$0-16
1171 MOVV R20, R4
1172 MOVV R21, R5
1173 JMP runtime·goPanicSliceBU<ABIInternal>(SB)
1174 TEXT runtime·panicSlice3Alen<ABIInternal>(SB),NOSPLIT,$0-16
1175 MOVV R23, R4
1176 MOVV R24, R5
1177 JMP runtime·goPanicSlice3Alen<ABIInternal>(SB)
1178 TEXT runtime·panicSlice3AlenU<ABIInternal>(SB),NOSPLIT,$0-16
1179 MOVV R23, R4
1180 MOVV R24, R5
1181 JMP runtime·goPanicSlice3AlenU<ABIInternal>(SB)
1182 TEXT runtime·panicSlice3Acap<ABIInternal>(SB),NOSPLIT,$0-16
1183 MOVV R23, R4
1184 MOVV R24, R5
1185 JMP runtime·goPanicSlice3Acap<ABIInternal>(SB)
1186 TEXT runtime·panicSlice3AcapU<ABIInternal>(SB),NOSPLIT,$0-16
1187 MOVV R23, R4
1188 MOVV R24, R5
1189 JMP runtime·goPanicSlice3AcapU<ABIInternal>(SB)
1190 TEXT runtime·panicSlice3B<ABIInternal>(SB),NOSPLIT,$0-16
1191 MOVV R21, R4
1192 MOVV R23, R5
1193 JMP runtime·goPanicSlice3B<ABIInternal>(SB)
1194 TEXT runtime·panicSlice3BU<ABIInternal>(SB),NOSPLIT,$0-16
1195 MOVV R21, R4
1196 MOVV R23, R5
1197 JMP runtime·goPanicSlice3BU<ABIInternal>(SB)
1198 TEXT runtime·panicSlice3C<ABIInternal>(SB),NOSPLIT,$0-16
1199 MOVV R20, R4
1200 MOVV R21, R5
1201 JMP runtime·goPanicSlice3C<ABIInternal>(SB)
1202 TEXT runtime·panicSlice3CU<ABIInternal>(SB),NOSPLIT,$0-16
1203 MOVV R20, R4
1204 MOVV R21, R5
1205 JMP runtime·goPanicSlice3CU<ABIInternal>(SB)
1206 TEXT runtime·panicSliceConvert<ABIInternal>(SB),NOSPLIT,$0-16
1207 MOVV R23, R4
1208 MOVV R24, R5
1209 JMP runtime·goPanicSliceConvert<ABIInternal>(SB)
1210
View as plain text