src/runtime/export_debug_ppc64le_test.go

   1 // Copyright 2023 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 //go:build ppc64le && linux
   6
   7 package runtime
   8
   9 import (
  10         "internal/abi"
  11         "internal/goarch"
  12         "math"
  13         "unsafe"
  14 )
  15
  16 type sigContext struct {
  17         savedRegs sigcontext
  18 }
  19
  20 func sigctxtSetContextRegister(ctxt *sigctxt, x uint64) {
  21         ctxt.regs().gpr[11] = x
  22 }
  23
  24 func sigctxtAtTrapInstruction(ctxt *sigctxt) bool {
  25         return *(*uint32)(unsafe.Pointer(ctxt.sigpc())) == 0x7fe00008 // Trap
  26 }
  27
  28 func sigctxtStatus(ctxt *sigctxt) uint64 {
  29         return ctxt.r20()
  30 }
  31
  32 func (h *debugCallHandler) saveSigContext(ctxt *sigctxt) {
  33         sp := ctxt.sp()
  34         sp -= 4 * goarch.PtrSize
  35         ctxt.set_sp(sp)
  36         *(*uint64)(unsafe.Pointer(uintptr(sp))) = ctxt.link() // save the current lr
  37         ctxt.set_link(ctxt.pc())                              // set new lr to the current pc
  38         // Write the argument frame size.
  39         *(*uintptr)(unsafe.Pointer(uintptr(sp - 32))) = h.argSize
  40         // Save current registers.
  41         h.sigCtxt.savedRegs = *ctxt.cregs()
  42 }
  43
  44 // case 0
  45 func (h *debugCallHandler) debugCallRun(ctxt *sigctxt) {
  46         sp := ctxt.sp()
  47         memmove(unsafe.Pointer(uintptr(sp)+32), h.argp, h.argSize)
  48         if h.regArgs != nil {
  49                 storeRegArgs(ctxt.cregs(), h.regArgs)
  50         }
  51         // Push return PC, which should be the signal PC+4, because
  52         // the signal PC is the PC of the trap instruction itself.
  53         ctxt.set_link(ctxt.pc() + 4)
  54         // Set PC to call and context register.
  55         ctxt.set_pc(uint64(h.fv.fn))
  56         sigctxtSetContextRegister(ctxt, uint64(uintptr(unsafe.Pointer(h.fv))))
  57 }
  58
  59 // case 1
  60 func (h *debugCallHandler) debugCallReturn(ctxt *sigctxt) {
  61         sp := ctxt.sp()
  62         memmove(h.argp, unsafe.Pointer(uintptr(sp)+32), h.argSize)
  63         if h.regArgs != nil {
  64                 loadRegArgs(h.regArgs, ctxt.cregs())
  65         }
  66         // Restore the old lr from *sp
  67         olr := *(*uint64)(unsafe.Pointer(uintptr(sp)))
  68         ctxt.set_link(olr)
  69         pc := ctxt.pc()
  70         ctxt.set_pc(pc + 4) // step to next instruction
  71 }
  72
  73 // case 2
  74 func (h *debugCallHandler) debugCallPanicOut(ctxt *sigctxt) {
  75         sp := ctxt.sp()
  76         memmove(unsafe.Pointer(&h.panic), unsafe.Pointer(uintptr(sp)+32), 2*goarch.PtrSize)
  77         ctxt.set_pc(ctxt.pc() + 4)
  78 }
  79
  80 // case 8
  81 func (h *debugCallHandler) debugCallUnsafe(ctxt *sigctxt) {
  82         sp := ctxt.sp()
  83         reason := *(*string)(unsafe.Pointer(uintptr(sp) + 40))
  84         h.err = plainError(reason)
  85         ctxt.set_pc(ctxt.pc() + 4)
  86 }
  87
  88 // case 16
  89 func (h *debugCallHandler) restoreSigContext(ctxt *sigctxt) {
  90         // Restore all registers except for pc and sp
  91         pc, sp := ctxt.pc(), ctxt.sp()
  92         *ctxt.cregs() = h.sigCtxt.savedRegs
  93         ctxt.set_pc(pc + 4)
  94         ctxt.set_sp(sp)
  95 }
  96
  97 // storeRegArgs sets up argument registers in the signal
  98 // context state from an abi.RegArgs.
  99 //
 100 // Both src and dst must be non-nil.
 101 func storeRegArgs(dst *sigcontext, src *abi.RegArgs) {
 102         // Gprs R3..R10, R14..R17 are used to pass int arguments in registers on PPC64
 103         for i := 0; i < 12; i++ {
 104                 if i > 7 {
 105                         dst.gp_regs[i+6] = uint64(src.Ints[i])
 106                 } else {
 107                         dst.gp_regs[i+3] = uint64(src.Ints[i])
 108                 }
 109         }
 110         // Fprs F1..F13 are used to pass float arguments in registers on PPC64
 111         for i := 0; i < 12; i++ {
 112                 dst.fp_regs[i+1] = math.Float64frombits(src.Floats[i])
 113         }
 114
 115 }
 116
 117 func loadRegArgs(dst *abi.RegArgs, src *sigcontext) {
 118         // Gprs R3..R10, R14..R17 are used to pass int arguments in registers on PPC64
 119         for i, _ := range [12]int{} {
 120                 if i > 7 {
 121                         dst.Ints[i] = uintptr(src.gp_regs[i+6])
 122                 } else {
 123                         dst.Ints[i] = uintptr(src.gp_regs[i+3])
 124                 }
 125         }
 126         // Fprs F1..F13 are used to pass float arguments in registers on PPC64
 127         for i, _ := range [12]int{} {
 128                 dst.Floats[i] = math.Float64bits(src.fp_regs[i+1])
 129         }
 130
 131 }