gcc/libgo/runtime/go-trampoline.c

114 lines
3.0 KiB
C
Raw Normal View History

/* go-trampoline.c -- allocate a trampoline for a nested function.
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. */
#include "config.h"
#include <stddef.h>
#include <stdint.h>
#include <unistd.h>
#ifdef HAVE_SYS_MMAN_H
#include <sys/mman.h>
#endif
#include "runtime.h"
#include "arch.h"
#include "malloc.h"
#include "go-assert.h"
/* Trampolines need to run in memory that is both writable and
executable. In order to implement them, we grab a page of memory
and mprotect it. We fill in the page with trampolines as they are
required. When we run out of space, we drop the pointer to the
page and allocate a new one. The page will be freed by the garbage
collector when there are no more variables of type func pointing to
it. */
/* A lock to control access to the page of closures. */
static Lock trampoline_lock;
/* The page of closures. */
static unsigned char *trampoline_page;
/* The size of trampoline_page. */
static uintptr_t trampoline_page_size;
/* The number of bytes we have used on trampoline_page. */
static uintptr_t trampoline_page_used;
/* Allocate a trampoline of SIZE bytes that will use the closure in
CLOSURE. */
void *
__go_allocate_trampoline (uintptr_t size, void *closure)
{
uintptr_t ptr_size;
uintptr_t full_size;
unsigned char *ret;
/* Because the garbage collector only looks at aligned addresses, we
need to store the closure at an aligned address to ensure that it
sees it. */
ptr_size = sizeof (void *);
full_size = (((size + ptr_size - 1) / ptr_size) * ptr_size);
full_size += ptr_size;
runtime_lock (&trampoline_lock);
if (full_size < trampoline_page_size - trampoline_page_used)
trampoline_page = NULL;
if (trampoline_page == NULL)
{
uintptr_t page_size;
unsigned char *page;
page_size = getpagesize ();
__go_assert (page_size >= full_size);
page = (unsigned char *) runtime_mallocgc (2 * page_size - 1, 0, 0, 0);
page = (unsigned char *) (((uintptr_t) page + page_size - 1)
& ~ (page_size - 1));
#ifdef HAVE_SYS_MMAN_H
{
int i;
i = mprotect (page, page_size, PROT_READ | PROT_WRITE | PROT_EXEC);
__go_assert (i == 0);
}
#endif
trampoline_page = page;
trampoline_page_size = page_size;
trampoline_page_used = 0;
}
ret = trampoline_page + trampoline_page_used;
trampoline_page_used += full_size;
runtime_unlock (&trampoline_lock);
__builtin_memcpy (ret + full_size - ptr_size, &closure, ptr_size);
return (void *) ret;
}
/* Scan the trampoline page when running the garbage collector. This
just makes sure that the garbage collector sees the pointer in
trampoline_page, so that the page itself is not freed if there are
no other references to it. */
void
runtime_trampoline_scan (void (*addroot) (Obj))
{
if (trampoline_page != NULL)
addroot ((Obj){(byte *) &trampoline_page, sizeof trampoline_page, 0});
}