File Manager

X7ROOT File Manager

Current Path: /opt/golang/1.17.2/src/runtime

📁 ..
📄 HACKING.md(13.07 KB)
📄 Makefile(178 B)
📄 abi_test.go(2.88 KB)
📄 alg.go(9.45 KB)
📄 asm.s(715 B)
📄 asm_386.s(40.27 KB)
📄 asm_amd64.s(56.93 KB)
📄 asm_arm.s(30.23 KB)
📄 asm_arm64.s(33 KB)
📄 asm_mips64x.s(22.43 KB)
📄 asm_mipsx.s(24.39 KB)
📄 asm_ppc64x.h(1023 B)
📄 asm_ppc64x.s(29.16 KB)
📄 asm_riscv64.s(22.43 KB)
📄 asm_s390x.s(26.04 KB)
📄 asm_wasm.s(9.8 KB)
📄 atomic_arm64.s(259 B)
📄 atomic_mips64x.s(326 B)
📄 atomic_mipsx.s(284 B)
📄 atomic_pointer.go(2.62 KB)
📄 atomic_ppc64x.s(461 B)
📄 atomic_riscv64.s(275 B)
📄 auxv_none.go(360 B)
📄 callers_test.go(7.72 KB)
📁 cgo
📄 cgo.go(2.01 KB)
📄 cgo_mmap.go(2.42 KB)
📄 cgo_ppc64x.go(439 B)
📄 cgo_sigaction.go(3.17 KB)
📄 cgocall.go(18.88 KB)
📄 cgocallback.go(317 B)
📄 cgocheck.go(6.83 KB)
📄 chan.go(23.54 KB)
📄 chan_test.go(23.01 KB)
📄 chanbarrier_test.go(1.4 KB)
📄 checkptr.go(3.29 KB)
📄 checkptr_test.go(1.62 KB)
📄 closure_test.go(937 B)
📄 compiler.go(413 B)
📄 complex.go(1.59 KB)
📄 complex_test.go(1.05 KB)
📄 conv_wasm_test.go(2.96 KB)
📄 cpuflags.go(800 B)
📄 cpuflags_amd64.go(533 B)
📄 cpuflags_arm64.go(334 B)
📄 cpuprof.go(6.92 KB)
📄 cputicks.go(497 B)
📄 crash_cgo_test.go(16.17 KB)
📄 crash_nonunix_test.go(429 B)
📄 crash_test.go(20.96 KB)
📄 crash_unix_test.go(8.52 KB)
📁 debug
📄 debug.go(1.63 KB)
📄 debug_test.go(6.82 KB)
📄 debugcall.go(6.21 KB)
📄 debuglog.go(17.49 KB)
📄 debuglog_off.go(377 B)
📄 debuglog_on.go(1.11 KB)
📄 debuglog_test.go(4.56 KB)
📄 defer_test.go(10.32 KB)
📄 defs1_linux.go(862 B)
📄 defs1_netbsd_386.go(2.84 KB)
📄 defs1_netbsd_amd64.go(3.07 KB)
📄 defs1_netbsd_arm.go(2.96 KB)
📄 defs1_netbsd_arm64.go(3.18 KB)
📄 defs1_solaris_amd64.go(4.02 KB)
📄 defs2_linux.go(3.52 KB)
📄 defs3_linux.go(1.11 KB)
📄 defs_aix.go(4.18 KB)
📄 defs_aix_ppc64.go(3.63 KB)
📄 defs_arm_linux.go(2.69 KB)
📄 defs_darwin.go(3.79 KB)
📄 defs_darwin_amd64.go(6.07 KB)
📄 defs_darwin_arm64.go(3.89 KB)
📄 defs_dragonfly.go(2.63 KB)
📄 defs_dragonfly_amd64.go(3.31 KB)
📄 defs_freebsd.go(3.86 KB)
📄 defs_freebsd_386.go(4.38 KB)
📄 defs_freebsd_amd64.go(4.65 KB)
📄 defs_freebsd_arm.go(3.71 KB)
📄 defs_freebsd_arm64.go(4.03 KB)
📄 defs_illumos_amd64.go(285 B)
📄 defs_linux.go(3.05 KB)
📄 defs_linux_386.go(3.77 KB)
📄 defs_linux_amd64.go(4.28 KB)
📄 defs_linux_arm.go(3.45 KB)
📄 defs_linux_arm64.go(3.21 KB)
📄 defs_linux_mips64x.go(3.24 KB)
📄 defs_linux_mipsx.go(3.21 KB)
📄 defs_linux_ppc64.go(3.28 KB)
📄 defs_linux_ppc64le.go(3.28 KB)
📄 defs_linux_riscv64.go(3.27 KB)
📄 defs_linux_s390x.go(2.76 KB)
📄 defs_netbsd.go(2.76 KB)
📄 defs_netbsd_386.go(872 B)
📄 defs_netbsd_amd64.go(1.03 KB)
📄 defs_netbsd_arm.go(781 B)
📄 defs_openbsd.go(3.1 KB)
📄 defs_openbsd_386.go(2.89 KB)
📄 defs_openbsd_amd64.go(3.09 KB)
📄 defs_openbsd_arm.go(3 KB)
📄 defs_openbsd_arm64.go(2.76 KB)
📄 defs_openbsd_mips64.go(2.66 KB)
📄 defs_plan9_386.go(1.63 KB)
📄 defs_plan9_amd64.go(1.82 KB)
📄 defs_plan9_arm.go(1.73 KB)
📄 defs_solaris.go(3.35 KB)
📄 defs_solaris_amd64.go(1021 B)
📄 defs_windows.go(2.09 KB)
📄 defs_windows_386.go(1.98 KB)
📄 defs_windows_amd64.go(2.71 KB)
📄 defs_windows_arm.go(2.11 KB)
📄 defs_windows_arm64.go(2.63 KB)
📄 duff_386.s(8.24 KB)
📄 duff_amd64.s(5.62 KB)
📄 duff_arm.s(7.11 KB)
📄 duff_arm64.s(5.25 KB)
📄 duff_mips64x.s(11.31 KB)
📄 duff_ppc64x.s(2.43 KB)
📄 duff_riscv64.s(11.38 KB)
📄 duff_s390x.s(507 B)
📄 env_plan9.go(2.99 KB)
📄 env_posix.go(1.95 KB)
📄 env_test.go(1.16 KB)
📄 error.go(9.23 KB)
📄 example_test.go(1.55 KB)
📄 export_aix_test.go(204 B)
📄 export_arm_test.go(226 B)
📄 export_darwin_test.go(351 B)
📄 export_debug_regabiargs_off_test.go(416 B)
📄 export_debug_regabiargs_on_test.go(1.39 KB)
📄 export_debug_test.go(5.86 KB)
📄 export_debuglog_test.go(1.27 KB)
📄 export_futex_test.go(570 B)
📄 export_linux_test.go(429 B)
📄 export_mmap_test.go(571 B)
📄 export_pipe2_test.go(436 B)
📄 export_pipe_test.go(240 B)
📄 export_solaris_test.go(282 B)
📄 export_test.go(30.12 KB)
📄 export_unix_test.go(2.35 KB)
📄 export_windows_test.go(652 B)
📄 extern.go(12.58 KB)
📄 fastlog2.go(1.22 KB)
📄 fastlog2_test.go(784 B)
📄 fastlog2table.go(904 B)
📄 float.go(1.35 KB)
📄 funcdata.h(2.47 KB)
📄 futex_test.go(2.15 KB)
📄 gc_test.go(19.21 KB)
📄 gcinfo_test.go(5.69 KB)
📄 go_tls.h(366 B)
📄 hash32.go(1.61 KB)
📄 hash64.go(2.01 KB)
📄 hash_test.go(16.5 KB)
📄 heapdump.go(17.74 KB)
📄 histogram.go(6.42 KB)
📄 histogram_test.go(1.85 KB)
📄 iface.go(16.13 KB)
📄 iface_test.go(7.51 KB)
📁 internal
📄 lfstack.go(1.77 KB)
📄 lfstack_32bit.go(562 B)
📄 lfstack_64bit.go(2.24 KB)
📄 lfstack_test.go(2.78 KB)
📄 libfuzzer.go(2.6 KB)
📄 libfuzzer_amd64.s(961 B)
📄 libfuzzer_arm64.s(772 B)
📄 lock_futex.go(5.22 KB)
📄 lock_js.go(5.81 KB)
📄 lock_sema.go(6.8 KB)
📄 lockrank.go(11.62 KB)
📄 lockrank_off.go(1.17 KB)
📄 lockrank_on.go(9.84 KB)
📄 lockrank_test.go(1.15 KB)
📄 malloc.go(52.33 KB)
📄 malloc_test.go(10.83 KB)
📄 map.go(42.47 KB)
📄 map_benchmark_test.go(10.51 KB)
📄 map_fast32.go(12.63 KB)
📄 map_fast64.go(12.82 KB)
📄 map_faststr.go(14.15 KB)
📄 map_test.go(27.52 KB)
📄 mbarrier.go(12.2 KB)
📄 mbitmap.go(65.27 KB)
📄 mcache.go(9.68 KB)
📄 mcentral.go(7.8 KB)
📄 mcheckmark.go(2.81 KB)
📄 mem_aix.go(1.94 KB)
📄 mem_bsd.go(2.12 KB)
📄 mem_darwin.go(1.88 KB)
📄 mem_js.go(2.35 KB)
📄 mem_linux.go(5.59 KB)
📄 mem_plan9.go(4.53 KB)
📄 mem_windows.go(3.87 KB)
📄 memclr_386.s(2.42 KB)
📄 memclr_amd64.s(3.89 KB)
📄 memclr_arm.s(2.6 KB)
📄 memclr_arm64.s(3.65 KB)
📄 memclr_mips64x.s(1.75 KB)
📄 memclr_mipsx.s(1.35 KB)
📄 memclr_plan9_386.s(983 B)
📄 memclr_plan9_amd64.s(511 B)
📄 memclr_ppc64x.s(4.31 KB)
📄 memclr_riscv64.s(926 B)
📄 memclr_s390x.s(1.96 KB)
📄 memclr_wasm.s(622 B)
📄 memmove_386.s(4.46 KB)
📄 memmove_amd64.s(12.66 KB)
📄 memmove_arm.s(5.9 KB)
📄 memmove_arm64.s(6 KB)
📄 memmove_linux_amd64_test.go(1.6 KB)
📄 memmove_mips64x.s(1.85 KB)
📄 memmove_mipsx.s(4.42 KB)
📄 memmove_plan9_386.s(3.06 KB)
📄 memmove_plan9_amd64.s(3.04 KB)
📄 memmove_ppc64x.s(4.11 KB)
📄 memmove_riscv64.s(1.81 KB)
📄 memmove_s390x.s(2.92 KB)
📄 memmove_test.go(12.04 KB)
📄 memmove_wasm.s(1.74 KB)
📁 metrics
📄 metrics.go(17.69 KB)
📄 metrics_test.go(12.48 KB)
📄 mfinal.go(15.76 KB)
📄 mfinal_test.go(5.85 KB)
📄 mfixalloc.go(2.73 KB)
📄 mgc.go(55.18 KB)
📄 mgcmark.go(45.54 KB)
📄 mgcpacer.go(29.56 KB)
📄 mgcscavenge.go(35.05 KB)
📄 mgcscavenge_test.go(12.74 KB)
📄 mgcstack.go(10.58 KB)
📄 mgcsweep.go(23.56 KB)
📄 mgcwork.go(12.82 KB)
📄 mheap.go(66.31 KB)
📄 mkduff.go(7.19 KB)
📄 mkfastlog2table.go(1.32 KB)
📄 mkpreempt.go(14.17 KB)
📄 mksizeclasses.go(9.31 KB)
📄 mmap.go(990 B)
📄 mpagealloc.go(36.77 KB)
📄 mpagealloc_32bit.go(3.81 KB)
📄 mpagealloc_64bit.go(6.65 KB)
📄 mpagealloc_test.go(32.38 KB)
📄 mpagecache.go(5.28 KB)
📄 mpagecache_test.go(9.93 KB)
📄 mpallocbits.go(12.01 KB)
📄 mpallocbits_test.go(13.69 KB)
📄 mprof.go(25.82 KB)
📄 mranges.go(11.84 KB)
📄 mranges_test.go(5.68 KB)
📁 msan
📄 msan.go(1.51 KB)
📄 msan0.go(741 B)
📄 msan_amd64.s(2.32 KB)
📄 msan_arm64.s(2.01 KB)
📄 msize.go(777 B)
📄 mspanset.go(12.2 KB)
📄 mstats.go(30.65 KB)
📄 mwbbuf.go(9.3 KB)
📄 nbpipe_fcntl_libc_test.go(499 B)
📄 nbpipe_fcntl_unix_test.go(507 B)
📄 nbpipe_pipe.go(426 B)
📄 nbpipe_pipe2.go(592 B)
📄 nbpipe_test.go(2.26 KB)
📄 net_plan9.go(645 B)
📄 netpoll.go(16.24 KB)
📄 netpoll_aix.go(4.87 KB)
📄 netpoll_epoll.go(4.21 KB)
📄 netpoll_fake.go(670 B)
📄 netpoll_kqueue.go(4.64 KB)
📄 netpoll_os_test.go(360 B)
📄 netpoll_solaris.go(10.75 KB)
📄 netpoll_stub.go(1.42 KB)
📄 netpoll_windows.go(3.75 KB)
📄 norace_linux_test.go(905 B)
📄 norace_test.go(996 B)
📄 numcpu_freebsd_test.go(381 B)
📄 os2_aix.go(20.45 KB)
📄 os2_freebsd.go(302 B)
📄 os2_openbsd.go(296 B)
📄 os2_plan9.go(1.48 KB)
📄 os2_solaris.go(320 B)
📄 os3_plan9.go(3.88 KB)
📄 os3_solaris.go(17.02 KB)
📄 os_aix.go(8.06 KB)
📄 os_android.go(463 B)
📄 os_darwin.go(11.54 KB)
📄 os_darwin_arm64.go(416 B)
📄 os_dragonfly.go(6.46 KB)
📄 os_freebsd.go(11.2 KB)
📄 os_freebsd2.go(507 B)
📄 os_freebsd_amd64.go(529 B)
📄 os_freebsd_arm.go(1.32 KB)
📄 os_freebsd_arm64.go(398 B)
📄 os_freebsd_noauxv.go(264 B)
📄 os_illumos.go(3.93 KB)
📄 os_js.go(3.26 KB)
📄 os_linux.go(13.47 KB)
📄 os_linux_arm.go(1.35 KB)
📄 os_linux_arm64.go(572 B)
📄 os_linux_be64.go(862 B)
📄 os_linux_generic.go(950 B)
📄 os_linux_mips64x.go(1.11 KB)
📄 os_linux_mipsx.go(1.09 KB)
📄 os_linux_noauxv.go(408 B)
📄 os_linux_novdso.go(387 B)
📄 os_linux_ppc64x.go(566 B)
📄 os_linux_riscv64.go(198 B)
📄 os_linux_s390x.go(316 B)
📄 os_linux_x86.go(270 B)
📄 os_netbsd.go(9.09 KB)
📄 os_netbsd_386.go(588 B)
📄 os_netbsd_amd64.go(585 B)
📄 os_netbsd_arm.go(1.13 KB)
📄 os_netbsd_arm64.go(827 B)
📄 os_nonopenbsd.go(456 B)
📄 os_only_solaris.go(376 B)
📄 os_openbsd.go(6.01 KB)
📄 os_openbsd_arm.go(749 B)
📄 os_openbsd_arm64.go(416 B)
📄 os_openbsd_libc.go(1.7 KB)
📄 os_openbsd_mips64.go(416 B)
📄 os_openbsd_syscall.go(1.27 KB)
📄 os_openbsd_syscall1.go(466 B)
📄 os_openbsd_syscall2.go(2.5 KB)
📄 os_plan9.go(10.2 KB)
📄 os_plan9_arm.go(462 B)
📄 os_solaris.go(6.49 KB)
📄 os_windows.go(43.68 KB)
📄 os_windows_arm.go(511 B)
📄 os_windows_arm64.go(339 B)
📄 panic.go(44.28 KB)
📄 panic32.go(4.83 KB)
📄 panic_test.go(1.71 KB)
📄 plugin.go(4.27 KB)
📁 pprof
📄 preempt.go(15.4 KB)
📄 preempt_386.s(1.07 KB)
📄 preempt_amd64.s(1.81 KB)
📄 preempt_arm.s(1.66 KB)
📄 preempt_arm64.s(2.99 KB)
📄 preempt_mips64x.s(2.93 KB)
📄 preempt_mipsx.s(2.89 KB)
📄 preempt_nonwindows.go(309 B)
📄 preempt_ppc64x.s(2.92 KB)
📄 preempt_riscv64.s(2.48 KB)
📄 preempt_s390x.s(1.19 KB)
📄 preempt_wasm.s(365 B)
📄 print.go(5.95 KB)
📄 proc.go(181.46 KB)
📄 proc_runtime_test.go(820 B)
📄 proc_test.go(25.02 KB)
📄 profbuf.go(18.26 KB)
📄 profbuf_test.go(8.65 KB)
📄 proflabel.go(1.52 KB)
📁 race
📄 race.go(18.56 KB)
📄 race0.go(2.81 KB)
📄 race_amd64.s(14.46 KB)
📄 race_arm64.s(13.71 KB)
📄 race_ppc64le.s(17.72 KB)
📄 rand_test.go(783 B)
📄 rdebug.go(553 B)
📄 relax_stub.go(617 B)
📄 rt0_aix_ppc64.s(4.33 KB)
📄 rt0_android_386.s(822 B)
📄 rt0_android_amd64.s(754 B)
📄 rt0_android_arm.s(843 B)
📄 rt0_android_arm64.s(941 B)
📄 rt0_darwin_amd64.s(399 B)
📄 rt0_darwin_arm64.s(2.27 KB)
📄 rt0_dragonfly_amd64.s(448 B)
📄 rt0_freebsd_386.s(454 B)
📄 rt0_freebsd_amd64.s(442 B)
📄 rt0_freebsd_arm.s(298 B)
📄 rt0_freebsd_arm64.s(2.46 KB)
📄 rt0_illumos_amd64.s(311 B)
📄 rt0_ios_amd64.s(425 B)
📄 rt0_ios_arm64.s(425 B)
📄 rt0_js_wasm.s(2.3 KB)
📄 rt0_linux_386.s(450 B)
📄 rt0_linux_amd64.s(307 B)
📄 rt0_linux_arm.s(1007 B)
📄 rt0_linux_arm64.s(2.39 KB)
📄 rt0_linux_mips64x.s(1.03 KB)
📄 rt0_linux_mipsx.s(835 B)
📄 rt0_linux_ppc64.s(865 B)
📄 rt0_linux_ppc64le.s(3.88 KB)
📄 rt0_linux_riscv64.s(370 B)
📄 rt0_linux_s390x.s(676 B)
📄 rt0_netbsd_386.s(452 B)
📄 rt0_netbsd_amd64.s(309 B)
📄 rt0_netbsd_arm.s(296 B)
📄 rt0_netbsd_arm64.s(2.38 KB)
📄 rt0_openbsd_386.s(454 B)
📄 rt0_openbsd_amd64.s(311 B)
📄 rt0_openbsd_arm.s(298 B)
📄 rt0_openbsd_arm64.s(2.54 KB)
📄 rt0_openbsd_mips64.s(976 B)
📄 rt0_plan9_386.s(523 B)
📄 rt0_plan9_amd64.s(481 B)
📄 rt0_plan9_arm.s(397 B)
📄 rt0_solaris_amd64.s(311 B)
📄 rt0_windows_386.s(1.28 KB)
📄 rt0_windows_amd64.s(986 B)
📄 rt0_windows_arm.s(386 B)
📄 rt0_windows_arm64.s(725 B)
📄 runtime-gdb.py(15.02 KB)
📄 runtime-gdb_test.go(20.19 KB)
📄 runtime-lldb_test.go(4.95 KB)
📄 runtime.go(1.42 KB)
📄 runtime1.go(12.63 KB)
📄 runtime2.go(42.27 KB)
📄 runtime_linux_test.go(1.46 KB)
📄 runtime_mmap_test.go(1.91 KB)
📄 runtime_test.go(7.81 KB)
📄 runtime_unix_test.go(1.29 KB)
📄 rwmutex.go(3.53 KB)
📄 rwmutex_test.go(4.03 KB)
📄 select.go(14.45 KB)
📄 sema.go(16.08 KB)
📄 sema_test.go(2.5 KB)
📄 semasleep_test.go(1.65 KB)
📄 sigaction.go(543 B)
📄 signal_386.go(1.72 KB)
📄 signal_aix_ppc64.go(3.56 KB)
📄 signal_amd64.go(2.71 KB)
📄 signal_arm.go(2.56 KB)
📄 signal_arm64.go(3.16 KB)
📄 signal_darwin.go(2.13 KB)
📄 signal_darwin_amd64.go(3.85 KB)
📄 signal_darwin_arm64.go(3.6 KB)
📄 signal_dragonfly.go(2.17 KB)
📄 signal_dragonfly_amd64.go(2.01 KB)
📄 signal_freebsd.go(2.2 KB)
📄 signal_freebsd_386.go(1.55 KB)
📄 signal_freebsd_amd64.go(2.03 KB)
📄 signal_freebsd_arm.go(2.18 KB)
📄 signal_freebsd_arm64.go(3.23 KB)
📄 signal_linux_386.go(1.59 KB)
📄 signal_linux_amd64.go(2.05 KB)
📄 signal_linux_arm.go(2.13 KB)
📄 signal_linux_arm64.go(2.95 KB)
📄 signal_linux_mips64x.go(3.39 KB)
📄 signal_linux_mipsx.go(3.7 KB)
📄 signal_linux_ppc64x.go(3.46 KB)
📄 signal_linux_riscv64.go(2.92 KB)
📄 signal_linux_s390x.go(4.43 KB)
📄 signal_mips64x.go(3.2 KB)
📄 signal_mipsx.go(3.07 KB)
📄 signal_netbsd.go(2.18 KB)
📄 signal_netbsd_386.go(1.76 KB)
📄 signal_netbsd_amd64.go(2.33 KB)
📄 signal_netbsd_arm.go(2.3 KB)
📄 signal_netbsd_arm64.go(3.4 KB)
📄 signal_openbsd.go(2.18 KB)
📄 signal_openbsd_386.go(1.58 KB)
📄 signal_openbsd_amd64.go(2.04 KB)
📄 signal_openbsd_arm.go(2.12 KB)
📄 signal_openbsd_arm64.go(3.38 KB)
📄 signal_openbsd_mips64.go(3.28 KB)
📄 signal_plan9.go(1.93 KB)
📄 signal_ppc64x.go(3.64 KB)
📄 signal_riscv64.go(2.88 KB)
📄 signal_solaris.go(4.5 KB)
📄 signal_solaris_amd64.go(2.47 KB)
📄 signal_unix.go(37.82 KB)
📄 signal_windows.go(9.2 KB)
📄 signal_windows_test.go(5.73 KB)
📄 sigqueue.go(8.76 KB)
📄 sigqueue_note.go(673 B)
📄 sigqueue_plan9.go(3.39 KB)
📄 sigtab_aix.go(11.3 KB)
📄 sigtab_linux_generic.go(3.56 KB)
📄 sigtab_linux_mipsx.go(6.01 KB)
📄 sizeclasses.go(9.14 KB)
📄 sizeof_test.go(905 B)
📄 slice.go(8.94 KB)
📄 slice_test.go(10.32 KB)
📄 softfloat64.go(10.78 KB)
📄 softfloat64_test.go(4.05 KB)
📄 stack.go(41.92 KB)
📄 stack_test.go(21.05 KB)
📄 string.go(10.85 KB)
📄 string_test.go(9.62 KB)
📄 stubs.go(18.17 KB)
📄 stubs2.go(1.14 KB)
📄 stubs3.go(331 B)
📄 stubs_386.go(550 B)
📄 stubs_amd64.go(1.2 KB)
📄 stubs_arm.go(531 B)
📄 stubs_arm64.go(351 B)
📄 stubs_linux.go(663 B)
📄 stubs_mips64x.go(390 B)
📄 stubs_mipsx.go(305 B)
📄 stubs_nonlinux.go(315 B)
📄 stubs_ppc64.go(383 B)
📄 stubs_ppc64le.go(271 B)
📄 stubs_s390x.go(256 B)
📄 symtab.go(32.29 KB)
📄 symtab_test.go(6.78 KB)
📄 sys_aix_ppc64.s(7.13 KB)
📄 sys_arm.go(521 B)
📄 sys_arm64.go(469 B)
📄 sys_darwin.go(15.91 KB)
📄 sys_darwin_amd64.s(18.52 KB)
📄 sys_darwin_arm64.go(1.68 KB)
📄 sys_darwin_arm64.s(17.23 KB)
📄 sys_dragonfly_amd64.s(8.42 KB)
📄 sys_freebsd_386.s(8.98 KB)
📄 sys_freebsd_amd64.s(10.55 KB)
📄 sys_freebsd_arm.s(10.69 KB)
📄 sys_freebsd_arm64.s(10.33 KB)
📄 sys_libc.go(1.87 KB)
📄 sys_linux_386.s(18.17 KB)
📄 sys_linux_amd64.s(16.25 KB)
📄 sys_linux_arm.s(15.84 KB)
📄 sys_linux_arm64.s(15.26 KB)
📄 sys_linux_mips64x.s(13.4 KB)
📄 sys_linux_mipsx.s(11.16 KB)
📄 sys_linux_ppc64x.s(21.48 KB)
📄 sys_linux_riscv64.s(10.35 KB)
📄 sys_linux_s390x.s(10.52 KB)
📄 sys_mips64x.go(526 B)
📄 sys_mipsx.go(518 B)
📄 sys_netbsd_386.s(10.13 KB)
📄 sys_netbsd_amd64.s(9.91 KB)
📄 sys_netbsd_arm.s(10.94 KB)
📄 sys_netbsd_arm64.s(10.42 KB)
📄 sys_nonppc64x.go(271 B)
📄 sys_openbsd.go(2.3 KB)
📄 sys_openbsd1.go(1.16 KB)
📄 sys_openbsd2.go(7.31 KB)
📄 sys_openbsd3.go(3.29 KB)
📄 sys_openbsd_386.s(19.97 KB)
📄 sys_openbsd_amd64.s(16.44 KB)
📄 sys_openbsd_arm.s(18.09 KB)
📄 sys_openbsd_arm64.s(15.92 KB)
📄 sys_openbsd_mips64.s(9.22 KB)
📄 sys_plan9_386.s(4.4 KB)
📄 sys_plan9_amd64.s(4.47 KB)
📄 sys_plan9_arm.s(7.03 KB)
📄 sys_ppc64x.go(556 B)
📄 sys_riscv64.go(469 B)
📄 sys_s390x.go(469 B)
📄 sys_solaris_amd64.s(6.69 KB)
📄 sys_wasm.go(732 B)
📄 sys_wasm.s(2.65 KB)
📄 sys_windows_386.s(7.74 KB)
📄 sys_windows_amd64.s(9.16 KB)
📄 sys_windows_arm.s(12.02 KB)
📄 sys_windows_arm64.s(12.51 KB)
📄 sys_x86.go(574 B)
📄 syscall2_solaris.go(1.65 KB)
📄 syscall_aix.go(5.99 KB)
📄 syscall_solaris.go(8.26 KB)
📄 syscall_windows.go(16.48 KB)
📄 syscall_windows_test.go(32.53 KB)
📁 testdata
📄 textflag.h(1.52 KB)
📄 time.go(30.56 KB)
📄 time_fake.go(2.38 KB)
📄 time_linux_amd64.s(2.18 KB)
📄 time_nofake.go(587 B)
📄 time_test.go(2.03 KB)
📄 time_windows.h(694 B)
📄 time_windows_386.s(1.81 KB)
📄 time_windows_amd64.s(1.07 KB)
📄 time_windows_arm.s(2.07 KB)
📄 time_windows_arm64.s(1.33 KB)
📄 timeasm.go(468 B)
📄 timestub.go(595 B)
📄 timestub2.go(447 B)
📄 tls_arm.s(3.33 KB)
📄 tls_arm64.h(1.22 KB)
📄 tls_arm64.s(1.2 KB)
📄 tls_mips64x.s(759 B)
📄 tls_mipsx.s(731 B)
📄 tls_ppc64x.s(1.52 KB)
📄 tls_riscv64.s(726 B)
📄 tls_s390x.s(1.55 KB)
📄 tls_stub.go(294 B)
📄 tls_windows_amd64.go(294 B)
📁 trace
📄 trace.go(38.36 KB)
📄 traceback.go(46.51 KB)
📄 traceback_test.go(8.04 KB)
📄 type.go(18.59 KB)
📄 typekind.go(742 B)
📄 utf8.go(3.39 KB)
📄 vdso_elf32.go(2.79 KB)
📄 vdso_elf64.go(2.87 KB)
📄 vdso_freebsd.go(2.46 KB)
📄 vdso_freebsd_arm.go(454 B)
📄 vdso_freebsd_arm64.go(443 B)
📄 vdso_freebsd_x86.go(1.89 KB)
📄 vdso_in_none.go(490 B)
📄 vdso_linux.go(7.77 KB)
📄 vdso_linux_386.go(669 B)
📄 vdso_linux_amd64.go(685 B)
📄 vdso_linux_arm.go(669 B)
📄 vdso_linux_arm64.go(670 B)
📄 vdso_linux_mips64x.go(892 B)
📄 vdso_linux_ppc64x.go(712 B)
📄 vlop_386.s(2.02 KB)
📄 vlop_arm.s(7.06 KB)
📄 vlop_arm_test.go(3.75 KB)
📄 vlrt.go(5.91 KB)
📄 wincallback.go(3.52 KB)
📄 write_err.go(310 B)
📄 write_err_android.go(4.65 KB)
📄 zcallback_windows.go(155 B)
📄 zcallback_windows.s(63.05 KB)
📄 zcallback_windows_arm.s(89.34 KB)
📄 zcallback_windows_arm64.s(89.34 KB)

