Go 汇编详解

// func Get() int64
TEXT ·Get(SB),NOSPLIT,$0-8
    MOVQ (TLS), R14
    MOVQ g_goid(R14), R13
    MOVQ R13, ret+0(FP)
    RET

TEXT github.com/petermattis/goid.Get.abi0(SB) /Users/bytedance/go/pkg/mod/github.com/petermattis/goid@v0.0.0-20221215004737-a150e88a970d/goid_go1.5_amd64.s
  goid_go1.5_amd64.s:28 0x108adc0   654c8b342530000000  MOVQ GS:0x30, R14 
  goid_go1.5_amd64.s:29 0x108adc9   4d8bae98000000    MOVQ 0x98(R14), R13 
  goid_go1.5_amd64.s:30 0x108add0   4c896c2408    MOVQ R13, 0x8(SP) 
  goid_go1.5_amd64.s:31 0x108add5   c3      RET

高地址 +------------------+
        |                  |
        |     内核空间      |
        |                  |
        --------------------
        |                  |
        |       栈         |
        |                  |
        --------------------
        |                  |
        |     .......      |
        |                  |
        --------------------
        |                  |
        |       堆         |
        |                  |
        --------------------
        |     全局数据      |
        |------------------|
        |                  |
        |     静态代码      |
        |                  |
        |------------------|
        |     系统保留      |
  低地址 |------------------|

caller                                                                                 
                                 +------------------+                                                                         
                                 |                  |                                                                         
       +---------------------->  +------------------+                                                                        
       |                         |                  |                                                                         
       |                         | caller parent BP |                                                                         
       |           BP(pseudo SP) +------------------+                                                                         
       |                         |                  |                                                                         
       |                         |   Local Var0     |                                                                         
       |                         +------------------+                                                                         
       |                         |                  |                                                                         
       |                         |   .......        |                                                                         
       |                         +------------------+                                                                         
       |                         |                  |                                                                         
       |                         |   Local VarN     |                                                                         
                                 +------------------+                                                                         
 caller stack frame              |                  |                                                                         
                                 |   callee arg2    |                                                                         
       |                         +------------------+                                                                         
       |                         |                  |                                                                         
       |                         |   callee arg1    |                                                                         
       |                         +------------------+                                                                         
       |                         |                  |                                                                         
       |                         |   callee arg0    |                                                                         
       |   SP(Real Register) ->  +------------------+--------------------------+   FP(virtual register)                       
       |                         |                  |                          |                                              
       |                         |   return addr    |  parent return address   |                                              
       +---------------------->  +------------------+--------------------------+    <-----------------------+         
                                                    |  caller BP               |                            |         
                                                    |  (caller frame pointer)  |                            |         
                                     BP(pseudo SP)  +--------------------------+                            |         
                                                    |                          |                            |         
                                                    |     Local Var0           |                            |         
                                                    +--------------------------+                            |         
                                                    |                          |                                      
                                                    |     Local Var1           |                                      
                                                    +--------------------------+                    callee stack frame
                                                    |                          |                                      
                                                    |       .....              |                                      
                                                    +--------------------------+                            |         
                                                    |                          |                            |         
                                                    |     Local VarN           |                            |         
     High                         SP(Real Register) +--------------------------+                            |         
      ^                                             |                          |                            |         
      |                                             |                          |                            |         
      |                                             |                          |                            |         
      |                                             |                          |                            |         
      |                                             |                          |                            |         
      |                                             +--------------------------+    <-----------------------+         
     Low                                                                                                                      
                                                              callee

// Must agree with internal/buildcfg.FramePointerEnabled.
const framepointer_enabled = GOARCH == "amd64" || GOARCH == "arm64"

// For architectures with frame pointers, if there's
  // a frame, then there's a saved frame pointer here.
  //
  // NOTE: This code is not as general as it looks.
  // On x86, the ABI is to save the frame pointer word at the
  // top of the stack frame, so we have to back down over it.
  // On arm64, the frame pointer should be at the bottom of
  // the stack (with R29 (aka FP) = RSP), in which case we would
  // not want to do the subtraction here. But we started out without
  // any frame pointer, and when we wanted to add it, we didn't
  // want to break all the assembly doing direct writes to 8(RSP)
  // to set the first parameter to a called function.
  // So we decided to write the FP link *below* the stack pointer
  // (with R29 = RSP - 8 in Go functions).
  // This is technically ABI-compatible but not standard.
  // And it happens to end up mimicking the x86 layout.
  // Other architectures may make different decisions.
  if frame.varp > frame.sp && framepointer_enabled {
    frame.varp -= goarch.PtrSize
  }

// Must agree with internal/buildcfg.FramePointerEnabled.
const framepointer_enabled = GOARCH == "amd64" || GOARCH == "arm64"

MOVB $1, DI     // 1 byte； 将 DI 的第一个 Byte 的值设置为 1
MOVW $0x10, BX  // 2bytes
MOVD $1, DX     // 4 bytes
MOVQ $-10, AX   // 8 bytes
SUBQ $0x18, SP  //对SP做减法，扩栈
ADDQ $0x18, SP  //对SP做加法，缩栈
ADDQ AX, BX     // BX += AX
SUBQ AX, BX     // BX -= AX
IMULQ AX, BX    // BX *= AX
JMP addr        // 跳转到地址，地址可为代码中的地址，不过实际上手写一般不会出现
JMP label       // 跳转到标签，可以跳转到同一函数内的标签位置
JMP 2(PC)       // 向前转2行
JMP -2(PC)      // 向后跳转2行
JNZ target      // 如果zero flag被set过，则跳转

