Source file
src/runtime/runtime1.go
1
2
3
4
5 package runtime
6
7 import (
8 "internal/bytealg"
9 "internal/goarch"
10 "internal/runtime/atomic"
11 "unsafe"
12 )
13
14
15
16
17
18
19 const (
20 tracebackCrash = 1 << iota
21 tracebackAll
22 tracebackShift = iota
23 )
24
25 var traceback_cache uint32 = 2 << tracebackShift
26 var traceback_env uint32
27
28
29
30
31
32
33
34
35
36
37 func gotraceback() (level int32, all, crash bool) {
38 gp := getg()
39 t := atomic.Load(&traceback_cache)
40 crash = t&tracebackCrash != 0
41 all = gp.m.throwing >= throwTypeUser || t&tracebackAll != 0
42 if gp.m.traceback != 0 {
43 level = int32(gp.m.traceback)
44 } else if gp.m.throwing >= throwTypeRuntime {
45
46
47 level = 2
48 } else {
49 level = int32(t >> tracebackShift)
50 }
51 return
52 }
53
54 var (
55 argc int32
56 argv **byte
57 )
58
59
60
61
62 func argv_index(argv **byte, i int32) *byte {
63 return *(**byte)(add(unsafe.Pointer(argv), uintptr(i)*goarch.PtrSize))
64 }
65
66 func args(c int32, v **byte) {
67 argc = c
68 argv = v
69 sysargs(c, v)
70 }
71
72 func goargs() {
73 if GOOS == "windows" {
74 return
75 }
76 argslice = make([]string, argc)
77 for i := int32(0); i < argc; i++ {
78 argslice[i] = gostringnocopy(argv_index(argv, i))
79 }
80 }
81
82 func goenvs_unix() {
83
84
85
86 n := int32(0)
87 for argv_index(argv, argc+1+n) != nil {
88 n++
89 }
90
91 envs = make([]string, n)
92 for i := int32(0); i < n; i++ {
93 envs[i] = gostring(argv_index(argv, argc+1+i))
94 }
95 }
96
97 func environ() []string {
98 return envs
99 }
100
101
102
103 var test_z64, test_x64 uint64
104
105 func testAtomic64() {
106 test_z64 = 42
107 test_x64 = 0
108 if atomic.Cas64(&test_z64, test_x64, 1) {
109 throw("cas64 failed")
110 }
111 if test_x64 != 0 {
112 throw("cas64 failed")
113 }
114 test_x64 = 42
115 if !atomic.Cas64(&test_z64, test_x64, 1) {
116 throw("cas64 failed")
117 }
118 if test_x64 != 42 || test_z64 != 1 {
119 throw("cas64 failed")
120 }
121 if atomic.Load64(&test_z64) != 1 {
122 throw("load64 failed")
123 }
124 atomic.Store64(&test_z64, (1<<40)+1)
125 if atomic.Load64(&test_z64) != (1<<40)+1 {
126 throw("store64 failed")
127 }
128 if atomic.Xadd64(&test_z64, (1<<40)+1) != (2<<40)+2 {
129 throw("xadd64 failed")
130 }
131 if atomic.Load64(&test_z64) != (2<<40)+2 {
132 throw("xadd64 failed")
133 }
134 if atomic.Xchg64(&test_z64, (3<<40)+3) != (2<<40)+2 {
135 throw("xchg64 failed")
136 }
137 if atomic.Load64(&test_z64) != (3<<40)+3 {
138 throw("xchg64 failed")
139 }
140 }
141
142 func check() {
143 var (
144 a int8
145 b uint8
146 c int16
147 d uint16
148 e int32
149 f uint32
150 g int64
151 h uint64
152 i, i1 float32
153 j, j1 float64
154 k unsafe.Pointer
155 l *uint16
156 m [4]byte
157 )
158 type x1t struct {
159 x uint8
160 }
161 type y1t struct {
162 x1 x1t
163 y uint8
164 }
165 var x1 x1t
166 var y1 y1t
167
168 if unsafe.Sizeof(a) != 1 {
169 throw("bad a")
170 }
171 if unsafe.Sizeof(b) != 1 {
172 throw("bad b")
173 }
174 if unsafe.Sizeof(c) != 2 {
175 throw("bad c")
176 }
177 if unsafe.Sizeof(d) != 2 {
178 throw("bad d")
179 }
180 if unsafe.Sizeof(e) != 4 {
181 throw("bad e")
182 }
183 if unsafe.Sizeof(f) != 4 {
184 throw("bad f")
185 }
186 if unsafe.Sizeof(g) != 8 {
187 throw("bad g")
188 }
189 if unsafe.Sizeof(h) != 8 {
190 throw("bad h")
191 }
192 if unsafe.Sizeof(i) != 4 {
193 throw("bad i")
194 }
195 if unsafe.Sizeof(j) != 8 {
196 throw("bad j")
197 }
198 if unsafe.Sizeof(k) != goarch.PtrSize {
199 throw("bad k")
200 }
201 if unsafe.Sizeof(l) != goarch.PtrSize {
202 throw("bad l")
203 }
204 if unsafe.Sizeof(x1) != 1 {
205 throw("bad unsafe.Sizeof x1")
206 }
207 if unsafe.Offsetof(y1.y) != 1 {
208 throw("bad offsetof y1.y")
209 }
210 if unsafe.Sizeof(y1) != 2 {
211 throw("bad unsafe.Sizeof y1")
212 }
213
214 if timediv(12345*1000000000+54321, 1000000000, &e) != 12345 || e != 54321 {
215 throw("bad timediv")
216 }
217
218 var z uint32
219 z = 1
220 if !atomic.Cas(&z, 1, 2) {
221 throw("cas1")
222 }
223 if z != 2 {
224 throw("cas2")
225 }
226
227 z = 4
228 if atomic.Cas(&z, 5, 6) {
229 throw("cas3")
230 }
231 if z != 4 {
232 throw("cas4")
233 }
234
235 z = 0xffffffff
236 if !atomic.Cas(&z, 0xffffffff, 0xfffffffe) {
237 throw("cas5")
238 }
239 if z != 0xfffffffe {
240 throw("cas6")
241 }
242
243 m = [4]byte{1, 1, 1, 1}
244 atomic.Or8(&m[1], 0xf0)
245 if m[0] != 1 || m[1] != 0xf1 || m[2] != 1 || m[3] != 1 {
246 throw("atomicor8")
247 }
248
249 m = [4]byte{0xff, 0xff, 0xff, 0xff}
250 atomic.And8(&m[1], 0x1)
251 if m[0] != 0xff || m[1] != 0x1 || m[2] != 0xff || m[3] != 0xff {
252 throw("atomicand8")
253 }
254
255 *(*uint64)(unsafe.Pointer(&j)) = ^uint64(0)
256 if j == j {
257 throw("float64nan")
258 }
259 if !(j != j) {
260 throw("float64nan1")
261 }
262
263 *(*uint64)(unsafe.Pointer(&j1)) = ^uint64(1)
264 if j == j1 {
265 throw("float64nan2")
266 }
267 if !(j != j1) {
268 throw("float64nan3")
269 }
270
271 *(*uint32)(unsafe.Pointer(&i)) = ^uint32(0)
272 if i == i {
273 throw("float32nan")
274 }
275 if i == i {
276 throw("float32nan1")
277 }
278
279 *(*uint32)(unsafe.Pointer(&i1)) = ^uint32(1)
280 if i == i1 {
281 throw("float32nan2")
282 }
283 if i == i1 {
284 throw("float32nan3")
285 }
286
287 testAtomic64()
288
289 if fixedStack != round2(fixedStack) {
290 throw("FixedStack is not power-of-2")
291 }
292
293 if !checkASM() {
294 throw("assembly checks failed")
295 }
296 }
297
298 type dbgVar struct {
299 name string
300 value *int32
301 atomic *atomic.Int32
302 def int32
303 }
304
305
306
307
308
309 var debug struct {
310 cgocheck int32
311 clobberfree int32
312 disablethp int32
313 dontfreezetheworld int32
314 efence int32
315 gccheckmark int32
316 gcpacertrace int32
317 gcshrinkstackoff int32
318 gcstoptheworld int32
319 gctrace int32
320 invalidptr int32
321 madvdontneed int32
322 runtimeContentionStacks atomic.Int32
323 scavtrace int32
324 scheddetail int32
325 schedtrace int32
326 tracebackancestors int32
327 asyncpreemptoff int32
328 harddecommit int32
329 adaptivestackstart int32
330 tracefpunwindoff int32
331 traceadvanceperiod int32
332 traceCheckStackOwnership int32
333
334
335
336
337 malloc bool
338 inittrace int32
339 sbrk int32
340
341
342
343
344
345
346
347
348 traceallocfree atomic.Int32
349
350 panicnil atomic.Int32
351
352
353
354
355
356
357
358
359
360 asynctimerchan atomic.Int32
361 }
362
363 var dbgvars = []*dbgVar{
364 {name: "adaptivestackstart", value: &debug.adaptivestackstart},
365 {name: "asyncpreemptoff", value: &debug.asyncpreemptoff},
366 {name: "asynctimerchan", atomic: &debug.asynctimerchan},
367 {name: "cgocheck", value: &debug.cgocheck},
368 {name: "clobberfree", value: &debug.clobberfree},
369 {name: "disablethp", value: &debug.disablethp},
370 {name: "dontfreezetheworld", value: &debug.dontfreezetheworld},
371 {name: "efence", value: &debug.efence},
372 {name: "gccheckmark", value: &debug.gccheckmark},
373 {name: "gcpacertrace", value: &debug.gcpacertrace},
374 {name: "gcshrinkstackoff", value: &debug.gcshrinkstackoff},
375 {name: "gcstoptheworld", value: &debug.gcstoptheworld},
376 {name: "gctrace", value: &debug.gctrace},
377 {name: "harddecommit", value: &debug.harddecommit},
378 {name: "inittrace", value: &debug.inittrace},
379 {name: "invalidptr", value: &debug.invalidptr},
380 {name: "madvdontneed", value: &debug.madvdontneed},
381 {name: "panicnil", atomic: &debug.panicnil},
382 {name: "runtimecontentionstacks", atomic: &debug.runtimeContentionStacks},
383 {name: "sbrk", value: &debug.sbrk},
384 {name: "scavtrace", value: &debug.scavtrace},
385 {name: "scheddetail", value: &debug.scheddetail},
386 {name: "schedtrace", value: &debug.schedtrace},
387 {name: "traceadvanceperiod", value: &debug.traceadvanceperiod},
388 {name: "traceallocfree", atomic: &debug.traceallocfree},
389 {name: "tracecheckstackownership", value: &debug.traceCheckStackOwnership},
390 {name: "tracebackancestors", value: &debug.tracebackancestors},
391 {name: "tracefpunwindoff", value: &debug.tracefpunwindoff},
392 }
393
394 func parsedebugvars() {
395
396 debug.cgocheck = 1
397 debug.invalidptr = 1
398 debug.adaptivestackstart = 1
399 if GOOS == "linux" {
400
401
402
403
404
405
406
407
408 debug.madvdontneed = 1
409 }
410 debug.traceadvanceperiod = defaultTraceAdvancePeriod
411
412 godebug := gogetenv("GODEBUG")
413
414 p := new(string)
415 *p = godebug
416 godebugEnv.Store(p)
417
418
419 for _, v := range dbgvars {
420 if v.def != 0 {
421
422 if v.value != nil {
423 *v.value = v.def
424 } else if v.atomic != nil {
425 v.atomic.Store(v.def)
426 }
427 }
428 }
429
430
431 parsegodebug(godebugDefault, nil)
432
433
434 parsegodebug(godebug, nil)
435
436 debug.malloc = (debug.inittrace | debug.sbrk) != 0
437
438 setTraceback(gogetenv("GOTRACEBACK"))
439 traceback_env = traceback_cache
440 }
441
442
443
444 func reparsedebugvars(env string) {
445 seen := make(map[string]bool)
446
447 parsegodebug(env, seen)
448
449 parsegodebug(godebugDefault, seen)
450
451 for _, v := range dbgvars {
452 if v.atomic != nil && !seen[v.name] {
453 v.atomic.Store(0)
454 }
455 }
456 }
457
458
459
460
461
462
463
464
465
466
467
468 func parsegodebug(godebug string, seen map[string]bool) {
469 for p := godebug; p != ""; {
470 var field string
471 if seen == nil {
472
473 i := bytealg.IndexByteString(p, ',')
474 if i < 0 {
475 field, p = p, ""
476 } else {
477 field, p = p[:i], p[i+1:]
478 }
479 } else {
480
481 i := len(p) - 1
482 for i >= 0 && p[i] != ',' {
483 i--
484 }
485 if i < 0 {
486 p, field = "", p
487 } else {
488 p, field = p[:i], p[i+1:]
489 }
490 }
491 i := bytealg.IndexByteString(field, '=')
492 if i < 0 {
493 continue
494 }
495 key, value := field[:i], field[i+1:]
496 if seen[key] {
497 continue
498 }
499 if seen != nil {
500 seen[key] = true
501 }
502
503
504
505
506 if seen == nil && key == "memprofilerate" {
507 if n, ok := atoi(value); ok {
508 MemProfileRate = n
509 }
510 } else {
511 for _, v := range dbgvars {
512 if v.name == key {
513 if n, ok := atoi32(value); ok {
514 if seen == nil && v.value != nil {
515 *v.value = n
516 } else if v.atomic != nil {
517 v.atomic.Store(n)
518 }
519 }
520 }
521 }
522 }
523 }
524
525 if debug.cgocheck > 1 {
526 throw("cgocheck > 1 mode is no longer supported at runtime. Use GOEXPERIMENT=cgocheck2 at build time instead.")
527 }
528 }
529
530
531 func setTraceback(level string) {
532 var t uint32
533 switch level {
534 case "none":
535 t = 0
536 case "single", "":
537 t = 1 << tracebackShift
538 case "all":
539 t = 1<<tracebackShift | tracebackAll
540 case "system":
541 t = 2<<tracebackShift | tracebackAll
542 case "crash":
543 t = 2<<tracebackShift | tracebackAll | tracebackCrash
544 case "wer":
545 if GOOS == "windows" {
546 t = 2<<tracebackShift | tracebackAll | tracebackCrash
547 enableWER()
548 break
549 }
550 fallthrough
551 default:
552 t = tracebackAll
553 if n, ok := atoi(level); ok && n == int(uint32(n)) {
554 t |= uint32(n) << tracebackShift
555 }
556 }
557
558
559 if islibrary || isarchive {
560 t |= tracebackCrash
561 }
562
563 t |= traceback_env
564
565 atomic.Store(&traceback_cache, t)
566 }
567
568
569
570
571
572
573
574
575 func timediv(v int64, div int32, rem *int32) int32 {
576 res := int32(0)
577 for bit := 30; bit >= 0; bit-- {
578 if v >= int64(div)<<uint(bit) {
579 v = v - (int64(div) << uint(bit))
580
581
582 res |= 1 << uint(bit)
583 }
584 }
585 if v >= int64(div) {
586 if rem != nil {
587 *rem = 0
588 }
589 return 0x7fffffff
590 }
591 if rem != nil {
592 *rem = int32(v)
593 }
594 return res
595 }
596
597
598
599
600 func acquirem() *m {
601 gp := getg()
602 gp.m.locks++
603 return gp.m
604 }
605
606
607 func releasem(mp *m) {
608 gp := getg()
609 mp.locks--
610 if mp.locks == 0 && gp.preempt {
611
612 gp.stackguard0 = stackPreempt
613 }
614 }
615
616
617 func reflect_typelinks() ([]unsafe.Pointer, [][]int32) {
618 modules := activeModules()
619 sections := []unsafe.Pointer{unsafe.Pointer(modules[0].types)}
620 ret := [][]int32{modules[0].typelinks}
621 for _, md := range modules[1:] {
622 sections = append(sections, unsafe.Pointer(md.types))
623 ret = append(ret, md.typelinks)
624 }
625 return sections, ret
626 }
627
628
629
630
631 func reflect_resolveNameOff(ptrInModule unsafe.Pointer, off int32) unsafe.Pointer {
632 return unsafe.Pointer(resolveNameOff(ptrInModule, nameOff(off)).Bytes)
633 }
634
635
636
637
638 func reflect_resolveTypeOff(rtype unsafe.Pointer, off int32) unsafe.Pointer {
639 return unsafe.Pointer(toRType((*_type)(rtype)).typeOff(typeOff(off)))
640 }
641
642
643
644
645 func reflect_resolveTextOff(rtype unsafe.Pointer, off int32) unsafe.Pointer {
646 return toRType((*_type)(rtype)).textOff(textOff(off))
647 }
648
649
650
651
652 func reflectlite_resolveNameOff(ptrInModule unsafe.Pointer, off int32) unsafe.Pointer {
653 return unsafe.Pointer(resolveNameOff(ptrInModule, nameOff(off)).Bytes)
654 }
655
656
657
658
659 func reflectlite_resolveTypeOff(rtype unsafe.Pointer, off int32) unsafe.Pointer {
660 return unsafe.Pointer(toRType((*_type)(rtype)).typeOff(typeOff(off)))
661 }
662
663
664
665
666 func reflect_addReflectOff(ptr unsafe.Pointer) int32 {
667 reflectOffsLock()
668 if reflectOffs.m == nil {
669 reflectOffs.m = make(map[int32]unsafe.Pointer)
670 reflectOffs.minv = make(map[unsafe.Pointer]int32)
671 reflectOffs.next = -1
672 }
673 id, found := reflectOffs.minv[ptr]
674 if !found {
675 id = reflectOffs.next
676 reflectOffs.next--
677 reflectOffs.m[id] = ptr
678 reflectOffs.minv[ptr] = id
679 }
680 reflectOffsUnlock()
681 return id
682 }
683
View as plain text