Editing: cgocall.go

// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Cgo call and callback support.
//
// To call into the C function f from Go, the cgo-generated code calls
// runtime.cgocall(_cgo_Cfunc_f, frame), where _cgo_Cfunc_f is a
// gcc-compiled function written by cgo.
//
// runtime.cgocall (below) calls entersyscall so as not to block
// other goroutines or the garbage collector, and then calls
// runtime.asmcgocall(_cgo_Cfunc_f, frame).
//
// runtime.asmcgocall (in asm_$GOARCH.s) switches to the m->g0 stack
// (assumed to be an operating system-allocated stack, so safe to run
// gcc-compiled code on) and calls _cgo_Cfunc_f(frame).
//
// _cgo_Cfunc_f invokes the actual C function f with arguments
// taken from the frame structure, records the results in the frame,
// and returns to runtime.asmcgocall.
//
// After it regains control, runtime.asmcgocall switches back to the
// original g (m->curg)'s stack and returns to runtime.cgocall.
//
// After it regains control, runtime.cgocall calls exitsyscall, which blocks
// until this m can run Go code without violating the $GOMAXPROCS limit,
// and then unlocks g from m.
//
// The above description skipped over the possibility of the gcc-compiled
// function f calling back into Go. If that happens, we continue down
// the rabbit hole during the execution of f.
//
// To make it possible for gcc-compiled C code to call a Go function p.GoF,
// cgo writes a gcc-compiled function named GoF (not p.GoF, since gcc doesn't
// know about packages).  The gcc-compiled C function f calls GoF.
//
// GoF initializes "frame", a structure containing all of its
// arguments and slots for p.GoF's results. It calls
// crosscall2(_cgoexp_GoF, frame, framesize, ctxt) using the gcc ABI.
//
// crosscall2 (in cgo/asm_$GOARCH.s) is a four-argument adapter from
// the gcc function call ABI to the gc function call ABI. At this
// point we're in the Go runtime, but we're still running on m.g0's
// stack and outside the $GOMAXPROCS limit. crosscall2 calls
// runtime.cgocallback(_cgoexp_GoF, frame, ctxt) using the gc ABI.
// (crosscall2's framesize argument is no longer used, but there's one
// case where SWIG calls crosscall2 directly and expects to pass this
// argument. See _cgo_panic.)
//
// runtime.cgocallback (in asm_$GOARCH.s) switches from m.g0's stack
// to the original g (m.curg)'s stack, on which it calls
// runtime.cgocallbackg(_cgoexp_GoF, frame, ctxt). As part of the
// stack switch, runtime.cgocallback saves the current SP as
// m.g0.sched.sp, so that any use of m.g0's stack during the execution
// of the callback will be done below the existing stack frames.
// Before overwriting m.g0.sched.sp, it pushes the old value on the
// m.g0 stack, so that it can be restored later.
//
// runtime.cgocallbackg (below) is now running on a real goroutine
// stack (not an m.g0 stack).  First it calls runtime.exitsyscall, which will
// block until the $GOMAXPROCS limit allows running this goroutine.
// Once exitsyscall has returned, it is safe to do things like call the memory
// allocator or invoke the Go callback function.  runtime.cgocallbackg
// first defers a function to unwind m.g0.sched.sp, so that if p.GoF
// panics, m.g0.sched.sp will be restored to its old value: the m.g0 stack
// and the m.curg stack will be unwound in lock step.
// Then it calls _cgoexp_GoF(frame).
//
// _cgoexp_GoF, which was generated by cmd/cgo, unpacks the arguments
// from frame, calls p.GoF, writes the results back to frame, and
// returns. Now we start unwinding this whole process.
//
// runtime.cgocallbackg pops but does not execute the deferred
// function to unwind m.g0.sched.sp, calls runtime.entersyscall, and
// returns to runtime.cgocallback.
//
// After it regains control, runtime.cgocallback switches back to
// m.g0's stack (the pointer is still in m.g0.sched.sp), restores the old
// m.g0.sched.sp value from the stack, and returns to crosscall2.
//
// crosscall2 restores the callee-save registers for gcc and returns
// to GoF, which unpacks any result values and returns to f.

