github.com/ebitengine/purego@v0.8.0-alpha.2.0.20240512170805-6cd12240d332/internal/fakecgo/go_linux_arm64.go (about)

     1  // Copyright 2011 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  //go:build !cgo
     6  
     7  package fakecgo
     8  
     9  import "unsafe"
    10  
    11  //go:nosplit
    12  func _cgo_sys_thread_start(ts *ThreadStart) {
    13  	var attr pthread_attr_t
    14  	var ign, oset sigset_t
    15  	var p pthread_t
    16  	var size size_t
    17  	var err int
    18  
    19  	//fprintf(stderr, "runtime/cgo: _cgo_sys_thread_start: fn=%p, g=%p\n", ts->fn, ts->g); // debug
    20  	sigfillset(&ign)
    21  	pthread_sigmask(SIG_SETMASK, &ign, &oset)
    22  
    23  	pthread_attr_init(&attr)
    24  	pthread_attr_getstacksize(&attr, &size)
    25  	// Leave stacklo=0 and set stackhi=size; mstart will do the rest.
    26  	ts.g.stackhi = uintptr(size)
    27  
    28  	err = _cgo_try_pthread_create(&p, &attr, unsafe.Pointer(threadentry_trampolineABI0), ts)
    29  
    30  	pthread_sigmask(SIG_SETMASK, &oset, nil)
    31  
    32  	if err != 0 {
    33  		print("fakecgo: pthread_create failed: ")
    34  		println(err)
    35  		abort()
    36  	}
    37  }
    38  
    39  // threadentry_trampolineABI0 maps the C ABI to Go ABI then calls the Go function
    40  //
    41  //go:linkname x_threadentry_trampoline threadentry_trampoline
    42  var x_threadentry_trampoline byte
    43  var threadentry_trampolineABI0 = &x_threadentry_trampoline
    44  
    45  //go:nosplit
    46  func threadentry(v unsafe.Pointer) unsafe.Pointer {
    47  	ts := *(*ThreadStart)(v)
    48  	free(v)
    49  
    50  	setg_trampoline(setg_func, uintptr(unsafe.Pointer(ts.g)))
    51  
    52  	// faking funcs in go is a bit a... involved - but the following works :)
    53  	fn := uintptr(unsafe.Pointer(&ts.fn))
    54  	(*(*func())(unsafe.Pointer(&fn)))()
    55  
    56  	return nil
    57  }
    58  
    59  // here we will store a pointer to the provided setg func
    60  var setg_func uintptr
    61  
    62  // x_cgo_init(G *g, void (*setg)(void*)) (runtime/cgo/gcc_linux_amd64.c)
    63  // This get's called during startup, adjusts stacklo, and provides a pointer to setg_gcc for us
    64  // Additionally, if we set _cgo_init to non-null, go won't do it's own TLS setup
    65  // This function can't be go:systemstack since go is not in a state where the systemcheck would work.
    66  //
    67  //go:nosplit
    68  func x_cgo_init(g *G, setg uintptr) {
    69  	var size size_t
    70  	var attr *pthread_attr_t
    71  
    72  	/* The memory sanitizer distributed with versions of clang
    73  	   before 3.8 has a bug: if you call mmap before malloc, mmap
    74  	   may return an address that is later overwritten by the msan
    75  	   library.  Avoid this problem by forcing a call to malloc
    76  	   here, before we ever call malloc.
    77  
    78  	   This is only required for the memory sanitizer, so it's
    79  	   unfortunate that we always run it.  It should be possible
    80  	   to remove this when we no longer care about versions of
    81  	   clang before 3.8.  The test for this is
    82  	   misc/cgo/testsanitizers.
    83  
    84  	   GCC works hard to eliminate a seemingly unnecessary call to
    85  	   malloc, so we actually use the memory we allocate.  */
    86  
    87  	setg_func = setg
    88  	attr = (*pthread_attr_t)(malloc(unsafe.Sizeof(*attr)))
    89  	if attr == nil {
    90  		println("fakecgo: malloc failed")
    91  		abort()
    92  	}
    93  	pthread_attr_init(attr)
    94  	pthread_attr_getstacksize(attr, &size)
    95  	g.stacklo = uintptr(unsafe.Pointer(&size)) - uintptr(size) + 4096
    96  	pthread_attr_destroy(attr)
    97  	free(unsafe.Pointer(attr))
    98  }