// DATA 汇编指令指定对应内存中的值; width 必须是 1、2、4、8 几个宽度之一
DATA    symbol+offset(SB)/width, value // symbol+offset 偏移量，width 宽度, value 初始值

// GLOBL 指令声明一个变量对应的符号，以及变量对应的内存大小
GLOBL symbol(SB), flag, width  // 名为 symbol, 内存宽度为 width, flag可省略

DATA age+0x00(SB)/4, $18    // age = 18
GLOBL age(SB), RODATA, $4   // 声明全局变量 age，占用 4Byte 内存空间

DATA pi+0(SB)/8, $3.1415926
GLOBL pi(SB), RODATA, $8

DATA bio<>+0(SB)/8, $"hello wo"     // <> 表示只在当前文件生效
DATA bio<>+8(SB)/8, $"old !!!!"     // bio = "hello world !!!!"
GLOBL bio<>(SB), RODATA, $16

//go:nosplit
func someFunc() {
}

// 表示someFunc函数执行时最多需要 24 字节本地变量和 8 字节参数空间
TEXT ·someFunc(SB), NOSPLIT, $24-8  
    RET

nosplit functions
Most functions start with a prologue that inspects the stack pointer and the current G's stack bound and calls morestack if the stack needs to grow.

Functions can be marked //go:nosplit (or NOSPLIT in assembly) to indicate that they should not get this prologue. This has several uses:

 - Functions that must run on the user stack, but must not call into stack growth, for example because this would cause a deadlock, or because they have untyped words on the stack.
 - Functions that must not be preempted on entry.
 - Functions that may run without a valid G. For example, functions that run in early runtime start-up, or that may be entered from C code such as cgo callbacks or the signal handler.

Splittable functions ensure there's some amount of space on the stack for nosplit functions to run in and the linker checks that any static chain of nosplit function calls cannot exceed this bound.

Any function with a //go:nosplit annotation should explain why it is nosplit in its documentation comment.

//const StackSmall  = 128
    if ctxt.Arch.Family == sys.AMD64 && autoffset < objabi.StackSmall && !p.From.Sym.NoSplit() {
        leaf := true
    LeafSearch:
        for q := p; q != nil; q = q.Link {
            switch q.As {
            case obj.ACALL:
                // Treat common runtime calls that take no arguments
                // the same as duffcopy and duffzero.
                if !isZeroArgRuntimeCall(q.To.Sym) {
                    leaf = false
                    break LeafSearch
                }
                fallthrough
            case obj.ADUFFCOPY, obj.ADUFFZERO:
                if autoffset >= objabi.StackSmall-8 {
                    leaf = false
                    break LeafSearch
                }
            }
        }

        if leaf {
            p.From.Sym.Set(obj.AttrNoSplit, true)
        }
    }

#include "textflag.h"

TEXT ·get(SB), NOSPLIT, $0-8
    MOVQ ·a(SB), AX             // 把 go 代码定义的全局变量读到 AX 中
    MOVQ AX, ret+0(FP)          // 把 AX 的值写入返回值位置
    RET

package main

var a = 999

func get() intfunc main() {
    println(get())
}

// string 定义形式 1： 在 String 结构体后多分配一个 [n]byte 数组存放静态字符串
DATA ·Name+0(SB)/8,$·Name+16(SB)    // StringHeader.Data
DATA ·Name+8(SB)/8,$6               // StringHeader.Len
DATA ·Name+16(SB)/8,$"gopher"       // [6]byte{'g','o','p','h','e','r'}
GLOBL ·Name(SB),NOPTR,$24           // struct{Data uintptr, Len int, str [6]byte}

// string 定义形式 2：独立分配一个仅当前文件可见的 [n]byte 数组存放静态字符串
DATA str<>+0(SB)/8,$"Hello Wo"      // str[0:8]={'H','e','l','l','o',' ','W','o'}
DATA str<>+8(SB)/8,$"rld!"          // str[9:12]={'r','l','d','!''}
GLOBL str<>(SB),NOPTR,$16           // 定义全局数组 var str<> [16]byte
DATA ·Helloworld+0(SB)/8,$str<>(SB) // StringHeader.Data = &str<>
DATA ·Helloworld+8(SB)/8,$12        // StringHeader.Len = 12
GLOBL ·Helloworld(SB),NOPTR,$16     // struct{Data uintptr, Len int}

var Name,Helloworld string
func doSth() {
    fmt.Printf("Name: %s\n", Name)               // 读取汇编中初始化的变量 Name
    fmt.Printf("Helloworld: %s\n", Helloworld)   // 读取汇编中初始化的变量 Helloworld
}
// 输出： 
// Name: gopher
// Helloworld: Hello World!

告诉汇编器该数据放到TEXT区
  ^                        静态基地址指针(告诉汇编器这是基于静态地址的数据)
  |                                ^    
  |                                |   标签   函数入参+返回值占用空间大小
  |                                |    ^      ^
  |                                |    |      |
TEXT pkgname·funcname<ABIInternal>(SB),TAG,$16-24
     ^         ^        ^                   ^
     |         |        |                   |
函数所属包名  函数名  表示ABI类型           函数栈帧大小(本地变量占用空间大小)

go tool compile -S xxx.go
go build -gcflags -S xxx.go

go tool objdump -s "main.main" main.out > main.S

// add.go
package main
import "fmt"

func add(x, y int64) int64