package runtime

import (
	"runtime/internal/atomic"
	"runtime/internal/sys"
	"unsafe"
)

// Addresses collected in a cgo backtrace when crashing.
// Length must match arg.Max in x_cgo_callers in runtime/cgo/gcc_traceback.c.
type cgoCallers [32]uintptr

// argset matches runtime/cgo/linux_syscall.c:argset_t
type argset struct {
	args   unsafe.Pointer
	retval uintptr
}

// wrapper for syscall package to call cgocall for libc (cgo) calls.
//go:linkname syscall_cgocaller syscall.cgocaller
//go:nosplit
//go:uintptrescapes
func syscall_cgocaller(fn unsafe.Pointer, args ...uintptr) uintptr {
	as := argset{args: unsafe.Pointer(&args[0])}
	cgocall(fn, unsafe.Pointer(&as))
	return as.retval
}

var ncgocall uint64 // number of cgo calls in total for dead m

// Call from Go to C.
//
// This must be nosplit because it's used for syscalls on some
// platforms. Syscalls may have untyped arguments on the stack, so
// it's not safe to grow or scan the stack.
//
//go:nosplit
func cgocall(fn, arg unsafe.Pointer) int32 {
	if !iscgo && GOOS != "solaris" && GOOS != "illumos" && GOOS != "windows" {
		throw("cgocall unavailable")
	}

if fn == nil {
		throw("cgocall nil")
	}

if raceenabled {
		racereleasemerge(unsafe.Pointer(&racecgosync))
	}

mp := getg().m
	mp.ncgocall++
	mp.ncgo++

// Reset traceback.
	mp.cgoCallers[0] = 0

// Announce we are entering a system call
	// so that the scheduler knows to create another
	// M to run goroutines while we are in the
	// foreign code.
	//
	// The call to asmcgocall is guaranteed not to
	// grow the stack and does not allocate memory,
	// so it is safe to call while "in a system call", outside
	// the $GOMAXPROCS accounting.
	//
	// fn may call back into Go code, in which case we'll exit the
	// "system call", run the Go code (which may grow the stack),
	// and then re-enter the "system call" reusing the PC and SP
	// saved by entersyscall here.
	entersyscall()

// Tell asynchronous preemption that we're entering external
	// code. We do this after entersyscall because this may block
	// and cause an async preemption to fail, but at this point a
	// sync preemption will succeed (though this is not a matter
	// of correctness).
	osPreemptExtEnter(mp)

mp.incgo = true
	errno := asmcgocall(fn, arg)

// Update accounting before exitsyscall because exitsyscall may
	// reschedule us on to a different M.
	mp.incgo = false
	mp.ncgo--

osPreemptExtExit(mp)

exitsyscall()

// Note that raceacquire must be called only after exitsyscall has
	// wired this M to a P.
	if raceenabled {
		raceacquire(unsafe.Pointer(&racecgosync))
	}

// From the garbage collector's perspective, time can move
	// backwards in the sequence above. If there's a callback into
	// Go code, GC will see this function at the call to
	// asmcgocall. When the Go call later returns to C, the
	// syscall PC/SP is rolled back and the GC sees this function
	// back at the call to entersyscall. Normally, fn and arg
	// would be live at entersyscall and dead at asmcgocall, so if
	// time moved backwards, GC would see these arguments as dead
	// and then live. Prevent these undead arguments from crashing
	// GC by forcing them to stay live across this time warp.
	KeepAlive(fn)
	KeepAlive(arg)
	KeepAlive(mp)

return errno
}

