Source file src/runtime/runtime1.go

     1  // Copyright 2009 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  package runtime
     6  
     7  import (
     8  	"internal/abi"
     9  	"internal/bytealg"
    10  	"internal/goarch"
    11  	"internal/godebugs"
    12  	"internal/runtime/atomic"
    13  	"internal/strconv"
    14  	"unsafe"
    15  )
    16  
    17  // Keep a cached value to make gotraceback fast,
    18  // since we call it on every call to gentraceback.
    19  // The cached value is a uint32 in which the low bits
    20  // are the "crash" and "all" settings and the remaining
    21  // bits are the traceback value (0 off, 1 on, 2 include system).
    22  const (
    23  	tracebackCrash = 1 << iota
    24  	tracebackAll
    25  	tracebackShift = iota
    26  )
    27  
    28  var traceback_cache uint32 = 2 << tracebackShift
    29  var traceback_env uint32
    30  
    31  // gotraceback returns the current traceback settings.
    32  //
    33  // If level is 0, suppress all tracebacks.
    34  // If level is 1, show tracebacks, but exclude runtime frames.
    35  // If level is 2, show tracebacks including runtime frames.
    36  // If all is set, print all goroutine stacks. Otherwise, print just the current goroutine.
    37  // If crash is set, crash (core dump, etc) after tracebacking.
    38  //
    39  //go:nosplit
    40  func gotraceback() (level int32, all, crash bool) {
    41  	gp := getg()
    42  	t := atomic.Load(&traceback_cache)
    43  	crash = t&tracebackCrash != 0
    44  	all = gp.m.throwing > throwTypeUser || t&tracebackAll != 0
    45  	if gp.m.traceback != 0 {
    46  		level = int32(gp.m.traceback)
    47  	} else if gp.m.throwing >= throwTypeRuntime {
    48  		// Always include runtime frames in runtime throws unless
    49  		// otherwise overridden by m.traceback.
    50  		level = 2
    51  	} else {
    52  		level = int32(t >> tracebackShift)
    53  	}
    54  	return
    55  }
    56  
    57  var (
    58  	argc int32
    59  	argv **byte
    60  )
    61  
    62  // nosplit for use in linux startup sysargs.
    63  //
    64  //go:nosplit
    65  func argv_index(argv **byte, i int32) *byte {
    66  	return *(**byte)(add(unsafe.Pointer(argv), uintptr(i)*goarch.PtrSize))
    67  }
    68  
    69  func args(c int32, v **byte) {
    70  	argc = c
    71  	argv = v
    72  	sysargs(c, v)
    73  }
    74  
    75  func goargs() {
    76  	if GOOS == "windows" {
    77  		return
    78  	}
    79  	argslice = make([]string, argc)
    80  	for i := int32(0); i < argc; i++ {
    81  		argslice[i] = gostringnocopy(argv_index(argv, i))
    82  	}
    83  }
    84  
    85  func goenvs_unix() {
    86  	// TODO(austin): ppc64 in dynamic linking mode doesn't
    87  	// guarantee env[] will immediately follow argv. Might cause
    88  	// problems.
    89  	n := int32(0)
    90  	for argv_index(argv, argc+1+n) != nil {
    91  		n++
    92  	}
    93  
    94  	envs = make([]string, n)
    95  	for i := int32(0); i < n; i++ {
    96  		envs[i] = gostring(argv_index(argv, argc+1+i))
    97  	}
    98  }
    99  
   100  func environ() []string {
   101  	return envs
   102  }
   103  
   104  // TODO: These should be locals in testAtomic64, but we don't 8-byte
   105  // align stack variables on 386.
   106  var test_z64, test_x64 uint64
   107  
   108  func testAtomic64() {
   109  	test_z64 = 42
   110  	test_x64 = 0
   111  	if atomic.Cas64(&test_z64, test_x64, 1) {
   112  		throw("cas64 failed")
   113  	}
   114  	if test_x64 != 0 {
   115  		throw("cas64 failed")
   116  	}
   117  	test_x64 = 42
   118  	if !atomic.Cas64(&test_z64, test_x64, 1) {
   119  		throw("cas64 failed")
   120  	}
   121  	if test_x64 != 42 || test_z64 != 1 {
   122  		throw("cas64 failed")
   123  	}
   124  	if atomic.Load64(&test_z64) != 1 {
   125  		throw("load64 failed")
   126  	}
   127  	atomic.Store64(&test_z64, (1<<40)+1)
   128  	if atomic.Load64(&test_z64) != (1<<40)+1 {
   129  		throw("store64 failed")
   130  	}
   131  	if atomic.Xadd64(&test_z64, (1<<40)+1) != (2<<40)+2 {
   132  		throw("xadd64 failed")
   133  	}
   134  	if atomic.Load64(&test_z64) != (2<<40)+2 {
   135  		throw("xadd64 failed")
   136  	}
   137  	if atomic.Xchg64(&test_z64, (3<<40)+3) != (2<<40)+2 {
   138  		throw("xchg64 failed")
   139  	}
   140  	if atomic.Load64(&test_z64) != (3<<40)+3 {
   141  		throw("xchg64 failed")
   142  	}
   143  }
   144  
   145  func check() {
   146  	var (
   147  		a     int8
   148  		b     uint8
   149  		c     int16
   150  		d     uint16
   151  		e     int32
   152  		f     uint32
   153  		g     int64
   154  		h     uint64
   155  		i, i1 float32
   156  		j, j1 float64
   157  		k     unsafe.Pointer
   158  		l     *uint16
   159  		m     [4]byte
   160  	)
   161  	type x1t struct {
   162  		x uint8
   163  	}
   164  	type y1t struct {
   165  		x1 x1t
   166  		y  uint8
   167  	}
   168  	var x1 x1t
   169  	var y1 y1t
   170  
   171  	if unsafe.Sizeof(a) != 1 {
   172  		throw("bad a")
   173  	}
   174  	if unsafe.Sizeof(b) != 1 {
   175  		throw("bad b")
   176  	}
   177  	if unsafe.Sizeof(c) != 2 {
   178  		throw("bad c")
   179  	}
   180  	if unsafe.Sizeof(d) != 2 {
   181  		throw("bad d")
   182  	}
   183  	if unsafe.Sizeof(e) != 4 {
   184  		throw("bad e")
   185  	}
   186  	if unsafe.Sizeof(f) != 4 {
   187  		throw("bad f")
   188  	}
   189  	if unsafe.Sizeof(g) != 8 {
   190  		throw("bad g")
   191  	}
   192  	if unsafe.Sizeof(h) != 8 {
   193  		throw("bad h")
   194  	}
   195  	if unsafe.Sizeof(i) != 4 {
   196  		throw("bad i")
   197  	}
   198  	if unsafe.Sizeof(j) != 8 {
   199  		throw("bad j")
   200  	}
   201  	if unsafe.Sizeof(k) != goarch.PtrSize {
   202  		throw("bad k")
   203  	}
   204  	if unsafe.Sizeof(l) != goarch.PtrSize {
   205  		throw("bad l")
   206  	}
   207  	if unsafe.Sizeof(x1) != 1 {
   208  		throw("bad unsafe.Sizeof x1")
   209  	}
   210  	if unsafe.Offsetof(y1.y) != 1 {
   211  		throw("bad offsetof y1.y")
   212  	}
   213  	if unsafe.Sizeof(y1) != 2 {
   214  		throw("bad unsafe.Sizeof y1")
   215  	}
   216  
   217  	var z uint32
   218  	z = 1
   219  	if !atomic.Cas(&z, 1, 2) {
   220  		throw("cas1")
   221  	}
   222  	if z != 2 {
   223  		throw("cas2")
   224  	}
   225  
   226  	z = 4
   227  	if atomic.Cas(&z, 5, 6) {
   228  		throw("cas3")
   229  	}
   230  	if z != 4 {
   231  		throw("cas4")
   232  	}
   233  
   234  	z = 0xffffffff
   235  	if !atomic.Cas(&z, 0xffffffff, 0xfffffffe) {
   236  		throw("cas5")
   237  	}
   238  	if z != 0xfffffffe {
   239  		throw("cas6")
   240  	}
   241  
   242  	m = [4]byte{1, 1, 1, 1}
   243  	atomic.Or8(&m[1], 0xf0)
   244  	if m[0] != 1 || m[1] != 0xf1 || m[2] != 1 || m[3] != 1 {
   245  		throw("atomicor8")
   246  	}
   247  
   248  	m = [4]byte{0xff, 0xff, 0xff, 0xff}
   249  	atomic.And8(&m[1], 0x1)
   250  	if m[0] != 0xff || m[1] != 0x1 || m[2] != 0xff || m[3] != 0xff {
   251  		throw("atomicand8")
   252  	}
   253  
   254  	*(*uint64)(unsafe.Pointer(&j)) = ^uint64(0)
   255  	if j == j {
   256  		throw("float64nan")
   257  	}
   258  	if !(j != j) {
   259  		throw("float64nan1")
   260  	}
   261  
   262  	*(*uint64)(unsafe.Pointer(&j1)) = ^uint64(1)
   263  	if j == j1 {
   264  		throw("float64nan2")
   265  	}
   266  	if !(j != j1) {
   267  		throw("float64nan3")
   268  	}
   269  
   270  	*(*uint32)(unsafe.Pointer(&i)) = ^uint32(0)
   271  	if i == i {
   272  		throw("float32nan")
   273  	}
   274  	if i == i {
   275  		throw("float32nan1")
   276  	}
   277  
   278  	*(*uint32)(unsafe.Pointer(&i1)) = ^uint32(1)
   279  	if i == i1 {
   280  		throw("float32nan2")
   281  	}
   282  	if i == i1 {
   283  		throw("float32nan3")
   284  	}
   285  
   286  	testAtomic64()
   287  
   288  	if fixedStack != round2(fixedStack) {
   289  		throw("FixedStack is not power-of-2")
   290  	}
   291  }
   292  
   293  type dbgVar struct {
   294  	name   string
   295  	value  *int32        // for variables that can only be set at startup
   296  	atomic *atomic.Int32 // for variables that can be changed during execution
   297  	def    int32         // default value (ideally zero)
   298  }
   299  
   300  // Holds variables parsed from GODEBUG env var,
   301  // except for "memprofilerate" since there is an
   302  // existing int var for that value, which may
   303  // already have an initial value.
   304  var debug struct {
   305  	cgocheck                 int32
   306  	clobberfree              int32
   307  	containermaxprocs        int32
   308  	decoratemappings         int32
   309  	disablethp               int32
   310  	dontfreezetheworld       int32
   311  	efence                   int32
   312  	gccheckmark              int32
   313  	gcpacertrace             int32
   314  	gcshrinkstackoff         int32
   315  	gcstoptheworld           int32
   316  	gctrace                  int32
   317  	invalidptr               int32
   318  	madvdontneed             int32 // for Linux; issue 28466
   319  	scavtrace                int32
   320  	scheddetail              int32
   321  	schedtrace               int32
   322  	tracebackancestors       int32
   323  	updatemaxprocs           int32
   324  	asyncpreemptoff          int32
   325  	harddecommit             int32
   326  	adaptivestackstart       int32
   327  	tracefpunwindoff         int32
   328  	traceadvanceperiod       int32
   329  	traceCheckStackOwnership int32
   330  	profstackdepth           int32
   331  	dataindependenttiming    int32
   332  
   333  	// debug.malloc is used as a combined debug check
   334  	// in the malloc function and should be set
   335  	// if any of the below debug options is != 0.
   336  	malloc          bool
   337  	inittrace       int32
   338  	sbrk            int32
   339  	checkfinalizers int32
   340  	// traceallocfree controls whether execution traces contain
   341  	// detailed trace data about memory allocation. This value
   342  	// affects debug.malloc only if it is != 0 and the execution
   343  	// tracer is enabled, in which case debug.malloc will be
   344  	// set to "true" if it isn't already while tracing is enabled.
   345  	// It will be set while the world is stopped, so it's safe.
   346  	// The value of traceallocfree can be changed any time in response
   347  	// to os.Setenv("GODEBUG").
   348  	traceallocfree atomic.Int32
   349  
   350  	panicnil atomic.Int32
   351  
   352  	// tracebacklabels controls the inclusion of goroutine labels in the
   353  	// goroutine status header line.
   354  	tracebacklabels atomic.Int32
   355  }
   356  
   357  var dbgvars = []*dbgVar{
   358  	{name: "adaptivestackstart", value: &debug.adaptivestackstart},
   359  	{name: "asyncpreemptoff", value: &debug.asyncpreemptoff},
   360  	{name: "cgocheck", value: &debug.cgocheck},
   361  	{name: "clobberfree", value: &debug.clobberfree},
   362  	{name: "containermaxprocs", value: &debug.containermaxprocs, def: 1},
   363  	{name: "dataindependenttiming", value: &debug.dataindependenttiming},
   364  	{name: "decoratemappings", value: &debug.decoratemappings, def: 1},
   365  	{name: "disablethp", value: &debug.disablethp},
   366  	{name: "dontfreezetheworld", value: &debug.dontfreezetheworld},
   367  	{name: "checkfinalizers", value: &debug.checkfinalizers},
   368  	{name: "efence", value: &debug.efence},
   369  	{name: "gccheckmark", value: &debug.gccheckmark},
   370  	{name: "gcpacertrace", value: &debug.gcpacertrace},
   371  	{name: "gcshrinkstackoff", value: &debug.gcshrinkstackoff},
   372  	{name: "gcstoptheworld", value: &debug.gcstoptheworld},
   373  	{name: "gctrace", value: &debug.gctrace},
   374  	{name: "harddecommit", value: &debug.harddecommit},
   375  	{name: "inittrace", value: &debug.inittrace},
   376  	{name: "invalidptr", value: &debug.invalidptr},
   377  	{name: "madvdontneed", value: &debug.madvdontneed},
   378  	{name: "panicnil", atomic: &debug.panicnil},
   379  	{name: "profstackdepth", value: &debug.profstackdepth, def: 128},
   380  	{name: "sbrk", value: &debug.sbrk},
   381  	{name: "scavtrace", value: &debug.scavtrace},
   382  	{name: "scheddetail", value: &debug.scheddetail},
   383  	{name: "schedtrace", value: &debug.schedtrace},
   384  	{name: "traceadvanceperiod", value: &debug.traceadvanceperiod},
   385  	{name: "traceallocfree", atomic: &debug.traceallocfree},
   386  	{name: "tracecheckstackownership", value: &debug.traceCheckStackOwnership},
   387  	{name: "tracebackancestors", value: &debug.tracebackancestors},
   388  	{name: "tracebacklabels", atomic: &debug.tracebacklabels, def: 1},
   389  	{name: "tracefpunwindoff", value: &debug.tracefpunwindoff},
   390  	{name: "updatemaxprocs", value: &debug.updatemaxprocs, def: 1},
   391  }
   392  
   393  func parseRuntimeDebugVars(godebug string) {
   394  	// defaults
   395  	debug.cgocheck = 1
   396  	debug.invalidptr = 1
   397  	debug.adaptivestackstart = 1 // set this to 0 to turn larger initial goroutine stacks off
   398  	if GOOS == "linux" {
   399  		// On Linux, MADV_FREE is faster than MADV_DONTNEED,
   400  		// but doesn't affect many of the statistics that
   401  		// MADV_DONTNEED does until the memory is actually
   402  		// reclaimed. This generally leads to poor user
   403  		// experience, like confusing stats in top and other
   404  		// monitoring tools; and bad integration with
   405  		// management systems that respond to memory usage.
   406  		// Hence, default to MADV_DONTNEED.
   407  		debug.madvdontneed = 1
   408  	}
   409  	debug.traceadvanceperiod = defaultTraceAdvancePeriod
   410  
   411  	// apply runtime defaults, if any
   412  	for _, v := range dbgvars {
   413  		if v.def != 0 {
   414  			// Every var should have either v.value or v.atomic set.
   415  			if v.value != nil {
   416  				*v.value = v.def
   417  			} else if v.atomic != nil {
   418  				v.atomic.Store(v.def)
   419  			}
   420  		}
   421  	}
   422  	// apply compile-time GODEBUG settings
   423  	parsegodebug(godebugDefault, nil)
   424  
   425  	// apply environment settings
   426  	parsegodebug(godebug, nil)
   427  
   428  	debug.malloc = (debug.inittrace | debug.sbrk | debug.checkfinalizers) != 0
   429  	debug.profstackdepth = min(debug.profstackdepth, maxProfStackDepth)
   430  
   431  	// Disable async preemption in checkmark mode. The following situation is
   432  	// problematic with checkmark mode:
   433  	//
   434  	// - The GC doesn't mark object A because it is truly dead.
   435  	// - The GC stops the world, asynchronously preempting G1 which has a reference
   436  	//   to A in its top stack frame
   437  	// - During the stop the world, we run the second checkmark GC. It marks the roots
   438  	//   and discovers A through G1.
   439  	// - Checkmark mode reports a failure since there's a discrepancy in mark metadata.
   440  	//
   441  	// We could disable just conservative scanning during the checkmark scan, which is
   442  	// safe but makes checkmark slightly less powerful, but that's a lot more invasive
   443  	// than just disabling async preemption altogether.
   444  	if debug.gccheckmark > 0 {
   445  		debug.asyncpreemptoff = 1
   446  	}
   447  }
   448  
   449  func finishDebugVarsSetup() {
   450  	p := new(string)
   451  	*p = gogetenv("GODEBUG")
   452  	godebugEnv.Store(p)
   453  
   454  	setTraceback(gogetenv("GOTRACEBACK"))
   455  	traceback_env = traceback_cache
   456  }
   457  
   458  // reparsedebugvars reparses the runtime's debug variables
   459  // because the environment variable has been changed to env.
   460  func reparsedebugvars(env string) {
   461  	seen := make(map[string]bool)
   462  	// apply environment settings
   463  	parsegodebug(env, seen)
   464  	// apply compile-time GODEBUG settings for as-yet-unseen variables
   465  	parsegodebug(godebugDefault, seen)
   466  	// apply defaults for as-yet-unseen variables
   467  	for _, v := range dbgvars {
   468  		if v.atomic != nil && !seen[v.name] {
   469  			v.atomic.Store(0)
   470  		}
   471  	}
   472  }
   473  
   474  // If an invalid GODEBUG setting is found during startup time,
   475  // invalidGODEBUG is set to that setting so it can be reported
   476  // when initialization has progressed sufficiently.
   477  var invalidGODEBUG struct {
   478  	key, value string
   479  	removed    int
   480  }
   481  
   482  // parsegodebug parses the godebug string, updating variables listed in dbgvars.
   483  // If seen == nil, this is startup time and we process the string left to right
   484  // overwriting older settings with newer ones.
   485  // If seen != nil, $GODEBUG has changed and we are doing an
   486  // incremental update. To avoid flapping in the case where a value is
   487  // set multiple times (perhaps in the default and the environment,
   488  // or perhaps twice in the environment), we process the string right-to-left
   489  // and only change values not already seen. After doing this for both
   490  // the environment and the default settings, the caller must also call
   491  // cleargodebug(seen) to reset any now-unset values back to their defaults.
   492  func parsegodebug(godebug string, seen map[string]bool) {
   493  	for p := godebug; p != ""; {
   494  		var field string
   495  		if seen == nil {
   496  			// startup: process left to right, overwriting older settings with newer
   497  			i := bytealg.IndexByteString(p, ',')
   498  			if i < 0 {
   499  				field, p = p, ""
   500  			} else {
   501  				field, p = p[:i], p[i+1:]
   502  			}
   503  		} else {
   504  			// incremental update: process right to left, updating and skipping seen
   505  			i := len(p) - 1
   506  			for i >= 0 && p[i] != ',' {
   507  				i--
   508  			}
   509  			if i < 0 {
   510  				p, field = "", p
   511  			} else {
   512  				p, field = p[:i], p[i+1:]
   513  			}
   514  		}
   515  		i := bytealg.IndexByteString(field, '=')
   516  		if i < 0 {
   517  			continue
   518  		}
   519  		key, value := field[:i], field[i+1:]
   520  
   521  		// Setting a removed GODEBUG is ok unless it's set to an old value.
   522  		// We only check at startup time per go.dev/issue/76163.
   523  		if seen == nil {
   524  			for _, info := range godebugs.Removed {
   525  				if info.Name == key {
   526  					if info.Old(value) {
   527  						invalidGODEBUG.key = key
   528  						invalidGODEBUG.value = value
   529  						invalidGODEBUG.removed = info.Removed
   530  						return // this skips the cgocheck below but we're about to fatal anyway
   531  					}
   532  					break
   533  				}
   534  			}
   535  		}
   536  
   537  		if seen[key] {
   538  			continue
   539  		}
   540  		if seen != nil {
   541  			seen[key] = true
   542  		}
   543  
   544  		// Update MemProfileRate directly here since it
   545  		// is int, not int32, and should only be updated
   546  		// if specified in GODEBUG.
   547  		if seen == nil && key == "memprofilerate" {
   548  			if n, err := strconv.Atoi(value); err == nil {
   549  				MemProfileRate = n
   550  			}
   551  		} else {
   552  			for _, v := range dbgvars {
   553  				if v.name == key {
   554  					if n, err := strconv.ParseInt(value, 10, 32); err == nil {
   555  						if seen == nil && v.value != nil {
   556  							*v.value = int32(n)
   557  						} else if v.atomic != nil {
   558  							v.atomic.Store(int32(n))
   559  						}
   560  					}
   561  				}
   562  			}
   563  		}
   564  	}
   565  
   566  	if debug.cgocheck > 1 {
   567  		throw("cgocheck > 1 mode is no longer supported at runtime. Use GOEXPERIMENT=cgocheck2 at build time instead.")
   568  	}
   569  }
   570  
   571  //go:linkname setTraceback runtime/debug.SetTraceback
   572  func setTraceback(level string) {
   573  	var t uint32
   574  	switch level {
   575  	case "none":
   576  		t = 0
   577  	case "single", "":
   578  		t = 1 << tracebackShift
   579  	case "all":
   580  		t = 1<<tracebackShift | tracebackAll
   581  	case "system":
   582  		t = 2<<tracebackShift | tracebackAll
   583  	case "crash":
   584  		t = 2<<tracebackShift | tracebackAll | tracebackCrash
   585  	case "wer":
   586  		if GOOS == "windows" {
   587  			t = 2<<tracebackShift | tracebackAll | tracebackCrash
   588  			enableWER()
   589  			break
   590  		}
   591  		fallthrough
   592  	default:
   593  		t = tracebackAll
   594  		if n, err := strconv.Atoi(level); err == nil && n == int(uint32(n)) {
   595  			t |= uint32(n) << tracebackShift
   596  		}
   597  	}
   598  	// when C owns the process, simply exit'ing the process on fatal errors
   599  	// and panics is surprising. Be louder and abort instead.
   600  	if islibrary || isarchive {
   601  		t |= tracebackCrash
   602  	}
   603  
   604  	t |= traceback_env
   605  
   606  	atomic.Store(&traceback_cache, t)
   607  }
   608  
   609  // Helpers for Go. Must be NOSPLIT, must only call NOSPLIT functions, and must not block.
   610  
   611  //go:nosplit
   612  func acquirem() *m {
   613  	gp := getg()
   614  	gp.m.locks++
   615  	return gp.m
   616  }
   617  
   618  //go:nosplit
   619  func releasem(mp *m) {
   620  	gp := getg()
   621  	mp.locks--
   622  	if mp.locks == 0 && gp.preempt {
   623  		// restore the preemption request in case we've cleared it in newstack
   624  		gp.stackguard0 = stackPreempt
   625  	}
   626  }
   627  
   628  // reflect_typelinks is meant for package reflect,
   629  // but widely used packages access it using linkname.
   630  // Notable members of the hall of shame include:
   631  //   - gitee.com/quant1x/gox
   632  //   - github.com/goccy/json
   633  //   - github.com/modern-go/reflect2
   634  //   - github.com/vmware/govmomi
   635  //   - github.com/pinpoint-apm/pinpoint-go-agent
   636  //   - github.com/timandy/routine
   637  //   - github.com/v2pro/plz
   638  //
   639  // Do not remove or change the type signature.
   640  // See go.dev/issue/67401.
   641  //
   642  // This is obsolete and only remains for external packages.
   643  // New code should use reflect_compiledTypelinks.
   644  //
   645  //go:linkname reflect_typelinks reflect.typelinks
   646  func reflect_typelinks() ([]unsafe.Pointer, [][]int32) {
   647  	modules := activeModules()
   648  
   649  	typesToOffsets := func(md *moduledata) []int32 {
   650  		types := moduleTypelinks(md)
   651  		ret := make([]int32, 0, len(types))
   652  		for _, typ := range types {
   653  			ret = append(ret, int32(uintptr(unsafe.Pointer(typ))-md.types))
   654  		}
   655  		return ret
   656  	}
   657  
   658  	sections := []unsafe.Pointer{unsafe.Pointer(modules[0].types)}
   659  	ret := [][]int32{typesToOffsets(modules[0])}
   660  	for _, md := range modules[1:] {
   661  		sections = append(sections, unsafe.Pointer(md.types))
   662  		ret = append(ret, typesToOffsets(md))
   663  	}
   664  	return sections, ret
   665  }
   666  
   667  // reflect_compiledTypelinks returns the typelink types
   668  // generated by the compiler for all current modules.
   669  // The normal case is a single module, so this returns one
   670  // slice for the main module, and a slice of slices, normally nil,
   671  // for other modules.
   672  //
   673  //go:linknamestd reflect_compiledTypelinks reflect.compiledTypelinks
   674  func reflect_compiledTypelinks() ([]*abi.Type, [][]*abi.Type) {
   675  	modules := activeModules()
   676  	firstTypes := moduleTypelinks(modules[0])
   677  	var rest [][]*abi.Type
   678  	for _, md := range modules[1:] {
   679  		rest = append(rest, moduleTypelinks(md))
   680  	}
   681  	return firstTypes, rest
   682  }
   683  
   684  // reflect_resolveNameOff resolves a name offset from a base pointer.
   685  //
   686  // reflect_resolveNameOff is for package reflect,
   687  // but widely used packages access it using linkname.
   688  // Notable members of the hall of shame include:
   689  //   - github.com/agiledragon/gomonkey/v2
   690  //
   691  // Do not remove or change the type signature.
   692  // See go.dev/issue/67401.
   693  //
   694  //go:linkname reflect_resolveNameOff reflect.resolveNameOff
   695  func reflect_resolveNameOff(ptrInModule unsafe.Pointer, off int32) unsafe.Pointer {
   696  	return unsafe.Pointer(resolveNameOff(ptrInModule, nameOff(off)).Bytes)
   697  }
   698  
   699  // reflect_resolveTypeOff resolves an *rtype offset from a base type.
   700  //
   701  // reflect_resolveTypeOff is meant for package reflect,
   702  // but widely used packages access it using linkname.
   703  // Notable members of the hall of shame include:
   704  //   - gitee.com/quant1x/gox
   705  //   - github.com/modern-go/reflect2
   706  //   - github.com/v2pro/plz
   707  //   - github.com/timandy/routine
   708  //
   709  // Do not remove or change the type signature.
   710  // See go.dev/issue/67401.
   711  //
   712  //go:linkname reflect_resolveTypeOff reflect.resolveTypeOff
   713  func reflect_resolveTypeOff(rtype unsafe.Pointer, off int32) unsafe.Pointer {
   714  	return unsafe.Pointer(toRType((*_type)(rtype)).typeOff(typeOff(off)))
   715  }
   716  
   717  // reflect_resolveTextOff resolves a function pointer offset from a base type.
   718  //
   719  // reflect_resolveTextOff is for package reflect,
   720  // but widely used packages access it using linkname.
   721  // Notable members of the hall of shame include:
   722  //   - github.com/agiledragon/gomonkey/v2
   723  //
   724  // Do not remove or change the type signature.
   725  // See go.dev/issue/67401.
   726  //
   727  //go:linkname reflect_resolveTextOff reflect.resolveTextOff
   728  func reflect_resolveTextOff(rtype unsafe.Pointer, off int32) unsafe.Pointer {
   729  	return toRType((*_type)(rtype)).textOff(textOff(off))
   730  }
   731  
   732  // reflectlite_resolveNameOff resolves a name offset from a base pointer.
   733  //
   734  //go:linkname reflectlite_resolveNameOff internal/reflectlite.resolveNameOff
   735  func reflectlite_resolveNameOff(ptrInModule unsafe.Pointer, off int32) unsafe.Pointer {
   736  	return unsafe.Pointer(resolveNameOff(ptrInModule, nameOff(off)).Bytes)
   737  }
   738  
   739  // reflectlite_resolveTypeOff resolves an *rtype offset from a base type.
   740  //
   741  //go:linkname reflectlite_resolveTypeOff internal/reflectlite.resolveTypeOff
   742  func reflectlite_resolveTypeOff(rtype unsafe.Pointer, off int32) unsafe.Pointer {
   743  	return unsafe.Pointer(toRType((*_type)(rtype)).typeOff(typeOff(off)))
   744  }
   745  
   746  // reflect_addReflectOff adds a pointer to the reflection offset lookup map.
   747  //
   748  //go:linkname reflect_addReflectOff reflect.addReflectOff
   749  func reflect_addReflectOff(ptr unsafe.Pointer) int32 {
   750  	reflectOffsLock()
   751  	if reflectOffs.m == nil {
   752  		reflectOffs.m = make(map[int32]unsafe.Pointer)
   753  		reflectOffs.minv = make(map[unsafe.Pointer]int32)
   754  		reflectOffs.next = -1
   755  	}
   756  	id, found := reflectOffs.minv[ptr]
   757  	if !found {
   758  		id = reflectOffs.next
   759  		reflectOffs.next-- // use negative offsets as IDs to aid debugging
   760  		reflectOffs.m[id] = ptr
   761  		reflectOffs.minv[ptr] = id
   762  	}
   763  	reflectOffsUnlock()
   764  	return id
   765  }
   766  
   767  // reflect_adjustAIXGCDataForRuntime takes a type.GCData address and returns
   768  // the new address to use. This is only called on AIX.
   769  // See getGCMaskOnDemand.
   770  //
   771  //go:linknamestd reflect_adjustAIXGCDataForRuntime reflect.adjustAIXGCDataForRuntime
   772  func reflect_adjustAIXGCDataForRuntime(addr *byte) *byte {
   773  	return (*byte)(add(unsafe.Pointer(addr), aixStaticDataBase-firstmoduledata.data))
   774  }
   775  
   776  //go:linkname fips_getIndicator crypto/internal/fips140.getIndicator
   777  func fips_getIndicator() uint8 {
   778  	return getg().fipsIndicator
   779  }
   780  
   781  //go:linkname fips_setIndicator crypto/internal/fips140.setIndicator
   782  func fips_setIndicator(indicator uint8) {
   783  	getg().fipsIndicator = indicator
   784  }
   785  

View as plain text