rsc.io/go@v0.0.0-20150416155037-e040fd465409/src/runtime/runtime1.go (about) 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 "unsafe" 8 9 // Keep a cached value to make gotraceback fast, 10 // since we call it on every call to gentraceback. 11 // The cached value is a uint32 in which the low bit 12 // is the "crash" setting and the top 31 bits are the 13 // gotraceback value. 14 var traceback_cache uint32 = 2 << 1 15 16 // The GOTRACEBACK environment variable controls the 17 // behavior of a Go program that is crashing and exiting. 18 // GOTRACEBACK=0 suppress all tracebacks 19 // GOTRACEBACK=1 default behavior - show tracebacks but exclude runtime frames 20 // GOTRACEBACK=2 show tracebacks including runtime frames 21 // GOTRACEBACK=crash show tracebacks including runtime frames, then crash (core dump etc) 22 //go:nosplit 23 func gotraceback(crash *bool) int32 { 24 _g_ := getg() 25 if crash != nil { 26 *crash = false 27 } 28 if _g_.m.traceback != 0 { 29 return int32(_g_.m.traceback) 30 } 31 if crash != nil { 32 *crash = traceback_cache&1 != 0 33 } 34 return int32(traceback_cache >> 1) 35 } 36 37 var ( 38 argc int32 39 argv **byte 40 ) 41 42 // nosplit for use in linux/386 startup linux_setup_vdso 43 //go:nosplit 44 func argv_index(argv **byte, i int32) *byte { 45 return *(**byte)(add(unsafe.Pointer(argv), uintptr(i)*ptrSize)) 46 } 47 48 func args(c int32, v **byte) { 49 argc = c 50 argv = v 51 sysargs(c, v) 52 } 53 54 var ( 55 // TODO: Retire in favor of GOOS== checks. 56 isplan9 int32 57 issolaris int32 58 iswindows int32 59 ) 60 61 func goargs() { 62 if GOOS == "windows" { 63 return 64 } 65 66 argslice = make([]string, argc) 67 for i := int32(0); i < argc; i++ { 68 argslice[i] = gostringnocopy(argv_index(argv, i)) 69 } 70 } 71 72 func goenvs_unix() { 73 // TODO(austin): ppc64 in dynamic linking mode doesn't 74 // guarantee env[] will immediately follow argv. Might cause 75 // problems. 76 n := int32(0) 77 for argv_index(argv, argc+1+n) != nil { 78 n++ 79 } 80 81 envs = make([]string, n) 82 for i := int32(0); i < n; i++ { 83 envs[i] = gostring(argv_index(argv, argc+1+i)) 84 } 85 } 86 87 func environ() []string { 88 return envs 89 } 90 91 // TODO: These should be locals in testAtomic64, but we don't 8-byte 92 // align stack variables on 386. 93 var test_z64, test_x64 uint64 94 95 func testAtomic64() { 96 test_z64 = 42 97 test_x64 = 0 98 prefetcht0(uintptr(unsafe.Pointer(&test_z64))) 99 prefetcht1(uintptr(unsafe.Pointer(&test_z64))) 100 prefetcht2(uintptr(unsafe.Pointer(&test_z64))) 101 prefetchnta(uintptr(unsafe.Pointer(&test_z64))) 102 if 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 !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 atomicload64(&test_z64) != 1 { 116 throw("load64 failed") 117 } 118 atomicstore64(&test_z64, (1<<40)+1) 119 if atomicload64(&test_z64) != (1<<40)+1 { 120 throw("store64 failed") 121 } 122 if xadd64(&test_z64, (1<<40)+1) != (2<<40)+2 { 123 throw("xadd64 failed") 124 } 125 if atomicload64(&test_z64) != (2<<40)+2 { 126 throw("xadd64 failed") 127 } 128 if xchg64(&test_z64, (3<<40)+3) != (2<<40)+2 { 129 throw("xchg64 failed") 130 } 131 if atomicload64(&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, k1 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) != ptrSize { 193 throw("bad k") 194 } 195 if unsafe.Sizeof(l) != 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 !cas(&z, 1, 2) { 215 throw("cas1") 216 } 217 if z != 2 { 218 throw("cas2") 219 } 220 221 z = 4 222 if cas(&z, 5, 6) { 223 throw("cas3") 224 } 225 if z != 4 { 226 throw("cas4") 227 } 228 229 z = 0xffffffff 230 if !cas(&z, 0xffffffff, 0xfffffffe) { 231 throw("cas5") 232 } 233 if z != 0xfffffffe { 234 throw("cas6") 235 } 236 237 k = unsafe.Pointer(uintptr(0xfedcb123)) 238 if ptrSize == 8 { 239 k = unsafe.Pointer(uintptr(unsafe.Pointer(k)) << 10) 240 } 241 if casp(&k, nil, nil) { 242 throw("casp1") 243 } 244 k1 = add(k, 1) 245 if !casp(&k, k, k1) { 246 throw("casp2") 247 } 248 if k != k1 { 249 throw("casp3") 250 } 251 252 m = [4]byte{1, 1, 1, 1} 253 atomicor8(&m[1], 0xf0) 254 if m[0] != 1 || m[1] != 0xf1 || m[2] != 1 || m[3] != 1 { 255 throw("atomicor8") 256 } 257 258 *(*uint64)(unsafe.Pointer(&j)) = ^uint64(0) 259 if j == j { 260 throw("float64nan") 261 } 262 if !(j != j) { 263 throw("float64nan1") 264 } 265 266 *(*uint64)(unsafe.Pointer(&j1)) = ^uint64(1) 267 if j == j1 { 268 throw("float64nan2") 269 } 270 if !(j != j1) { 271 throw("float64nan3") 272 } 273 274 *(*uint32)(unsafe.Pointer(&i)) = ^uint32(0) 275 if i == i { 276 throw("float32nan") 277 } 278 if i == i { 279 throw("float32nan1") 280 } 281 282 *(*uint32)(unsafe.Pointer(&i1)) = ^uint32(1) 283 if i == i1 { 284 throw("float32nan2") 285 } 286 if i == i1 { 287 throw("float32nan3") 288 } 289 290 testAtomic64() 291 292 if _FixedStack != round2(_FixedStack) { 293 throw("FixedStack is not power-of-2") 294 } 295 } 296 297 type dbgVar struct { 298 name string 299 value *int32 300 } 301 302 // TODO(rsc): Make GC respect debug.invalidptr. 303 304 // Holds variables parsed from GODEBUG env var, 305 // except for "memprofilerate" since there is an 306 // existing int var for that value, which may 307 // already have an initial value. 308 var debug struct { 309 allocfreetrace int32 310 efence int32 311 gcdead int32 312 gctrace int32 313 invalidptr int32 314 scavenge int32 315 scheddetail int32 316 schedtrace int32 317 wbshadow int32 318 gccheckmark int32 319 sbrk int32 320 } 321 322 var dbgvars = []dbgVar{ 323 {"allocfreetrace", &debug.allocfreetrace}, 324 {"efence", &debug.efence}, 325 {"gcdead", &debug.gcdead}, 326 {"gctrace", &debug.gctrace}, 327 {"invalidptr", &debug.invalidptr}, 328 {"scavenge", &debug.scavenge}, 329 {"scheddetail", &debug.scheddetail}, 330 {"schedtrace", &debug.schedtrace}, 331 {"wbshadow", &debug.wbshadow}, 332 {"gccheckmark", &debug.gccheckmark}, 333 {"sbrk", &debug.sbrk}, 334 } 335 336 func parsedebugvars() { 337 // gccheckmark is enabled by default for the 1.5 dev cycle 338 debug.gccheckmark = 1 339 340 for p := gogetenv("GODEBUG"); p != ""; { 341 field := "" 342 i := index(p, ",") 343 if i < 0 { 344 field, p = p, "" 345 } else { 346 field, p = p[:i], p[i+1:] 347 } 348 i = index(field, "=") 349 if i < 0 { 350 continue 351 } 352 key, value := field[:i], field[i+1:] 353 354 // Update MemProfileRate directly here since it 355 // is int, not int32, and should only be updated 356 // if specified in GODEBUG. 357 if key == "memprofilerate" { 358 MemProfileRate = atoi(value) 359 } else { 360 for _, v := range dbgvars { 361 if v.name == key { 362 *v.value = int32(atoi(value)) 363 } 364 } 365 } 366 } 367 368 switch p := gogetenv("GOTRACEBACK"); p { 369 case "": 370 traceback_cache = 1 << 1 371 case "crash": 372 traceback_cache = 2<<1 | 1 373 default: 374 traceback_cache = uint32(atoi(p)) << 1 375 } 376 } 377 378 // Poor mans 64-bit division. 379 // This is a very special function, do not use it if you are not sure what you are doing. 380 // int64 division is lowered into _divv() call on 386, which does not fit into nosplit functions. 381 // Handles overflow in a time-specific manner. 382 //go:nosplit 383 func timediv(v int64, div int32, rem *int32) int32 { 384 res := int32(0) 385 for bit := 30; bit >= 0; bit-- { 386 if v >= int64(div)<<uint(bit) { 387 v = v - (int64(div) << uint(bit)) 388 res += 1 << uint(bit) 389 } 390 } 391 if v >= int64(div) { 392 if rem != nil { 393 *rem = 0 394 } 395 return 0x7fffffff 396 } 397 if rem != nil { 398 *rem = int32(v) 399 } 400 return res 401 } 402 403 // Helpers for Go. Must be NOSPLIT, must only call NOSPLIT functions, and must not block. 404 405 //go:nosplit 406 func acquirem() *m { 407 _g_ := getg() 408 _g_.m.locks++ 409 return _g_.m 410 } 411 412 //go:nosplit 413 func releasem(mp *m) { 414 _g_ := getg() 415 mp.locks-- 416 if mp.locks == 0 && _g_.preempt { 417 // restore the preemption request in case we've cleared it in newstack 418 _g_.stackguard0 = stackPreempt 419 } 420 } 421 422 //go:nosplit 423 func gomcache() *mcache { 424 return getg().m.mcache 425 } 426 427 //go:linkname reflect_typelinks reflect.typelinks 428 //go:nosplit 429 func reflect_typelinks() [][]*_type { 430 ret := [][]*_type{firstmoduledata.typelinks} 431 for datap := firstmoduledata.next; datap != nil; datap = datap.next { 432 ret = append(ret, datap.typelinks) 433 } 434 return ret 435 } 436 437 // TODO: move back into mgc.go 438 func readgogc() int32 { 439 p := gogetenv("GOGC") 440 if p == "" { 441 return 100 442 } 443 if p == "off" { 444 return -1 445 } 446 return int32(atoi(p)) 447 }