// Call from C back to Go. fn must point to an ABIInternal Go entry-point.
//go:nosplit
func cgocallbackg(fn, frame unsafe.Pointer, ctxt uintptr) {
	gp := getg()
	if gp != gp.m.curg {
		println("runtime: bad g in cgocallback")
		exit(2)
	}

// The call from C is on gp.m's g0 stack, so we must ensure
	// that we stay on that M. We have to do this before calling
	// exitsyscall, since it would otherwise be free to move us to
	// a different M. The call to unlockOSThread is in unwindm.
	lockOSThread()

checkm := gp.m

// Save current syscall parameters, so m.syscall can be
	// used again if callback decide to make syscall.
	syscall := gp.m.syscall

// entersyscall saves the caller's SP to allow the GC to trace the Go
	// stack. However, since we're returning to an earlier stack frame and
	// need to pair with the entersyscall() call made by cgocall, we must
	// save syscall* and let reentersyscall restore them.
	savedsp := unsafe.Pointer(gp.syscallsp)
	savedpc := gp.syscallpc
	exitsyscall() // coming out of cgo call
	gp.m.incgo = false

osPreemptExtExit(gp.m)

cgocallbackg1(fn, frame, ctxt) // will call unlockOSThread

// At this point unlockOSThread has been called.
	// The following code must not change to a different m.
	// This is enforced by checking incgo in the schedule function.

gp.m.incgo = true

if gp.m != checkm {
		throw("m changed unexpectedly in cgocallbackg")
	}

osPreemptExtEnter(gp.m)

// going back to cgo call
	reentersyscall(savedpc, uintptr(savedsp))

gp.m.syscall = syscall
}