func main() {
    fmt.Println(add(2, 3))
}

// add_amd64.s
// add(x,y) -> x+y
TEXT ·add(SB),NOSPLIT,$0
    MOVQ x+0(FP), BX
    MOVQ y+8(FP), BP
    ADDQ BP, BX
    MOVQ BX, ret+16(FP)
    RET

package main
import "fmt"

func add(x, y int) int {
    return x + y
}

func output(a, b int) int

func main() {
    s := output(10, 13)
    fmt.Println(s)
}

#include "textflag.h"

// func output(a,b int) int
TEXT ·output(SB), NOSPLIT, $24-24
    MOVQ a+0(FP), DX    // arg a
    MOVQ DX, 0(SP)      // arg x
    MOVQ b+8(FP), CX    // arg b
    MOVQ CX, 8(SP)      // arg y
    CALL ·add(SB)       // 在调用 add 之前，已经把参数都通过物理寄存器 SP 搬到了函数的栈顶
    MOVQ 16(SP), AX     // add 函数会把返回值放在这个位置
    MOVQ AX, ret+16(FP) // return result
    RET

//go:build (darwin || freebsd || netbsd || openbsd) && gc
// +build darwin freebsd netbsd openbsd
// +build gc

//go:build linux && (386 || amd64 || arm || arm64 || mips64 || mips64le || ppc64 || ppc64le)
//go:build linux && (mips64 || mips64le)
//go:build linux && (ppc64 || ppc64le)
//go:build linux && !386 && !arm

package main
import _ "fmt"

func Print(delta string)

func main() {
   Print("hello")
}

#include "textflag.h"
TEXT ·Print(SB), NOSPLIT, $8
    CALL fmt·Println(SB)
    RET

package main
import ( 
  "fmt"
)
//go:linkname Println fmt.Println
func Println(a ...any) (n int, err error)

func Print(delta interface{})func main() { 
  Print("hello")
}

#include "textflag.h"
TEXT ·Print(SB), NOSPLIT, $48-16   
  LEAQ strp+0(FP),AX
  MOVQ AX, 0(SP)        // []interface{} slice 的 pointer
  MOVQ $1, BX    
  MOVQ BX, 8(SP)        // slice 的 len
  MOVQ BX, 16(SP)       // slice 的 cap
  CALL fmt·Println(SB)  // //go:linkname 为 fmt.Println 生成一个 ABI0 包装后，汇编可以直接调用
  RET

// Escape analysis.
//
// Here we analyze functions to determine which Go variables
// (including implicit allocations such as calls to "new" or "make",
// composite literals, etc.) can be allocated on the stack. The two
// key invariants we have to ensure are: (1) pointers to stack objects
// cannot be stored in the heap, and (2) pointers to a stack object
// cannot outlive that object (e.g., because the declaring function
// returned and destroyed the object's stack frame, or its space is
// reused across loop iterations for logically distinct variables).
//

if newsize > maxstacksize || newsize > maxstackceiling {
    if maxstacksize < maxstackceiling {
        print("runtime: goroutine stack exceeds ", maxstacksize, "-byte limit\n")
    } else {
        print("runtime: goroutine stack exceeds ", maxstackceiling, "-byte limit\n")
    }
    print("runtime: sp=", hex(sp), " stack=[", hex(gp.stack.lo), ", ", hex(gp.stack.hi), "]\n")
    throw("stack overflow")
}

go build -gcflags="-m" main.go
# 输出结果：
# ./op.go:3:6: can inline add
# ./op.go:7:6: can inline sub
# ./main.go:16:11: inlining call to sub
# ./main.go:14:11: inlining call to add
# ./main.go:7:12: inlining call to fmt.Printf

go build -gcflags="-m -m" main.go

# command-line-arguments
./main.go:10:6: cannot inline main: function too complex: cost 106 exceeds budget 80
./main.go:20:12: inlining call to fmt.Printf
./main.go:23:6: can inline toEface with cost 0 as: func() {  }
./main.go:18:2: shlx escapes to heap:
./main.go:18:2:   flow: i = &{storage for shlx}:
./main.go:18:2:     from shlx (spill) at ./main.go:18:2
./main.go:18:2:     from i = shlx (assign) at ./main.go:18:4
./main.go:18:2:   flow: {storage for ... argument} = i:
./main.go:18:2:     from ... argument (slice-literal-element) at ./main.go:20:12
./main.go:18:2:   flow: fmt.a = &{storage for ... argument}:
./main.go:18:2:     from ... argument (spill) at ./main.go:20:12
./main.go:18:2:     from fmt.format, fmt.a := "%+v", ... argument (assign-pair) at ./main.go:20:12
./main.go:18:2:   flow: {heap} = *fmt.a:
./main.go:18:2:     from fmt.Fprintf(io.Writer(os.Stdout), fmt.format, fmt.a...) (call parameter) at ./main.go:20:12
./main.go:17:2: x escapes to heap:
./main.go:17:2:   flow: i = &{storage for x}:
./main.go:17:2:     from x (spill) at ./main.go:17:2
./main.go:17:2:     from i = x (assign) at ./main.go:17:4
./main.go:17:2:   flow: {storage for ... argument} = i:
./main.go:17:2:     from ... argument (slice-literal-element) at ./main.go:20:12
./main.go:17:2:   flow: fmt.a = &{storage for ... argument}:
./main.go:17:2:     from ... argument (spill) at ./main.go:20:12
./main.go:17:2:     from fmt.format, fmt.a := "%+v", ... argument (assign-pair) at ./main.go:20:12
./main.go:17:2:   flow: {heap} = *fmt.a:
./main.go:17:2:     from fmt.Fprintf(io.Writer(os.Stdout), fmt.format, fmt.a...) (call parameter) at ./main.go:20:12
./main.go:17:2: x escapes to heap
./main.go:18:2: shlx escapes to heap
./main.go:20:12: ... argument does not escape

