type runtime.g

157 uses

	runtime (current package)
		cgocall.go#L264: 		defer func(gp *g) {
		chan.go#L649: func chanparkcommit(gp *g, chanLock unsafe.Pointer) bool {
		cpuprof.go#L91: func (p *cpuProfile) add(gp *g, stk []uintptr) {
		debugcall.go#L112: 			callingG *g
		debugcall.go#L153: 	mcall(func(gp *g) {
		debugcall.go#L189: func debugCallWrap1(dispatch uintptr, callingG *g) {
		debugcall.go#L195: 	mcall(func(gp *g) {
		heapdump.go#L342: func dumpgoroutine(gp *g) {
		lock_sema.go#L194: func notetsleep_internal(n *note, ns int64, gp *g, deadline int64) bool {
		lock_sema.go#L300: func beforeIdle(int64) (*g, bool) {
		malloc.go#L946: 	var assistG *g
		mfinal.go#L32: var fing *g        // goroutine that runs finalizers
		mfinal.go#L136: func wakefing() *g {
		mfinal.go#L137: 	var res *g
		mgc.go#L718: func (c *gcControllerState) findRunnableGCWorker(_p_ *p) *g {
		mgc.go#L1911: 		gopark(func(g *g, nodep unsafe.Pointer) bool {
		mgcmark.go#L121: 	var gp *g
		mgcmark.go#L190: 		var gp *g
		mgcmark.go#L387: func gcAssistAlloc(gp *g) {
		mgcmark.go#L504: func gcAssistAlloc1(gp *g, scanWork int64) {
		mgcmark.go#L695: func scanstack(gp *g, gcw *gcWork) {
		mgcscavenge.go#L163: 	g          *g
		mgcsweep.go#L37: 	g       *g
		mprof.go#L726: 	isOK := func(gp1 *g) bool {
		mprof.go#L792: func saveg(pc, sp uintptr, gp *g, r *StackRecord) {
		netpoll.go#L306: 	var rg, wg *g
		netpoll.go#L334: 	var rg, wg *g
		netpoll.go#L364: 	var rg, wg *g
		netpoll.go#L395: func netpollblockcommit(gp *g, gpp unsafe.Pointer) bool {
		netpoll.go#L406: func netpollgoready(gp *g, traceskip int) {
		netpoll.go#L448: func netpollunblock(pd *pollDesc, mode int32, ioready bool) *g {
		netpoll.go#L472: 			return (*g)(unsafe.Pointer(old))
		netpoll.go#L490: 	var rg *g
		netpoll.go#L499: 	var wg *g
		panic.go#L709: func addOneOpenDeferFrame(gp *g, pc uintptr, sp unsafe.Pointer) {
		panic.go#L810: func runOpenDeferFrame(gp *g, d *_defer) bool {
		panic.go#L1137: func recovery(gp *g) {
		panic.go#L1290: func dopanic_m(gp *g, pc, sp uintptr) bool {
		panic.go#L1340: func canpanic(gp *g) bool {
		panic.go#L1371: func shouldPushSigpanic(gp *g, pc, lr uintptr) bool {
		preempt.go#L62: 	g *g
		preempt.go#L105: func suspendG(gp *g) suspendGState {
		preempt.go#L342: func wantAsyncPreempt(gp *g) bool {
		preempt.go#L363: func isAsyncSafePoint(gp *g, pc, sp, lr uintptr) (bool, uintptr) {
		proc.go#L85: 	g0           g
		proc.go#L319: func gopark(unlockf func(*g, unsafe.Pointer) bool, lock unsafe.Pointer, reason waitReason, traceEv byte, traceskip int) {
		proc.go#L345: func goready(gp *g, traceskip int) {
		proc.go#L452: func badmcall(fn func(*g)) {
		proc.go#L456: func badmcall2(fn func(*g)) {
		proc.go#L500: 	allgs    []*g
		proc.go#L515: 	allgptr **g
		proc.go#L518: func allgadd(gp *g) {
		proc.go#L533: func atomicAllG() (**g, uintptr) {
		proc.go#L535: 	ptr := (**g)(atomic.Loadp(unsafe.Pointer(&allgptr)))
		proc.go#L540: func atomicAllGIndex(ptr **g, i uintptr) *g {
		proc.go#L541: 	return *(**g)(add(unsafe.Pointer(ptr), i*sys.PtrSize))
		proc.go#L689: func dumpgstatus(gp *g) {
		proc.go#L772: func ready(gp *g, traceskip int, next bool) {
		proc.go#L829: func readgstatus(gp *g) uint32 {
		proc.go#L837: func casfrom_Gscanstatus(gp *g, oldval, newval uint32) {
		proc.go#L865: func castogscanstatus(gp *g, oldval, newval uint32) bool {
		proc.go#L890: func casgstatus(gp *g, oldval, newval uint32) {
		proc.go#L931: func casgcopystack(gp *g) uint32 {
		proc.go#L947: func casGToPreemptScan(gp *g, old, new uint32) {
		proc.go#L959: func casGFromPreempted(gp *g, old, new uint32) bool {
		proc.go#L2465: func startlockedm(gp *g) {
		proc.go#L2519: func execute(gp *g, inheritTime bool) {
		proc.go#L2554: func findrunnable() (gp *g, inheritTime bool) {
		proc.go#L3000: 	var tail *g
		proc.go#L3090: 	var gp *g
		proc.go#L3246: func parkunlock_c(gp *g, lock unsafe.Pointer) bool {
		proc.go#L3252: func park_m(gp *g) {
		proc.go#L3277: func goschedImpl(gp *g) {
		proc.go#L3293: func gosched_m(gp *g) {
		proc.go#L3301: func goschedguarded_m(gp *g) {
		proc.go#L3313: func gopreempt_m(gp *g) {
		proc.go#L3323: func preemptPark(gp *g) {
		proc.go#L3353: func goyield_m(gp *g) {
		proc.go#L3376: func goexit0(gp *g) {
		proc.go#L3813: func exitsyscall0(gp *g) {
		proc.go#L3943: func malg(stacksize int32) *g {
		proc.go#L3944: 	newg := new(g)
		proc.go#L3999: func newproc1(fn *funcval, argp unsafe.Pointer, narg int32, callergp *g, callerpc uintptr) *g {
		proc.go#L4103: func saveAncestors(callergp *g) *[]ancestorInfo {
		proc.go#L4136: func gfput(_p_ *p, gp *g) {
		proc.go#L4171: func gfget(_p_ *p) *g {
		proc.go#L4372: func sigprof(pc, sp, lr uintptr, gp *g, mp *m) {
		proc.go#L5499: func schedEnabled(gp *g) bool {
		proc.go#L5540: func globrunqput(gp *g) {
		proc.go#L5551: func globrunqputhead(gp *g) {
		proc.go#L5571: func globrunqget(_p_ *p, max int32) *g {
		proc.go#L5739: func runqput(_p_ *p, gp *g, next bool) {
		proc.go#L5774: func runqputslow(_p_ *p, gp *g, h, t uint32) bool {
		proc.go#L5775: 	var batch [len(_p_.runq)/2 + 1]*g
		proc.go#L5851: func runqget(_p_ *p) (gp *g, inheritTime bool) {
		proc.go#L5935: func runqsteal(_p_, p2 *p, stealRunNextG bool) *g {
		proc.go#L5967: func (q *gQueue) push(gp *g) {
		proc.go#L5976: func (q *gQueue) pushBack(gp *g) {
		proc.go#L6003: func (q *gQueue) pop() *g {
		proc.go#L6033: func (l *gList) push(gp *g) {
		proc.go#L6047: func (l *gList) pop() *g {
		race0.go#L31: func raceacquireg(gp *g, addr unsafe.Pointer)                               { throw("race") }
		race0.go#L34: func racereleaseg(gp *g, addr unsafe.Pointer)                               { throw("race") }
		race0.go#L36: func racereleaseacquireg(gp *g, addr unsafe.Pointer)                        { throw("race") }
		race0.go#L38: func racereleasemergeg(gp *g, addr unsafe.Pointer)                          { throw("race") }
		runtime2.go#L262: func (gp guintptr) ptr() *g { return (*g)(unsafe.Pointer(gp)) }
		runtime2.go#L265: func (gp *guintptr) set(g *g) { *gp = guintptr(unsafe.Pointer(g)) }
		runtime2.go#L276: func setGNoWB(gp **g, new *g) {
		runtime2.go#L350: 	g *g
		runtime2.go#L404: type g struct {
		runtime2.go#L487: 	g0      *g     // goroutine with scheduling stack
		runtime2.go#L493: 	gsignal       *g           // signal-handling g
		runtime2.go#L498: 	curg          *g       // current running goroutine
		runtime2.go#L532: 	waitunlockf   func(*g, unsafe.Pointer) bool
		runtime2.go#L874: 	g    *g
		select.go#L62: func selparkcommit(gp *g, _ unsafe.Pointer) bool {
		select.go#L233: 		gp     *g
		signal_amd64.go#L48: func (c *sigctxt) preparePanic(sig uint32, gp *g) {
		signal_unix.go#L325: func doSigPreempt(gp *g, ctxt *sigctxt) {
		signal_unix.go#L382: func sigFetchG(c *sigctxt) *g {
		signal_unix.go#L395: 				gp := *(**g)(unsafe.Pointer(s.base()))
		signal_unix.go#L522: var testSigtrap func(info *siginfo, ctxt *sigctxt, gp *g) bool
		signal_unix.go#L523: var testSigusr1 func(gp *g) bool
		signal_unix.go#L536: func sighandler(sig uint32, info *siginfo, ctxt unsafe.Pointer, gp *g) {
		stack.go#L717: func adjustctxt(gp *g, adjinfo *adjustinfo) {
		stack.go#L733: func adjustdefers(gp *g, adjinfo *adjustinfo) {
		stack.go#L753: func adjustpanics(gp *g, adjinfo *adjustinfo) {
		stack.go#L759: func adjustsudogs(gp *g, adjinfo *adjustinfo) {
		stack.go#L773: func findsghi(gp *g, stk stack) uintptr {
		stack.go#L787: func syncadjustsudogs(gp *g, used uintptr, adjinfo *adjustinfo) uintptr {
		stack.go#L838: func copystack(gp *g, newsize uintptr) {
		stack.go#L1106: func isShrinkStackSafe(gp *g) bool {
		stack.go#L1126: func shrinkstack(gp *g) {
		stubs.go#L18: func getg() *g
		stubs.go#L34: func mcall(fn func(*g))
		stubs.go#L175: func setg(gg *g)
		time.go#L200: func resetForSleep(gp *g, ut unsafe.Pointer) bool {
		time.go#L242: 	goready(arg.(*g), 0)
		trace.go#L111: 	lockOwner     *g          // to avoid deadlocks during recursive lock locks
		trace.go#L459: func traceReader() *g {
		trace.go#L1055: func traceGoCreate(newg *g, pc uintptr) {
		trace.go#L1100: func traceGoUnpark(gp *g, skip int) {
		traceback.go#L41: func tracebackdefers(gp *g, callback func(*stkframe, unsafe.Pointer) bool, v unsafe.Pointer) {
		traceback.go#L86: func gentraceback(pc0, sp0, lr0 uintptr, gp *g, skip int, pcbuf *uintptr, max int, callback func(*stkframe, unsafe.Pointer) bool, v unsafe.Pointer, flags uint) int {
		traceback.go#L662: func printcreatedby(gp *g) {
		traceback.go#L685: func traceback(pc, sp, lr uintptr, gp *g) {
		traceback.go#L697: func tracebacktrap(pc, sp, lr uintptr, gp *g) {
		traceback.go#L706: func traceback1(pc, sp, lr uintptr, gp *g, flags uint) {
		traceback.go#L805: func gcallers(gp *g, skip int, pcbuf []uintptr) int {
		traceback.go#L811: func showframe(f funcInfo, gp *g, firstFrame bool, funcID, childID funcID) bool {
		traceback.go#L879: func goroutineheader(gp *g) {
		traceback.go#L916: func tracebackothers(me *g) {
		traceback.go#L1027: func isSystemGoroutine(gp *g, fixed bool) bool {