func cgocallbackg1(fn, frame unsafe.Pointer, ctxt uintptr) {
	gp := getg()

// When we return, undo the call to lockOSThread in cgocallbackg.
	// We must still stay on the same m.
	defer unlockOSThread()

if gp.m.needextram || atomic.Load(&extraMWaiters) > 0 {
		gp.m.needextram = false
		systemstack(newextram)
	}

if ctxt != 0 {
		s := append(gp.cgoCtxt, ctxt)

// Now we need to set gp.cgoCtxt = s, but we could get
		// a SIGPROF signal while manipulating the slice, and
		// the SIGPROF handler could pick up gp.cgoCtxt while
		// tracing up the stack.  We need to ensure that the
		// handler always sees a valid slice, so set the
		// values in an order such that it always does.
		p := (*slice)(unsafe.Pointer(&gp.cgoCtxt))
		atomicstorep(unsafe.Pointer(&p.array), unsafe.Pointer(&s[0]))
		p.cap = cap(s)
		p.len = len(s)

defer func(gp *g) {
			// Decrease the length of the slice by one, safely.
			p := (*slice)(unsafe.Pointer(&gp.cgoCtxt))
			p.len--
		}(gp)
	}

if gp.m.ncgo == 0 {
		// The C call to Go came from a thread not currently running
		// any Go. In the case of -buildmode=c-archive or c-shared,
		// this call may be coming in before package initialization
		// is complete. Wait until it is.
		<-main_init_done
	}

// Add entry to defer stack in case of panic.
	restore := true
	defer unwindm(&restore)

if raceenabled {
		raceacquire(unsafe.Pointer(&racecgosync))
	}

// Invoke callback. This function is generated by cmd/cgo and
	// will unpack the argument frame and call the Go function.
	var cb func(frame unsafe.Pointer)
	cbFV := funcval{uintptr(fn)}
	*(*unsafe.Pointer)(unsafe.Pointer(&cb)) = noescape(unsafe.Pointer(&cbFV))
	cb(frame)

if raceenabled {
		racereleasemerge(unsafe.Pointer(&racecgosync))
	}

// Do not unwind m->g0->sched.sp.
	// Our caller, cgocallback, will do that.
	restore = false
}