// 3.1: var closure = NewClosure()
func main() {
    // 3.2: var closure func() int
    var closure = NewClosure()
    closure()
    // 3.3: closure = NewClosure()
    closure()
}

func NewClosure() func() int {
    i := 0return func() int {
        i++
        return i
    }
}

./main.go:19:6: can inline NewClosure
./main.go:21:9: can inline NewClosure.func1
./main.go:13:26: inlining call to NewClosure
./main.go:21:9: can inline main.func1
./main.go:14:9: inlining call to main.func1
./main.go:16:9: inlining call to main.func1
./main.go:13:26: func literal does not escape
./main.go:20:2: moved to heap: i
./main.go:21:9: func literal escapes to heap

./main.go:20:2: moved to heap: i
./main.go:21:9: func literal escapes to heap

//go:noinline
func maxNoinline(a, b int) int {
    if a < b {
        return b
    }
    return a
}

func maxInline(a, b int) int {
    if a < b {
        return b
    }
    return a
}

func BenchmarkInline(b *testing.B) {
    x, y := 1, 2
    b.Run("BenchmarkNoInline", func(b *testing.B) {
        b.ResetTimer()
        for i := 0; i < b.N; i++ {
            maxNoinline(x, y)
        }
    })
    b.Run("BenchmarkInline", func(b *testing.B) {
        b.ResetTimer()
        for i := 0; i < b.N; i++ {
            maxInline(x, y)
        }
    })
}

BenchmarkInline/BenchmarkNoInline-12  886137398  1.248  ns/op  0 B/op  0 allocs/op
BenchmarkInline/BenchmarkInline-12   1000000000  0.2506 ns/op  0 B/op  0 allocs/op

// 3.1: var closure = NewClosure()
func main() {
    // 3.2: var closure func() int
    var closure = NewClosure()
    closure()
    // 3.3: closure = NewClosure()
    closure()
}

func NewClosure() func() int {
    i := 0
    return func() int {
        i++
        return i
    }
}

./main.go:19:6: can inline NewClosure
./main.go:21:9: can inline NewClosure.func1
./main.go:13:26: inlining call to NewClosure
./main.go:21:9: can inline main.func1
./main.go:14:9: inlining call to main.func1
./main.go:16:9: inlining call to main.func1
./main.go:13:26: func literal does not escape
./main.go:20:2: moved to heap: i
./main.go:21:9: func literal escapes to heap

./main.go:19:6: can inline NewClosure
./main.go:21:9: can inline NewClosure.func1
./main.go:13:22: inlining call to NewClosure
./main.go:13:22: func literal does not escape
./main.go:20:2: moved to heap: i
./main.go:21:9: func literal escapes to heap

go build -gcflags="-d=inlfuncswithclosures=0" main.go
go build -gcflags="-d inlfuncswithclosures=0" main.go

// CanInline determines whether fn is inlineable.
// If so, CanInline saves copies of fn.Body and fn.Dcl in fn.Inl.
// fn and fn.Body will already have been typechecked.
func CanInline(fn *ir.Func) {
...
    // If marked "go:noinline", don't inline
    if fn.Pragma&ir.Noinline != 0 {
        reason = "marked go:noinline"
        return
    }

    // If marked "go:norace" and -race compilation, don't inline.
    if base.Flag.Race && fn.Pragma&ir.Norace != 0 {
        reason = "marked go:norace with -race compilation"
        return
    }

    // If marked "go:nocheckptr" and -d checkptr compilation, don't inline.
    if base.Debug.Checkptr != 0 && fn.Pragma&ir.NoCheckPtr != 0 {
        reason = "marked go:nocheckptr"
        return
    }

    // If marked "go:cgo_unsafe_args", don't inline, since the
    // function makes assumptions about its argument frame layout.
    if fn.Pragma&ir.CgoUnsafeArgs != 0 {
        reason = "marked go:cgo_unsafe_args"
        return
    }

    // If marked as "go:uintptrescapes", don't inline, since the
    // escape information is lost during inlining.
    if fn.Pragma&ir.UintptrEscapes != 0 {
        reason = "marked as having an escaping uintptr argument"
        return
    }

    // The nowritebarrierrec checker currently works at function
    // granularity, so inlining yeswritebarrierrec functions can
    // confuse it (#22342). As a workaround, disallow inlining
    // them for now.
    if fn.Pragma&ir.Yeswritebarrierrec != 0 {
        reason = "marked go:yeswritebarrierrec"
        return
    }

    // If fn has no body (is defined outside of Go), cannot inline it.
    if len(fn.Body) == 0 {
        reason = "no function body"
        return
    }
...
    visitor := hairyVisitor{
        budget:        inlineMaxBudget, // inlineMaxBudget == 80 
        extraCallCost: cc,
    }
    if visitor.tooHairy(fn) {
        reason = visitor.reason
        return
    }
...
}

func (v *hairyVisitor) tooHairy(fn *ir.Func) bool {
    v.do = v.doNode // cache closure
    if ir.DoChildren(fn, v.do) {
        return true
    }
...
}

