Source file src/runtime/runtime1.go

Documentation: runtime

     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  	"runtime/internal/atomic"
     9  	"runtime/internal/sys"
    10  	"unsafe"
    11  )
    12  
    13  // Keep a cached value to make gotraceback fast,
    14  // since we call it on every call to gentraceback.
    15  // The cached value is a uint32 in which the low bits
    16  // are the "crash" and "all" settings and the remaining
    17  // bits are the traceback value (0 off, 1 on, 2 include system).
    18  const (
    19  	tracebackCrash = 1 << iota
    20  	tracebackAll
    21  	tracebackShift = iota
    22  )
    23  
    24  var traceback_cache uint32 = 2 << tracebackShift
    25  var traceback_env uint32
    26  
    27  // gotraceback returns the current traceback settings.
    28  //
    29  // If level is 0, suppress all tracebacks.
    30  // If level is 1, show tracebacks, but exclude runtime frames.
    31  // If level is 2, show tracebacks including runtime frames.
    32  // If all is set, print all goroutine stacks. Otherwise, print just the current goroutine.
    33  // If crash is set, crash (core dump, etc) after tracebacking.
    34  //
    35  //go:nosplit
    36  func gotraceback() (level int32, all, crash bool) {
    37  	_g_ := getg()
    38  	t := atomic.Load(&traceback_cache)
    39  	crash = t&tracebackCrash != 0
    40  	all = _g_.m.throwing > 0 || t&tracebackAll != 0
    41  	if _g_.m.traceback != 0 {
    42  		level = int32(_g_.m.traceback)
    43  	} else {
    44  		level = int32(t >> tracebackShift)
    45  	}
    46  	return
    47  }
    48  
    49  var (
    50  	argc int32
    51  	argv **byte
    52  )
    53  
    54  // nosplit for use in linux startup sysargs
    55  //go:nosplit
    56  func argv_index(argv **byte, i int32) *byte {
    57  	return *(**byte)(add(unsafe.Pointer(argv), uintptr(i)*sys.PtrSize))
    58  }
    59  
    60  func args(c int32, v **byte) {
    61  	argc = c
    62  	argv = v
    63  	sysargs(c, v)
    64  }
    65  
    66  func goargs() {
    67  	if GOOS == "windows" {
    68  		return
    69  	}
    70  	argslice = make([]string, argc)
    71  	for i := int32(0); i < argc; i++ {
    72  		argslice[i] = gostringnocopy(argv_index(argv, i))
    73  	}
    74  }
    75  
    76  func goenvs_unix() {
    77  	// TODO(austin): ppc64 in dynamic linking mode doesn't
    78  	// guarantee env[] will immediately follow argv. Might cause
    79  	// problems.
    80  	n := int32(0)
    81  	for argv_index(argv, argc+1+n) != nil {
    82  		n++
    83  	}
    84  
    85  	envs = make([]string, n)
    86  	for i := int32(0); i < n; i++ {
    87  		envs[i] = gostring(argv_index(argv, argc+1+i))
    88  	}
    89  }
    90  
    91  func environ() []string {
    92  	return envs
    93  }
    94  
    95  // TODO: These should be locals in testAtomic64, but we don't 8-byte
    96  // align stack variables on 386.
    97  var test_z64, test_x64 uint64
    98  
    99  func testAtomic64() {
   100  	test_z64 = 42
   101  	test_x64 = 0
   102  	if atomic.Cas64(&test_z64, test_x64, 1) {
   103  		throw("cas64 failed")
   104  	}
   105  	if test_x64 != 0 {
   106  		throw("cas64 failed")
   107  	}
   108  	test_x64 = 42
   109  	if !atomic.Cas64(&test_z64, test_x64, 1) {
   110  		throw("cas64 failed")
   111  	}
   112  	if test_x64 != 42 || test_z64 != 1 {
   113  		throw("cas64 failed")
   114  	}
   115  	if atomic.Load64(&test_z64) != 1 {
   116  		throw("load64 failed")
   117  	}
   118  	atomic.Store64(&test_z64, (1<<40)+1)
   119  	if atomic.Load64(&test_z64) != (1<<40)+1 {
   120  		throw("store64 failed")
   121  	}
   122  	if atomic.Xadd64(&test_z64, (1<<40)+1) != (2<<40)+2 {
   123  		throw("xadd64 failed")
   124  	}
   125  	if atomic.Load64(&test_z64) != (2<<40)+2 {
   126  		throw("xadd64 failed")
   127  	}
   128  	if atomic.Xchg64(&test_z64, (3<<40)+3) != (2<<40)+2 {
   129  		throw("xchg64 failed")
   130  	}
   131  	if atomic.Load64(&test_z64) != (3<<40)+3 {
   132  		throw("xchg64 failed")
   133  	}
   134  }
   135  
   136  func check() {
   137  	var (
   138  		a     int8
   139  		b     uint8
   140  		c     int16
   141  		d     uint16
   142  		e     int32
   143  		f     uint32
   144  		g     int64
   145  		h     uint64
   146  		i, i1 float32
   147  		j, j1 float64
   148  		k     unsafe.Pointer
   149  		l     *uint16
   150  		m     [4]byte
   151  	)
   152  	type x1t struct {
   153  		x uint8
   154  	}
   155  	type y1t struct {
   156  		x1 x1t
   157  		y  uint8
   158  	}
   159  	var x1 x1t
   160  	var y1 y1t
   161  
   162  	if unsafe.Sizeof(a) != 1 {
   163  		throw("bad a")
   164  	}
   165  	if unsafe.Sizeof(b) != 1 {
   166  		throw("bad b")
   167  	}
   168  	if unsafe.Sizeof(c) != 2 {
   169  		throw("bad c")
   170  	}
   171  	if unsafe.Sizeof(d) != 2 {
   172  		throw("bad d")
   173  	}
   174  	if unsafe.Sizeof(e) != 4 {
   175  		throw("bad e")
   176  	}
   177  	if unsafe.Sizeof(f) != 4 {
   178  		throw("bad f")
   179  	}
   180  	if unsafe.Sizeof(g) != 8 {
   181  		throw("bad g")
   182  	}
   183  	if unsafe.Sizeof(h) != 8 {
   184  		throw("bad h")
   185  	}
   186  	if unsafe.Sizeof(i) != 4 {
   187  		throw("bad i")
   188  	}
   189  	if unsafe.Sizeof(j) != 8 {
   190  		throw("bad j")
   191  	}
   192  	if unsafe.Sizeof(k) != sys.PtrSize {
   193  		throw("bad k")
   194  	}
   195  	if unsafe.Sizeof(l) != sys.PtrSize {
   196  		throw("bad l")
   197  	}
   198  	if unsafe.Sizeof(x1) != 1 {
   199  		throw("bad unsafe.Sizeof x1")
   200  	}
   201  	if unsafe.Offsetof(y1.y) != 1 {
   202  		throw("bad offsetof y1.y")
   203  	}
   204  	if unsafe.Sizeof(y1) != 2 {
   205  		throw("bad unsafe.Sizeof y1")
   206  	}
   207  
   208  	if timediv(12345*1000000000+54321, 1000000000, &e) != 12345 || e != 54321 {
   209  		throw("bad timediv")
   210  	}
   211  
   212  	var z uint32
   213  	z = 1
   214  	if !atomic.Cas(&z, 1, 2) {
   215  		throw("cas1")
   216  	}
   217  	if z != 2 {
   218  		throw("cas2")
   219  	}
   220  
   221  	z = 4
   222  	if atomic.Cas(&z, 5, 6) {
   223  		throw("cas3")
   224  	}
   225  	if z != 4 {
   226  		throw("cas4")
   227  	}
   228  
   229  	z = 0xffffffff
   230  	if !atomic.Cas(&z, 0xffffffff, 0xfffffffe) {
   231  		throw("cas5")
   232  	}
   233  	if z != 0xfffffffe {
   234  		throw("cas6")
   235  	}
   236  
   237  	m = [4]byte{1, 1, 1, 1}
   238  	atomic.Or8(&m[1], 0xf0)
   239  	if m[0] != 1 || m[1] != 0xf1 || m[2] != 1 || m[3] != 1 {
   240  		throw("atomicor8")
   241  	}
   242  
   243  	m = [4]byte{0xff, 0xff, 0xff, 0xff}
   244  	atomic.And8(&m[1], 0x1)
   245  	if m[0] != 0xff || m[1] != 0x1 || m[2] != 0xff || m[3] != 0xff {
   246  		throw("atomicand8")
   247  	}
   248  
   249  	*(*uint64)(unsafe.Pointer(&j)) = ^uint64(0)
   250  	if j == j {
   251  		throw("float64nan")
   252  	}
   253  	if !(j != j) {
   254  		throw("float64nan1")
   255  	}
   256  
   257  	*(*uint64)(unsafe.Pointer(&j1)) = ^uint64(1)
   258  	if j == j1 {
   259  		throw("float64nan2")
   260  	}
   261  	if !(j != j1) {
   262  		throw("float64nan3")
   263  	}
   264  
   265  	*(*uint32)(unsafe.Pointer(&i)) = ^uint32(0)
   266  	if i == i {
   267  		throw("float32nan")
   268  	}
   269  	if i == i {
   270  		throw("float32nan1")
   271  	}
   272  
   273  	*(*uint32)(unsafe.Pointer(&i1)) = ^uint32(1)
   274  	if i == i1 {
   275  		throw("float32nan2")
   276  	}
   277  	if i == i1 {
   278  		throw("float32nan3")
   279  	}
   280  
   281  	testAtomic64()
   282  
   283  	if _FixedStack != round2(_FixedStack) {
   284  		throw("FixedStack is not power-of-2")
   285  	}
   286  
   287  	if !checkASM() {
   288  		throw("assembly checks failed")
   289  	}
   290  }
   291  
   292  type dbgVar struct {
   293  	name  string
   294  	value *int32
   295  }
   296  
   297  // Holds variables parsed from GODEBUG env var,
   298  // except for "memprofilerate" since there is an
   299  // existing int var for that value, which may
   300  // already have an initial value.
   301  var debug struct {
   302  	allocfreetrace     int32
   303  	cgocheck           int32
   304  	clobberfree        int32
   305  	efence             int32
   306  	gccheckmark        int32
   307  	gcpacertrace       int32
   308  	gcshrinkstackoff   int32
   309  	gcstoptheworld     int32
   310  	gctrace            int32
   311  	invalidptr         int32
   312  	madvdontneed       int32 // for Linux; issue 28466
   313  	sbrk               int32
   314  	scavenge           int32
   315  	scheddetail        int32
   316  	schedtrace         int32
   317  	tracebackancestors int32
   318  }
   319  
   320  var dbgvars = []dbgVar{
   321  	{"allocfreetrace", &debug.allocfreetrace},
   322  	{"clobberfree", &debug.clobberfree},
   323  	{"cgocheck", &debug.cgocheck},
   324  	{"efence", &debug.efence},
   325  	{"gccheckmark", &debug.gccheckmark},
   326  	{"gcpacertrace", &debug.gcpacertrace},
   327  	{"gcshrinkstackoff", &debug.gcshrinkstackoff},
   328  	{"gcstoptheworld", &debug.gcstoptheworld},
   329  	{"gctrace", &debug.gctrace},
   330  	{"invalidptr", &debug.invalidptr},
   331  	{"madvdontneed", &debug.madvdontneed},
   332  	{"sbrk", &debug.sbrk},
   333  	{"scavenge", &debug.scavenge},
   334  	{"scheddetail", &debug.scheddetail},
   335  	{"schedtrace", &debug.schedtrace},
   336  	{"tracebackancestors", &debug.tracebackancestors},
   337  }
   338  
   339  func parsedebugvars() {
   340  	// defaults
   341  	debug.cgocheck = 1
   342  	debug.invalidptr = 1
   343  
   344  	for p := gogetenv("GODEBUG"); p != ""; {
   345  		field := ""
   346  		i := index(p, ",")
   347  		if i < 0 {
   348  			field, p = p, ""
   349  		} else {
   350  			field, p = p[:i], p[i+1:]
   351  		}
   352  		i = index(field, "=")
   353  		if i < 0 {
   354  			continue
   355  		}
   356  		key, value := field[:i], field[i+1:]
   357  
   358  		// Update MemProfileRate directly here since it
   359  		// is int, not int32, and should only be updated
   360  		// if specified in GODEBUG.
   361  		if key == "memprofilerate" {
   362  			if n, ok := atoi(value); ok {
   363  				MemProfileRate = n
   364  			}
   365  		} else {
   366  			for _, v := range dbgvars {
   367  				if v.name == key {
   368  					if n, ok := atoi32(value); ok {
   369  						*v.value = n
   370  					}
   371  				}
   372  			}
   373  		}
   374  	}
   375  
   376  	setTraceback(gogetenv("GOTRACEBACK"))
   377  	traceback_env = traceback_cache
   378  }
   379  
   380  //go:linkname setTraceback runtime/debug.SetTraceback
   381  func setTraceback(level string) {
   382  	var t uint32
   383  	switch level {
   384  	case "none":
   385  		t = 0
   386  	case "single", "":
   387  		t = 1 << tracebackShift
   388  	case "all":
   389  		t = 1<<tracebackShift | tracebackAll
   390  	case "system":
   391  		t = 2<<tracebackShift | tracebackAll
   392  	case "crash":
   393  		t = 2<<tracebackShift | tracebackAll | tracebackCrash
   394  	default:
   395  		t = tracebackAll
   396  		if n, ok := atoi(level); ok && n == int(uint32(n)) {
   397  			t |= uint32(n) << tracebackShift
   398  		}
   399  	}
   400  	// when C owns the process, simply exit'ing the process on fatal errors
   401  	// and panics is surprising. Be louder and abort instead.
   402  	if islibrary || isarchive {
   403  		t |= tracebackCrash
   404  	}
   405  
   406  	t |= traceback_env
   407  
   408  	atomic.Store(&traceback_cache, t)
   409  }
   410  
   411  // Poor mans 64-bit division.
   412  // This is a very special function, do not use it if you are not sure what you are doing.
   413  // int64 division is lowered into _divv() call on 386, which does not fit into nosplit functions.
   414  // Handles overflow in a time-specific manner.
   415  // This keeps us within no-split stack limits on 32-bit processors.
   416  //go:nosplit
   417  func timediv(v int64, div int32, rem *int32) int32 {
   418  	res := int32(0)
   419  	for bit := 30; bit >= 0; bit-- {
   420  		if v >= int64(div)<<uint(bit) {
   421  			v = v - (int64(div) << uint(bit))
   422  			// Before this for loop, res was 0, thus all these
   423  			// power of 2 increments are now just bitsets.
   424  			res |= 1 << uint(bit)
   425  		}
   426  	}
   427  	if v >= int64(div) {
   428  		if rem != nil {
   429  			*rem = 0
   430  		}
   431  		return 0x7fffffff
   432  	}
   433  	if rem != nil {
   434  		*rem = int32(v)
   435  	}
   436  	return res
   437  }
   438  
   439  // Helpers for Go. Must be NOSPLIT, must only call NOSPLIT functions, and must not block.
   440  
   441  //go:nosplit
   442  func acquirem() *m {
   443  	_g_ := getg()
   444  	_g_.m.locks++
   445  	return _g_.m
   446  }
   447  
   448  //go:nosplit
   449  func releasem(mp *m) {
   450  	_g_ := getg()
   451  	mp.locks--
   452  	if mp.locks == 0 && _g_.preempt {
   453  		// restore the preemption request in case we've cleared it in newstack
   454  		_g_.stackguard0 = stackPreempt
   455  	}
   456  }
   457  
   458  //go:nosplit
   459  func gomcache() *mcache {
   460  	return getg().m.mcache
   461  }
   462  
   463  //go:linkname reflect_typelinks reflect.typelinks
   464  func reflect_typelinks() ([]unsafe.Pointer, [][]int32) {
   465  	modules := activeModules()
   466  	sections := []unsafe.Pointer{unsafe.Pointer(modules[0].types)}
   467  	ret := [][]int32{modules[0].typelinks}
   468  	for _, md := range modules[1:] {
   469  		sections = append(sections, unsafe.Pointer(md.types))
   470  		ret = append(ret, md.typelinks)
   471  	}
   472  	return sections, ret
   473  }
   474  
   475  // reflect_resolveNameOff resolves a name offset from a base pointer.
   476  //go:linkname reflect_resolveNameOff reflect.resolveNameOff
   477  func reflect_resolveNameOff(ptrInModule unsafe.Pointer, off int32) unsafe.Pointer {
   478  	return unsafe.Pointer(resolveNameOff(ptrInModule, nameOff(off)).bytes)
   479  }
   480  
   481  // reflect_resolveTypeOff resolves an *rtype offset from a base type.
   482  //go:linkname reflect_resolveTypeOff reflect.resolveTypeOff
   483  func reflect_resolveTypeOff(rtype unsafe.Pointer, off int32) unsafe.Pointer {
   484  	return unsafe.Pointer((*_type)(rtype).typeOff(typeOff(off)))
   485  }
   486  
   487  // reflect_resolveTextOff resolves an function pointer offset from a base type.
   488  //go:linkname reflect_resolveTextOff reflect.resolveTextOff
   489  func reflect_resolveTextOff(rtype unsafe.Pointer, off int32) unsafe.Pointer {
   490  	return (*_type)(rtype).textOff(textOff(off))
   491  
   492  }
   493  
   494  // reflectlite_resolveNameOff resolves a name offset from a base pointer.
   495  //go:linkname reflectlite_resolveNameOff internal/reflectlite.resolveNameOff
   496  func reflectlite_resolveNameOff(ptrInModule unsafe.Pointer, off int32) unsafe.Pointer {
   497  	return unsafe.Pointer(resolveNameOff(ptrInModule, nameOff(off)).bytes)
   498  }
   499  
   500  // reflectlite_resolveTypeOff resolves an *rtype offset from a base type.
   501  //go:linkname reflectlite_resolveTypeOff internal/reflectlite.resolveTypeOff
   502  func reflectlite_resolveTypeOff(rtype unsafe.Pointer, off int32) unsafe.Pointer {
   503  	return unsafe.Pointer((*_type)(rtype).typeOff(typeOff(off)))
   504  }
   505  
   506  // reflect_addReflectOff adds a pointer to the reflection offset lookup map.
   507  //go:linkname reflect_addReflectOff reflect.addReflectOff
   508  func reflect_addReflectOff(ptr unsafe.Pointer) int32 {
   509  	reflectOffsLock()
   510  	if reflectOffs.m == nil {
   511  		reflectOffs.m = make(map[int32]unsafe.Pointer)
   512  		reflectOffs.minv = make(map[unsafe.Pointer]int32)
   513  		reflectOffs.next = -1
   514  	}
   515  	id, found := reflectOffs.minv[ptr]
   516  	if !found {
   517  		id = reflectOffs.next
   518  		reflectOffs.next-- // use negative offsets as IDs to aid debugging
   519  		reflectOffs.m[id] = ptr
   520  		reflectOffs.minv[ptr] = id
   521  	}
   522  	reflectOffsUnlock()
   523  	return id
   524  }
   525  

View as plain text