func unwindm(restore *bool) {
	if *restore {
		// Restore sp saved by cgocallback during
		// unwind of g's stack (see comment at top of file).
		mp := acquirem()
		sched := &mp.g0.sched
		sched.sp = *(*uintptr)(unsafe.Pointer(sched.sp + alignUp(sys.MinFrameSize, sys.StackAlign)))

// Do the accounting that cgocall will not have a chance to do
		// during an unwind.
		//
		// In the case where a Go call originates from C, ncgo is 0
		// and there is no matching cgocall to end.
		if mp.ncgo > 0 {
			mp.incgo = false
			mp.ncgo--
			osPreemptExtExit(mp)
		}

releasem(mp)
	}
}

// called from assembly
func badcgocallback() {
	throw("misaligned stack in cgocallback")
}

// called from (incomplete) assembly
func cgounimpl() {
	throw("cgo not implemented")
}

var racecgosync uint64 // represents possible synchronization in C code

// Pointer checking for cgo code.

// We want to detect all cases where a program that does not use
// unsafe makes a cgo call passing a Go pointer to memory that
// contains a Go pointer. Here a Go pointer is defined as a pointer
// to memory allocated by the Go runtime. Programs that use unsafe
// can evade this restriction easily, so we don't try to catch them.
// The cgo program will rewrite all possibly bad pointer arguments to
// call cgoCheckPointer, where we can catch cases of a Go pointer
// pointing to a Go pointer.