func (v *hairyVisitor) doNode(n ir.Node) bool {
...
    case ir.OSELECT,
        ir.OGO,
        ir.ODEFER,
        ir.ODCLTYPE, // can't print yet
        ir.OTAILCALL:
        v.reason = "unhandled op " + n.Op().String()
        return true
...
}

//go:build gc && go1.9// +build gc,go1.9package goid

type stack struct {
    lo uintptr
    hi uintptr
}

type gobuf struct {
    sp   uintptr
    pc   uintptr
    g    uintptr
    ctxt uintptr
    ret  uintptr
    lr   uintptr
    bp   uintptr
}

type g struct {
    stack       stack
    stackguard0 uintptr
    stackguard1 uintptr

    _panic       uintptr
    _defer       uintptr
    m            uintptr
    sched        gobuf
    syscallsp    uintptr
    syscallpc    uintptr
    stktopsp     uintptr
    param        uintptr
    atomicstatus uint32
    stackLock    uint32
    goid         int64 // Here it is!
}

//go:build (amd64 || amd64p32) && gc && go1.5// +build amd64 amd64p32// +build gc// +build go1.5package goid

func Get() int64

//go:build (amd64 || amd64p32) && gc && go1.5
// +build amd64 amd64p32
// +build gc
// +build go1.5

#include "go_asm.h"
#include "textflag.h"

// func Get() int64
TEXT ·Get(SB),NOSPLIT,$0-8
    MOVQ (TLS), R14
    MOVQ g_goid(R14), R13
    MOVQ R13, ret+0(FP)
    RET

getg() and getg().m.curg

To get the current user g, use getg().m.curg.

getg() alone returns the current g, but when executing on the system or signal stacks, this will return the current M's "g0" or "gsignal", respectively. This is usually not what you want.

To determine if you're running on the user stack or the system stack, use getg() == getg().m.curg.

//go:build gc && go1.19 && !go1.21// +build gc,go1.19,!go1.21package goid

type p struct {
    id int32 // Here is pid
}

type m struct {
    g0      uintptr // goroutine with scheduling stack
    morebuf gobuf   // gobuf arg to morestack
    divmod  uint32  // div/mod denominator for arm - known to liblink
    _       uint32// Fields not known to debuggers.
    procid     uint64       // for debuggers, but offset not hard-coded
    gsignal    uintptr      // signal-handling g
    goSigStack gsignalStack // Go-allocated signal handling stack
    sigmask    sigset       // storage for saved signal mask
    tls        [6]uintptr   // thread-local storage (for x86 extern register)
    mstartfn   func()
    curg       uintptr // current running goroutine
    caughtsig  uintptr // goroutine running during fatal signal
    p          *p      // attached p for executing go code (nil if not executing go code)
}

//go:build (amd64 || amd64p32 || arm64) && !windows && gc && go1.5// +build amd64 amd64p32 arm64// +build !windows// +build gc// +build go1.5package goid

//go:nosplitfunc getPid() uintptr//go:nosplitfunc GetPid() int {
    return int(getPid())
}

// +build amd64 amd64p32
// +build gc,go1.5

#include "go_asm.h"
#include "textflag.h"

// func getPid() int64
TEXT ·getPid(SB),NOSPLIT,$0-8
    MOVQ (TLS), R14
    MOVQ g_m(R14), R13
    MOVQ m_p(R13), R14
    MOVL p_id(R14), R13
    MOVQ R13, ret+0(FP)
    RET

import "unsafe"
var _ = unsafe.Sizeof(0)

//go:linkname procPin runtime.procPin
//go:nosplit
func procPin() int

//go:linkname procUnpin runtime.procUnpin
//go:nosplit
func procUnpin()

//go:nosplit
func procPin() int {
    _g_ := getg()
    mp := _g_.m

    mp.locks++     // 锁定 P 的调度
    return int(mp.p.ptr().id)
}

//go:nosplit
func procUnpin() {
    _g_ := getg()
    _g_.m.locks--
}

func Getg() int64func getgi() interface{}
var g_goid_offset uintptr = func() uintptr {
    g := getgi()
    if f, ok := reflect.TypeOf(g).FieldByName("goid"); ok {
        return f.Offset
    }
    panic("can not find g.goid field")
}()

TEXT ·Getg(SB), NOSPLIT, $0-8
    MOVQ (TLS), AX
    ADDQ ·g_goid_offset(SB),AX
    MOVQ (AX), BX
    MOVQ BX, ret+0(FP)
    RET

// func getgi() interface{}
TEXT ·getgi(SB), NOSPLIT, $32-16
    NO_LOCAL_POINTERS

    MOVQ $0, ret_type+0(FP)
    MOVQ $0, ret_data+8(FP)
    GO_RESULTS_INITIALIZED

    // get runtime.g
    // MOVQ (TLS), AX
    MOVQ $0, AX

    // get runtime.g type
    MOVQ $type·runtime·g(SB), BX

    // MOVQ BX, ·runtime_g_type(SB)

    // return interface{}
    MOVQ BX, ret_type+0(FP)
    MOVQ AX, ret_data+8(FP)
    RET

var runtime_g_type uint64  // go 源码中声明
var gGoidOffset uintptr = func() uintptr { //nolint
    var iface interface{}
    type eface struct {
        _type uint64
        data  unsafe.Pointer
    }
    // 结构 iface 后，修改他的类型为 g
    (*eface)(unsafe.Pointer(&iface))._type = runtime_g_type
    if f, ok := reflect.TypeOf(iface).FieldByName("goid"); ok {
        return f.Offset
    }
    panic("can not find g.goid field")
}()