// Complicating matters, taking the address of a slice or array
// element permits the C program to access all elements of the slice
// or array. In that case we will see a pointer to a single element,
// but we need to check the entire data structure.

// The cgoCheckPointer call takes additional arguments indicating that
// it was called on an address expression. An additional argument of
// true means that it only needs to check a single element. An
// additional argument of a slice or array means that it needs to
// check the entire slice/array, but nothing else. Otherwise, the
// pointer could be anything, and we check the entire heap object,
// which is conservative but safe.

// When and if we implement a moving garbage collector,
// cgoCheckPointer will pin the pointer for the duration of the cgo
// call.  (This is necessary but not sufficient; the cgo program will
// also have to change to pin Go pointers that cannot point to Go
// pointers.)

// cgoCheckPointer checks if the argument contains a Go pointer that
// points to a Go pointer, and panics if it does.
func cgoCheckPointer(ptr interface{}, arg interface{}) {
	if debug.cgocheck == 0 {
		return
	}

ep := efaceOf(&ptr)
	t := ep._type

top := true
	if arg != nil && (t.kind&kindMask == kindPtr || t.kind&kindMask == kindUnsafePointer) {
		p := ep.data
		if t.kind&kindDirectIface == 0 {
			p = *(*unsafe.Pointer)(p)
		}
		if p == nil || !cgoIsGoPointer(p) {
			return
		}
		aep := efaceOf(&arg)
		switch aep._type.kind & kindMask {
		case kindBool:
			if t.kind&kindMask == kindUnsafePointer {
				// We don't know the type of the element.
				break
			}
			pt := (*ptrtype)(unsafe.Pointer(t))
			cgoCheckArg(pt.elem, p, true, false, cgoCheckPointerFail)
			return
		case kindSlice:
			// Check the slice rather than the pointer.
			ep = aep
			t = ep._type
		case kindArray:
			// Check the array rather than the pointer.
			// Pass top as false since we have a pointer
			// to the array.
			ep = aep
			t = ep._type
			top = false
		default:
			throw("can't happen")
		}
	}

cgoCheckArg(t, ep.data, t.kind&kindDirectIface == 0, top, cgoCheckPointerFail)
}