GLOBL ·runtime_g_type(SB),NOPTR,$8  
DATA ·runtime_g_type+0(SB)/8,$type·runtime·g(SB)  // 汇编中初始化。汇编中可以访问 package 的私有变量

func (builder *MockBuilder) Build() *Mocker {
    mocker := Mocker{target: reflect.ValueOf(builder.target), builder: builder}
    mocker.buildHook(builder)
    mocker.Patch()
    return &mocker
}
func (mocker *Mocker) Patch() *Mocker {
    mocker.lock.Lock()
    defer mocker.lock.Unlock()
    if mocker.isPatched {
        return mocker
    }
    mocker.patch = monkey.PatchValue(mocker.target, mocker.hook, reflect.ValueOf(mocker.proxy), mocker.builder.unsafe)
    mocker.isPatched = true
    addToGlobal(mocker)

    mocker.outerCaller = tool.OuterCaller()
    return mocker
}

// PatchValue replace the target function with a hook function, and stores the target function in the proxy function// for future restore. Target and hook are values of function. Proxy is a value of proxy function pointer.func PatchValue(target, hook, proxy reflect.Value, unsafe bool) *Patch {
    tool.Assert(hook.Kind() == reflect.Func, "'%s' is not a function", hook.Kind())
    tool.Assert(proxy.Kind() == reflect.Ptr, "'%v' is not a function pointer", proxy.Kind())
    tool.Assert(hook.Type() == target.Type(), "'%v' and '%s' mismatch", hook.Type(), target.Type())
    tool.Assert(proxy.Elem().Type() == target.Type(), "'*%v' and '%s' mismatch", proxy.Elem().Type(), target.Type())

    targetAddr := target.Pointer()
    // The first few bytes of the target function codeconst bufSize = 64
    targetCodeBuf := common.BytesOf(targetAddr, bufSize)
    // construct the branch instruction, i.e. jump to the hook function
    hookCode := inst.BranchInto(common.PtrAt(hook))
    // search the cutting point of the target code, i.e. the minimum length of full instructions that is longer than the hookCode
    cuttingIdx := inst.Disassemble(targetCodeBuf, len(hookCode), !unsafe)

    // construct the proxy code
    proxyCode := common.AllocatePage()
    // save the original code before the cutting pointcopy(proxyCode, targetCodeBuf[:cuttingIdx])
    // construct the branch instruction, i.e. jump to the cutting pointcopy(proxyCode[cuttingIdx:], inst.BranchTo(targetAddr+uintptr(cuttingIdx)))
    // inject the proxy code to the proxy function
    fn.InjectInto(proxy, proxyCode)

    tool.DebugPrintf("PatchValue: hook code len(%v), cuttingIdx(%v)\n", len(hookCode), cuttingIdx)

    // replace target function codes before the cutting point
    mem.WriteWithSTW(targetAddr, hookCode)

    return &Patch{base: targetAddr, code: proxyCode, size: cuttingIdx}
}

// WriteWithSTW copies data bytes to the target address and replaces the original bytes, during which it will stop the// world (only the current goroutine's P is running).func WriteWithSTW(target uintptr, data []byte) {
    common.StopTheWorld()
    defer common.StartTheWorld()
    err := Write(target, data)
    tool.Assert(err == nil, err)
}

package mem

import (
    "syscall""github.com/bytedance/mockey/internal/monkey/common"
)

func Write(target uintptr, data []byte) error {
        do_replace_code(target, common.PtrOf(data), uint64(len(data)), syscall.SYS_MPROTECT,
        syscall.PROT_READ|syscall.PROT_WRITE, syscall.PROT_READ|syscall.PROT_EXEC))
    return nil
}

func do_replace_code(
    _ uintptr, // void   *addr
    _ uintptr, // void   *data
    _ uint64, // size_t  size
    _ uint64, // int     mprotect
    _ uint64, // int     prot_rw
    _ uint64, // int     prot_rx
)

#include "textflag.h"

#define NOP8 BYTE $0x90; BYTE $0x90; BYTE $0x90; BYTE $0x90; BYTE $0x90; BYTE $0x90; BYTE $0x90; BYTE $0x90;
#define NOP64 NOP8; NOP8; NOP8; NOP8; NOP8; NOP8; NOP8; NOP8;
#define NOP512 NOP64; NOP64; NOP64; NOP64; NOP64; NOP64; NOP64; NOP64;
#define NOP4096 NOP512; NOP512; NOP512; NOP512; NOP512; NOP512; NOP512; NOP512;

#define addr        arg + 0x00(FP)
#define data        arg + 0x08(FP)
#define size        arg + 0x10(FP)
#define mprotect    arg + 0x18(FP)
#define prot_rw     arg + 0x20(FP)
#define prot_rx     arg + 0x28(FP)

#define CMOVNEQ_AX_CX   \
    BYTE $0x48          \
    BYTE $0x0f          \
    BYTE $0x45          \
    BYTE $0xc8

TEXT ·do_replace_code(SB), NOSPLIT, $0x30 - 0
    JMP START
    NOP4096
START:
    MOVQ    addr, DI
    MOVQ    size, SI
    MOVQ    DI, AX
    ANDQ    $0x0fff, AX
    ANDQ    $~0x0fff, DI
    ADDQ    AX, SI
    MOVQ    SI, CX
    ANDQ    $0x0fff, CX
    MOVQ    $0x1000, AX
    SUBQ    CX, AX
    TESTQ   CX, CX
    CMOVNEQ_AX_CX
    ADDQ    CX, SI
    MOVQ    DI, R8
    MOVQ    SI, R9
    MOVQ    mprotect , AX
    MOVQ    prot_rw  , DX
    SYSCALL
    MOVQ    addr, DI
    MOVQ    data, SI
    MOVQ    size, CX
    REP
    MOVSB
    MOVQ    R8, DI
    MOVQ    R9, SI
    MOVQ    mprotect , AX
    MOVQ    prot_rx  , DX
    SYSCALL
    JMP     RETURN
    NOP4096
RETURN:
    RET

//stack_amd64.gotype Line uintptrfunc NewLine() Line

var rcuCache unsafe.Pointer = func() unsafe.Pointer {
    m := make(map[Line]string)
    return unsafe.Pointer(&m)
}()

func (l Line) LineNO() (line string) {
    mPCs := *(*map[Line]string)(atomic.LoadPointer(&rcuCache))
    line， ok := mPCs[l]
    if !ok {
        file， n := runtime.FuncForPC(uintptr(l)).FileLine(uintptr(l))
        line = file + ":" + strconv.Itoa(n)
        mPCs2 := make(map[Line]string， len(mPCs)+10)
        mPCs2[l] = line
        for {
            p := atomic.LoadPointer(&rcuCache)
            mPCs = *(*map[Line]string)(p)
            for k， v := range mPCs {
                mPCs2[k] = v
            }
            swapped := atomic.CompareAndSwapPointer(&rcuCache p， unsafe.Pointer(&mPCs2))
            if swapped {
                break
            }
        }
    }
    return
}

# stack_amd64.s
TEXT    ·NewLine(SB)， NOSPLIT， $0-8
    MOVQ     retpc-8(FP)， AX
    SUBQ     $1, AX             // 注意，这里要 -1
    MOVQ     AX， ret+0(FP)
    RET

// file/line information using pc-1, because that is the pc of the
// call instruction (more precisely, the last byte of the call instruction).
// Callers expect the pc buffer to contain return addresses and do the
// same -1 themselves, so we keep pc unchanged.
// When the pc is from a signal (e.g. profiler or segv) then we want
// to look up file/line information using pc, and we store pc+1 in the
// pc buffer so callers can unconditionally subtract 1 before looking up.
// See issue 34123.
// The pc can be at function entry when the frame is initialized without
// actually running code, like runtime.mstart.

//go:build amd64// +build amd64package errors

import (
    _ "unsafe"
)

func buildStack(s []uintptr) int

//go:build amd64 || amd64p32 || arm64
// +build amd64 amd64p32 arm64

#include "go_asm.h"
#include "textflag.h"
#include "funcdata.h"

// func buildStack(s []uintptr) int
TEXT ·buildStack(SB), NOSPLIT, $24-8
    NO_LOCAL_POINTERS
    MOVQ     cap+16(FP), DX     // s.cap
    MOVQ     p+0(FP), AX        // s.ptr
    MOVQ    $0, CX            // loop.i
loop:
    MOVQ    +8(BP), BX        // last pc -> BX
    SUBQ     $1, BX 
    MOVQ    BX, 0(AX)(CX*8)        // s[i] = BX
    
    ADDQ    $1, CX            // CX++ / i++
    CMPQ    CX, DX            // if s.len >= s.cap { return }
    JAE    return                // 无符号大于等于就跳转

    MOVQ    +0(BP), BP         // last BP; 展开调用栈至上一层
    CMPQ    BP, $0             // if (BP) <= 0 { return }
    JA loop                    // 无符号大于就跳转

return:
    MOVQ    CX,n+24(FP)     // ret n
    RET

func cmpstring(string, string) int

TEXT ·Compare<ABIInternal>(SB),NOSPLIT,$0-56
        // AX = a_base (want in SI)
        // BX = a_len  (want in BX)
        // CX = a_cap  (unused)
        // DI = b_base (want in DI)
        // SI = b_len  (want in DX)
        // R8 = b_cap  (unused)
        MOVQ    SI, DX
        MOVQ    AX, SI
        JMP    cmpbody<>(SB)

    TEXT runtime·cmpstring<ABIInternal>(SB),NOSPLIT,$0-40
        // AX = a_base (want in SI)
        // BX = a_len  (want in BX)
        // CX = b_base (want in DI)
        // DI = b_len  (want in DX)
        MOVQ    AX, SI
        MOVQ    DI, DX
        MOVQ    CX, DI
        JMP    cmpbody<>(SB)

    // input:
    //   SI = a
    //   DI = b
    //   BX = alen
    //   DX = blen
    // output:
    //   AX = output (-1/0/1)
    TEXT cmpbody<>(SB),NOSPLIT,$0-0
        CMPQ    SI, DI
    ...
loop:
    CMPQ    R8, $16
    JBE    _0through16
    MOVOU    (SI), X0
    MOVOU    (DI), X1
    PCMPEQB X0, X1
    PMOVMSKB X1, AX
    XORQ    $0xffff, AX    // convert EQ to NE
    JNE    diff16    // branch if at least one byte is not equal
    ADDQ    $16, SI
    ADDQ    $16, DI
    SUBQ    $16, R8
    JMP    loop
    ···