const cgoCheckPointerFail = "cgo argument has Go pointer to Go pointer"
const cgoResultFail = "cgo result has Go pointer"

// cgoCheckArg is the real work of cgoCheckPointer. The argument p
// is either a pointer to the value (of type t), or the value itself,
// depending on indir. The top parameter is whether we are at the top
// level, where Go pointers are allowed.
func cgoCheckArg(t *_type, p unsafe.Pointer, indir, top bool, msg string) {
	if t.ptrdata == 0 || p == nil {
		// If the type has no pointers there is nothing to do.
		return
	}

switch t.kind & kindMask {
	default:
		throw("can't happen")
	case kindArray:
		at := (*arraytype)(unsafe.Pointer(t))
		if !indir {
			if at.len != 1 {
				throw("can't happen")
			}
			cgoCheckArg(at.elem, p, at.elem.kind&kindDirectIface == 0, top, msg)
			return
		}
		for i := uintptr(0); i < at.len; i++ {
			cgoCheckArg(at.elem, p, true, top, msg)
			p = add(p, at.elem.size)
		}
	case kindChan, kindMap:
		// These types contain internal pointers that will
		// always be allocated in the Go heap. It's never OK
		// to pass them to C.
		panic(errorString(msg))
	case kindFunc:
		if indir {
			p = *(*unsafe.Pointer)(p)
		}
		if !cgoIsGoPointer(p) {
			return
		}
		panic(errorString(msg))
	case kindInterface:
		it := *(**_type)(p)
		if it == nil {
			return
		}
		// A type known at compile time is OK since it's
		// constant. A type not known at compile time will be
		// in the heap and will not be OK.
		if inheap(uintptr(unsafe.Pointer(it))) {
			panic(errorString(msg))
		}
		p = *(*unsafe.Pointer)(add(p, sys.PtrSize))
		if !cgoIsGoPointer(p) {
			return
		}
		if !top {
			panic(errorString(msg))
		}
		cgoCheckArg(it, p, it.kind&kindDirectIface == 0, false, msg)
	case kindSlice:
		st := (*slicetype)(unsafe.Pointer(t))
		s := (*slice)(p)
		p = s.array
		if p == nil || !cgoIsGoPointer(p) {
			return
		}
		if !top {
			panic(errorString(msg))
		}
		if st.elem.ptrdata == 0 {
			return
		}
		for i := 0; i < s.cap; i++ {
			cgoCheckArg(st.elem, p, true, false, msg)
			p = add(p, st.elem.size)
		}
	case kindString:
		ss := (*stringStruct)(p)
		if !cgoIsGoPointer(ss.str) {
			return
		}
		if !top {
			panic(errorString(msg))
		}
	case kindStruct:
		st := (*structtype)(unsafe.Pointer(t))
		if !indir {
			if len(st.fields) != 1 {
				throw("can't happen")
			}
			cgoCheckArg(st.fields[0].typ, p, st.fields[0].typ.kind&kindDirectIface == 0, top, msg)
			return
		}
		for _, f := range st.fields {
			if f.typ.ptrdata == 0 {
				continue
			}
			cgoCheckArg(f.typ, add(p, f.offset()), true, top, msg)
		}
	case kindPtr, kindUnsafePointer:
		if indir {
			p = *(*unsafe.Pointer)(p)
			if p == nil {
				return
			}
		}

if !cgoIsGoPointer(p) {
			return
		}
		if !top {
			panic(errorString(msg))
		}

cgoCheckUnknownPointer(p, msg)
	}
}

// cgoCheckUnknownPointer is called for an arbitrary pointer into Go
// memory. It checks whether that Go memory contains any other
// pointer into Go memory. If it does, we panic.
// The return values are unused but useful to see in panic tracebacks.
func cgoCheckUnknownPointer(p unsafe.Pointer, msg string) (base, i uintptr) {
	if inheap(uintptr(p)) {
		b, span, _ := findObject(uintptr(p), 0, 0)
		base = b
		if base == 0 {
			return
		}
		hbits := heapBitsForAddr(base)
		n := span.elemsize
		for i = uintptr(0); i < n; i += sys.PtrSize {
			if !hbits.morePointers() {
				// No more possible pointers.
				break
			}
			if hbits.isPointer() && cgoIsGoPointer(*(*unsafe.Pointer)(unsafe.Pointer(base + i))) {
				panic(errorString(msg))
			}
			hbits = hbits.next()
		}

return
	}

for _, datap := range activeModules() {
		if cgoInRange(p, datap.data, datap.edata) || cgoInRange(p, datap.bss, datap.ebss) {
			// We have no way to know the size of the object.
			// We have to assume that it might contain a pointer.
			panic(errorString(msg))
		}
		// In the text or noptr sections, we know that the
		// pointer does not point to a Go pointer.
	}

return
}

// cgoIsGoPointer reports whether the pointer is a Go pointer--a
// pointer to Go memory. We only care about Go memory that might
// contain pointers.
//go:nosplit
//go:nowritebarrierrec
func cgoIsGoPointer(p unsafe.Pointer) bool {
	if p == nil {
		return false
	}

if inHeapOrStack(uintptr(p)) {
		return true
	}

for _, datap := range activeModules() {
		if cgoInRange(p, datap.data, datap.edata) || cgoInRange(p, datap.bss, datap.ebss) {
			return true
		}
	}

return false
}

// cgoInRange reports whether p is between start and end.
//go:nosplit
//go:nowritebarrierrec
func cgoInRange(p unsafe.Pointer, start, end uintptr) bool {
	return start <= uintptr(p) && uintptr(p) < end
}

// cgoCheckResult is called to check the result parameter of an
// exported Go function. It panics if the result is or contains a Go
// pointer.
func cgoCheckResult(val interface{}) {
	if debug.cgocheck == 0 {
		return
	}

ep := efaceOf(&val)
	t := ep._type
	cgoCheckArg(t, ep.data, t.kind&kindDirectIface == 0, false, cgoResultFail)
}

X7ROOT File Manager

Editing: cgocall.go

Upload File

Create Folder