// Index returns the index of the first instance of substr in s, or -1 if substr is not present in s.func Index(s, substr string) int {
    n := len(substr)
    switch {
    case n == 0:
        return 0case n == 1:
        return IndexByte(s, substr[0])
    case n == len(s):
        if substr == s {
            return 0
        }
        return -1case n > len(s):
        return -1case n <= bytealg.MaxLen:
        // Use brute force when s and substr both are smallif len(s) <= bytealg.MaxBruteForce {
            return bytealg.IndexString(s, substr)
    ...
}
// IndexByte returns the index of the first instance of c in s, or -1 if c is not present in s.func IndexByte(s string, c byte) int {
    return bytealg.IndexByteString(s, c)
}

//go:build 386 || amd64 || s390x || arm || arm64 || ppc64 || ppc64le || mips || mipsle || mips64 || mips64le || riscv64 || wasm

package bytealg

//go:noescape
func IndexByte(b []byte, c byte) int

//go:noescape
func IndexByteString(s string, c byte) int

//go:build amd64 || arm64 || s390x || ppc64le || ppc64

package bytealg

//go:noescape

// Index returns the index of the first instance of b in a, or -1 if b is not present in a.
// Requires 2 <= len(b) <= MaxLen.
func Index(a, b []byte) int

//go:noescape

// IndexString returns the index of the first instance of b in a, or -1 if b is not present in a.
// Requires 2 <= len(b) <= MaxLen.
func IndexString(a, b string) int

#include "go_asm.h"
    #include "textflag.h"

    TEXT    ·IndexByte(SB), NOSPLIT, $0-40
        MOVQ b_base+0(FP), SI
        MOVQ b_len+8(FP), BX
        MOVB c+24(FP), AL
        LEAQ ret+32(FP), R8
        JMP  indexbytebody<>(SB)

    TEXT    ·IndexByteString(SB), NOSPLIT, $0-32
        MOVQ s_base+0(FP), SI
        MOVQ s_len+8(FP), BX
        MOVB c+16(FP), AL
        LEAQ ret+24(FP), R8
        JMP  indexbytebody<>(SB)

    // input:
    //   SI: data
    //   BX: data len
    //   AL: byte sought
    //   R8: address to put result
    TEXT    indexbytebody<>(SB), NOSPLIT, $0
        // Shuffle X0 around so that each byte contains
        // the character we're looking for.
        MOVD AX, X0
        PUNPCKLBW X0, X0
        PUNPCKLBW X0, X0
        PSHUFL $0, X0, X0
...

#include "go_asm.h"
    #include "textflag.h"

    TEXT ·Index(SB),NOSPLIT,$0-56
        MOVQ a_base+0(FP), DI
        MOVQ a_len+8(FP), DX
        MOVQ b_base+24(FP), R8
        MOVQ b_len+32(FP), AX
        MOVQ DI, R10
        LEAQ ret+48(FP), R11
        JMP  indexbody<>(SB)

    TEXT ·IndexString(SB),NOSPLIT,$0-40
        MOVQ a_base+0(FP), DI
        MOVQ a_len+8(FP), DX
        MOVQ b_base+16(FP), R8
        MOVQ b_len+24(FP), AX
        MOVQ DI, R10
        LEAQ ret+32(FP), R11
        JMP  indexbody<>(SB)

    // AX: length of string, that we are searching for
    // DX: length of string, in which we are searching
    // DI: pointer to string, in which we are searching
    // R8: pointer to string, that we are searching for
    // R11: address, where to put return value
    // Note: We want len in DX and AX, because PCMPESTRI implicitly consumes them
    TEXT indexbody<>(SB),NOSPLIT,$0
...

func BenchmarkIndexByte(b *testing.B) {
    b.Run("IndexByte", func(b *testing.B) {
        b.ReportAllocs()
        for i := 0; i < b.N; i++ {
            str := testdata.TwitterJsonOut
            n := 0
            k := 0for {
                j := strings.IndexByte(str[k:], ']')
                if j < 0 {
                    break
                }
                n++
                k += j + 1
            }
            _ = n
        }
        b.SetBytes(int64(b.N))
        b.StopTimer()
    })
    b.Run("for", func(b *testing.B) {
        b.ReportAllocs()
        str := testdata.TwitterJsonOut
        for i := 0; i < b.N; i++ {
            n := 0for i := 0; i < len(str); i++ {
                if str[i] == ']' {
                    n++
                }
            }
            _ = n
        }
        b.SetBytes(int64(b.N))
        b.StopTimer()
    })
}

BenchmarkIndexByte/IndexByte
BenchmarkIndexByte/IndexByte-12    3072980    387.5 ns/op    7929621.19 MB/s    0 B/op           0 allocs/op
BenchmarkIndexByte/for
BenchmarkIndexByte/for-12          516663    2417 ns/op      213777.66 MB/s    0 B/op           0 allocs/op

func TestTagTry0(t *testing.T) {
    defer func() {
        fmt.Printf("1 -> ")
    }()

    tag, err1 := NewTag() // 当 tag.Try(err) 时，跳转此处并返回 err1
    fmt.Printf("2 -> ")
    if err1 != nil {
        fmt.Printf("3 -> ")
        return
    }

    defer func() {
        fmt.Printf("4 -> ") // 由于的缺陷：这里 debug 下 defer 不内联，会执行；release 下 defer 内联，不会执行
    }()

    fmt.Printf("5 -> ")
    err2 := errors.New("err2")
    tag.Try(err2)  // 这里 err2!=nil，则会跳转到 tag 创建处的下一行指令执行，即 fmt.Printf("2 -> ")

    fmt.Printf("6 -> ")
    return
}