/* hold lock: */
GC_INNER void * GC_generic_malloc_inner(size_t lb, int k)
{
void *op;
if(SMALL_OBJ(lb)) {
struct obj_kind * kind = GC_obj_kinds + k;
size_t lg = GC_size_map[lb];
void ** opp = &(kind -> ok_freelist[lg]);
if( (op = *opp) == 0 ) {
if (GC_size_map[lb] == 0) {
if (!GC_is_initialized) GC_init();
if (GC_size_map[lb] == 0) GC_extend_size_map(lb);
return(GC_generic_malloc_inner(lb, k));
}
if (kind -> ok_reclaim_list == 0) {
if (!GC_alloc_reclaim_list(kind)) goto out;
}
op = GC_allocobj(lg, k);
if (op == 0) goto out;
}
*opp = obj_link(op);
obj_link(op) = 0;
GC_bytes_allocd += GRANULES_TO_BYTES(lg);
} else {
op = (ptr_t)GC_alloc_large_and_clear(ADD_SLOP(lb), k, 0);
GC_bytes_allocd += lb;
}
out:
return op;
}
void boehm_gc_startup_code(void)
{
GC_init();
GC_finalizer_notifier = &boehm_gc_finalizer_notifier;
GC_finalize_on_demand = 1;
GC_set_warn_proc(mem_boehm_ignore);
}
void neko_gc_init() {
GC_set_warn_proc((GC_warn_proc)(void*)null_warn_proc);
# ifndef NEKO_WINDOWS
// we can't set this on windows with old GC since
// it's already initialized through its own DllMain
GC_all_interior_pointers = 0;
# endif
#if (GC_VERSION_MAJOR >= 7) && defined(NEKO_WINDOWS)
GC_all_interior_pointers = 0;
# ifndef NEKO_STANDALONE
GC_use_DllMain(); // needed to auto-detect threads created by Apache
# endif
#endif
GC_java_finalization = 1;
GC_init();
GC_no_dls = 1;
#ifdef LOW_MEM
GC_dont_expand = 1;
#endif
GC_clear_roots();
#if defined(GC_LOG) && defined(NEKO_POSIX)
{
struct sigaction act;
act.sa_sigaction = NULL;
act.sa_handler = handle_signal;
act.sa_flags = 0;
sigemptyset(&act.sa_mask);
sigaction(SIGSEGV,&act,NULL);
}
#endif
}
/* should change while we have a valid object pointer to the block. */
GC_API void * GC_CALL GC_is_valid_displacement(void *p)
{
hdr *hhdr;
word pdispl;
word offset;
struct hblk *h;
word sz;
if (!GC_is_initialized) GC_init();
hhdr = HDR((word)p);
if (hhdr == 0) return(p);
h = HBLKPTR(p);
if (GC_all_interior_pointers) {
while (IS_FORWARDING_ADDR_OR_NIL(hhdr)) {
h = FORWARDED_ADDR(h, hhdr);
hhdr = HDR(h);
}
}
if (IS_FORWARDING_ADDR_OR_NIL(hhdr)) {
goto fail;
}
sz = hhdr -> hb_sz;
pdispl = HBLKDISPL(p);
offset = pdispl % sz;
if ((sz > MAXOBJBYTES && (ptr_t)p >= (ptr_t)h + sz)
|| !GC_valid_offsets[offset]
|| (ptr_t)p - offset + sz > (ptr_t)(h + 1)) {
goto fail;
}
return(p);
fail:
(*GC_is_valid_displacement_print_proc)((ptr_t)p);
return(p);
}
int main () {
GC_init();
int sock = CHECK(socket, AF_INET, SOCK_STREAM, 0);
sockaddr_in listen_addr = any_addr();
printf("bind...\n");
CHECK(bind, sock, (sockaddr*)&listen_addr, sizeof(listen_addr));
printf("listen...\n");
CHECK(listen, sock, SOMAXCONN);
sockaddr_in client_addr;
socklen_t client_addr_len;
int new_sock;
printf("accept...\n");
do {
new_sock = CHECK(accept, sock, (sockaddr*)&client_addr, &client_addr_len);
char* message = recv_string(new_sock);
puts(message);
const char* response = process_message((const char*)message);
puts("Response generated.");
CHECK(send, new_sock, response, strlen(response) + 1, 0);
puts("Response sent.\n");
// char endbuf [MAX_BUFFER];
// CHECK(recv, new_sock, endbuf, MAX_BUFFER, 0);
// puts("Close request recieved.");
CHECK(close, new_sock);
} while (0);
CHECK(close, sock);
return 0;
}
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
LPWSTR lpCmdLine, int nShowCmd)
{
DWORD exit_code = 1;
main_thread_args args = {
hInstance, hPrevInstance, lpCmdLine, nShowCmd
};
HANDLE thread_h;
DWORD thread_id;
/* initialize everything */
GC_init();
/* start the main thread */
thread_h = GC_CreateThread(
NULL, 0, main_thread_start, &args, 0, &thread_id);
if (thread_h != NULL)
{
WaitForSingleObject (thread_h, INFINITE);
GetExitCodeThread (thread_h, &exit_code);
CloseHandle (thread_h);
}
GC_deinit();
DeleteCriticalSection(&GC_allocate_ml);
return (int) exit_code;
}
void InitBags(UInt initial_size,
Bag * stack_bottom,
UInt stack_align)
{
UInt i; /* loop variable */
/* install the marking functions */
for (i = 0; i < NUM_TYPES; i++) {
TabMarkTypeBags[i] = -1;
}
#ifndef DISABLE_GC
#ifdef HPCGAP
if (!getenv("GC_MARKERS")) {
/* The Boehm GC does not have an API to set the number of
* markers for the parallel mark and sweep implementation,
* so we use the documented environment variable GC_MARKERS
* instead. However, we do not override it if it's already
* set.
*/
static char marker_env_str[32];
unsigned num_markers = 2;
if (!SyNumGCThreads)
SyNumGCThreads = SyNumProcessors;
if (SyNumGCThreads) {
if (SyNumGCThreads <= MAX_GC_THREADS)
num_markers = (unsigned)SyNumProcessors;
else
num_markers = MAX_GC_THREADS;
}
sprintf(marker_env_str, "GC_MARKERS=%u", num_markers);
putenv(marker_env_str);
}
#endif
GC_set_all_interior_pointers(0);
GC_init();
GC_set_free_space_divisor(1);
TLAllocatorInit();
GC_register_displacement(0);
GC_register_displacement(sizeof(BagHeader));
initial_size *= 1024;
if (GC_get_heap_size() < initial_size)
GC_expand_hp(initial_size - GC_get_heap_size());
if (SyStorKill)
GC_set_max_heap_size(SyStorKill * 1024);
#ifdef HPCGAP
AddGCRoots();
CreateMainRegion();
#else
void * p = ActiveGAPState();
GC_add_roots(p, (char *)p + sizeof(GAPState));
#endif
for (i = 0; i <= MAX_GC_PREFIX_DESC; i++) {
BuildPrefixGCDescriptor(i);
/* This is necessary to initialize some internal structures
* in the garbage collector: */
GC_generic_malloc(sizeof(BagHeader) + i * sizeof(Bag), GCMKind[i]);
}
#endif /* DISABLE_GC */
}
GC_API void GC_CALL GC_add_roots(void *b, void *e)
{
DCL_LOCK_STATE;
if (!EXPECT(GC_is_initialized, TRUE)) GC_init();
LOCK();
GC_add_roots_inner((ptr_t)b, (ptr_t)e, FALSE);
UNLOCK();
}
void scheme_set_stack_base(void *base, int no_auto_statics)
{
#if defined(MZ_PRECISE_GC) || defined(USE_SENORA_GC)
GC_set_stack_base(base);
/* no_auto_statics must always be true! */
#else
GC_stackbottom = base;
if (no_auto_statics) {
GC_no_dls = 1;
GC_init();
GC_clear_roots();
} else {
# if defined(__APPLE__) && defined(__MACH__)
GC_init(); /* For Darwin, CGC requires GC_init() always */
# endif
}
#endif
use_registered_statics = no_auto_statics;
}
void MLton_init (int argc, char **argv, GC_state s) {
int start;
Posix_ProcEnv_environ = (C_StringArray_t)environ;
start = GC_init (s, argc, argv);
/* Setup argv and argc that SML sees. */
/* start is now the index of the first real arg. */
CommandLine_commandName = (C_String_t)(argv[0]);
CommandLine_argc = argc - start;
CommandLine_argv = (C_StringArray_t)(argv + start);
}
/* Caller does not hold allocation lock. */
void GC_init_gcj_malloc(int mp_index, void * /* really GC_mark_proc */mp)
{
register int i;
GC_bool ignore_gcj_info;
DCL_LOCK_STATE;
GC_init(); /* In case it's not already done. */
DISABLE_SIGNALS();
LOCK();
if (GC_gcj_malloc_initialized) {
UNLOCK();
ENABLE_SIGNALS();
return;
}
GC_gcj_malloc_initialized = TRUE;
ignore_gcj_info = (0 != GETENV("GC_IGNORE_GCJ_INFO"));
# ifdef CONDPRINT
if (GC_print_stats && ignore_gcj_info) {
GC_printf0("Gcj-style type information is disabled!\n");
}
# endif
GC_ASSERT(GC_mark_procs[mp_index] == (GC_mark_proc)0); /* unused */
GC_mark_procs[mp_index] = (GC_mark_proc)mp;
if (mp_index >= GC_n_mark_procs) ABORT("GC_init_gcj_malloc: bad index");
/* Set up object kind gcj-style indirect descriptor. */
GC_gcjobjfreelist = (ptr_t *)GC_new_free_list_inner();
if (ignore_gcj_info) {
/* Use a simple length-based descriptor, thus forcing a fully */
/* conservative scan. */
GC_gcj_kind = GC_new_kind_inner((void **)GC_gcjobjfreelist,
(0 | GC_DS_LENGTH),
TRUE, TRUE);
} else {
GC_gcj_kind = GC_new_kind_inner(
(void **)GC_gcjobjfreelist,
(((word)(-MARK_DESCR_OFFSET - GC_INDIR_PER_OBJ_BIAS))
| GC_DS_PER_OBJECT),
FALSE, TRUE);
}
/* Set up object kind for objects that require mark proc call. */
if (ignore_gcj_info) {
GC_gcj_debug_kind = GC_gcj_kind;
GC_gcjdebugobjfreelist = GC_gcjobjfreelist;
} else {
GC_gcjdebugobjfreelist = (ptr_t *)GC_new_free_list_inner();
GC_gcj_debug_kind = GC_new_kind_inner(
(void **)GC_gcjdebugobjfreelist,
GC_MAKE_PROC(mp_index,
1 /* allocated with debug info */),
FALSE, TRUE);
}
UNLOCK();
ENABLE_SIGNALS();
}
int main ()
{
object obj;
GC_init();
obj = NEW();
RELEASE(obj);
GC_collect(0);
ASSERTDEAD(obj);
ASSERTFINAL(obj);
obj = NEW();
GC_collect(0);
ASSERTLIVE(obj);
ASSERTNOFINAL(obj);
GC_terminate(0);
ASSERTNOFINAL(obj);
GC_init();
obj = NEW();
GC_terminate(1);
ASSERTFINAL(obj);
return 0;
}
GC_API void GC_CALL GC_clear_roots(void)
{
DCL_LOCK_STATE;
if (!GC_is_initialized) GC_init();
LOCK();
roots_were_cleared = TRUE;
n_root_sets = 0;
GC_root_size = 0;
# if !defined(MSWIN32) && !defined(MSWINCE) && !defined(CYGWIN32)
BZERO(GC_root_index, RT_SIZE * sizeof(void *));
# endif
UNLOCK();
}
/* require special handling on allocation. */
GC_INNER void * GC_generic_malloc_inner(size_t lb, int k)
{
void *op;
GC_ASSERT(I_HOLD_LOCK());
if(SMALL_OBJ(lb)) {
struct obj_kind * kind = GC_obj_kinds + k;
size_t lg = GC_size_map[lb];
void ** opp = &(kind -> ok_freelist[lg]);
op = *opp;
if (EXPECT(0 == op, FALSE)) {
if (lg == 0) {
if (!EXPECT(GC_is_initialized, TRUE)) {
DCL_LOCK_STATE;
UNLOCK(); /* just to unset GC_lock_holder */
GC_init();
LOCK();
lg = GC_size_map[lb];
}
if (0 == lg) {
GC_extend_size_map(lb);
lg = GC_size_map[lb];
GC_ASSERT(lg != 0);
}
/* Retry */
opp = &(kind -> ok_freelist[lg]);
op = *opp;
}
if (0 == op) {
if (0 == kind -> ok_reclaim_list &&
!GC_alloc_reclaim_list(kind))
return NULL;
op = GC_allocobj(lg, k);
if (0 == op)
return NULL;
}
}
*opp = obj_link(op);
obj_link(op) = 0;
GC_bytes_allocd += GRANULES_TO_BYTES(lg);
} else {
op = (ptr_t)GC_alloc_large_and_clear(ADD_SLOP(lb), k, 0);
GC_bytes_allocd += lb;
}
return op;
}
STATIC void GC_init_lib_bounds(void)
{
if (GC_libpthread_start != 0) return;
GC_init(); /* if not called yet */
if (!GC_text_mapping("libpthread-",
&GC_libpthread_start, &GC_libpthread_end)) {
WARN("Failed to find libpthread.so text mapping: Expect crash\n", 0);
/* This might still work with some versions of libpthread, */
/* so we don't abort. Perhaps we should. */
/* Generate message only once: */
GC_libpthread_start = (ptr_t)1;
}
if (!GC_text_mapping("ld-", &GC_libld_start, &GC_libld_end)) {
WARN("Failed to find ld.so text mapping: Expect crash\n", 0);
}
}
void mygc() {
//int **max = (int **) 0xbfffffffUL; // the address of the top of the stack
unsigned long stack_bottom;
int **max = (int **) GC_init(); // get the address of the bottom of the stack
int* q;
int **p = &q; // the address of the bottom of the stack
while (p < max) {
//printf("0. p: %u, *p: %u max: %u\n",p,*p,max);
mark(*p);
p++;
}
//now fill in the rest think sweep , think coalesce
sweep(q);
coalesce();
}
GC_API void GC_CALL GC_clear_roots(void)
{
DCL_LOCK_STATE;
if (!EXPECT(GC_is_initialized, TRUE)) GC_init();
LOCK();
roots_were_cleared = TRUE;
n_root_sets = 0;
GC_root_size = 0;
# if !defined(MSWIN32) && !defined(MSWINCE) && !defined(CYGWIN32)
BZERO(GC_root_index, RT_SIZE * sizeof(void *));
# endif
# ifdef DEBUG_ADD_DEL_ROOTS
GC_log_printf("Clear all data root sections\n");
# endif
UNLOCK();
}
GC_API void GC_CALL GC_init_finalized_malloc(void)
{
DCL_LOCK_STATE;
GC_init(); /* In case it's not already done. */
LOCK();
if (done_init) {
UNLOCK();
return;
}
done_init = TRUE;
GC_finalized_objfreelist = (ptr_t *)GC_new_free_list_inner();
GC_finalized_kind = GC_new_kind_inner((void **)GC_finalized_objfreelist,
GC_DS_LENGTH, TRUE, TRUE);
GC_register_disclaim_proc(GC_finalized_kind, GC_finalized_disclaim, TRUE);
UNLOCK();
}
/* EXTRA_BYTES were already added to lb. */
GC_INNER ptr_t GC_alloc_large(size_t lb, int k, unsigned flags)
{
struct hblk * h;
word n_blocks;
ptr_t result;
GC_bool retry = FALSE;
GC_ASSERT(I_HOLD_LOCK());
lb = ROUNDUP_GRANULE_SIZE(lb);
n_blocks = OBJ_SZ_TO_BLOCKS(lb);
if (!EXPECT(GC_is_initialized, TRUE)) {
DCL_LOCK_STATE;
UNLOCK(); /* just to unset GC_lock_holder */
GC_init();
LOCK();
}
/* Do our share of marking work */
if (GC_incremental && !GC_dont_gc)
GC_collect_a_little_inner((int)n_blocks);
h = GC_allochblk(lb, k, flags);
# ifdef USE_MUNMAP
if (0 == h) {
GC_merge_unmapped();
h = GC_allochblk(lb, k, flags);
}
# endif
while (0 == h && GC_collect_or_expand(n_blocks, flags != 0, retry)) {
h = GC_allochblk(lb, k, flags);
retry = TRUE;
}
if (h == 0) {
result = 0;
} else {
size_t total_bytes = n_blocks * HBLKSIZE;
if (n_blocks > 1) {
GC_large_allocd_bytes += total_bytes;
if (GC_large_allocd_bytes > GC_max_large_allocd_bytes)
GC_max_large_allocd_bytes = GC_large_allocd_bytes;
}
/* FIXME: Do we need some way to reset GC_max_large_allocd_bytes? */
result = h -> hb_body;
}
return result;
}
PCR_ERes
PCR_GC_Run(void)
{
if( !PCR_Base_TestPCRArg("-nogc") ) {
GC_quiet = ( PCR_Base_TestPCRArg("-gctrace") ? 0 : 1 );
GC_use_debug = (GC_bool)PCR_Base_TestPCRArg("-debug_alloc");
GC_init();
if( !PCR_Base_TestPCRArg("-nogc_incremental") ) {
/*
* awful hack to test whether VD is implemented ...
*/
if( PCR_VD_Start( 0, NIL, 0) != PCR_ERes_FromErr(ENOSYS) ) {
GC_enable_incremental();
}
}
}
return PCR_ERes_okay;
}
/* Must be called before a second thread is created. */
void GC_init_parallel(void)
{
if (parallel_initialized) return;
parallel_initialized = TRUE;
/* GC_init() calls us back, so set flag first. */
if (!GC_is_initialized) GC_init();
if (GC_win32_dll_threads) {
GC_need_to_lock = TRUE;
/* Cannot intercept thread creation. Hence we don't know if */
/* other threads exist. However, client is not allowed to */
/* create other threads before collector initialization. */
/* Thus it's OK not to lock before this. */
}
/* Initialize thread local free lists if used. */
# if defined(THREAD_LOCAL_ALLOC)
LOCK();
GC_init_thread_local(&(GC_lookup_thread(GetCurrentThreadId())->tlfs));
UNLOCK();
# endif
}
/*---------------------------------------------------------------------*/
void
bglpth_setup_gc() {
#if( BGL_GC == BGL_BOEHM_GC && BGL_GC_HAVE_BLOCKING )
extern void GC_start_blocking();
extern void GC_end_blocking();
bgl_gc_start_blocking = &GC_start_blocking;
bgl_gc_stop_blocking = &GC_end_blocking;
#endif
#if( BGL_GC == BGL_BOEHM_GC && BGL_GC_HAVE_DO_BLOCKING )
#if( BGL_GC_VERSION == 722 \
|| BGL_GC_VERSION == 710 \
|| BGL_GC_VERSION == 700 || BGL_GC_VERSION == 707 )
extern void *GC_do_blocking();
#endif
bgl_gc_do_blocking = (void *(*)())&GC_do_blocking;
#endif
GC_init();
}
/* EXTRA_BYTES were already added to lb. */
GC_INNER ptr_t GC_alloc_large(size_t lb, int k, unsigned flags)
{
struct hblk * h;
word n_blocks;
ptr_t result;
GC_bool retry = FALSE;
/* Round up to a multiple of a granule. */
lb = (lb + GRANULE_BYTES - 1) & ~(GRANULE_BYTES - 1);
n_blocks = OBJ_SZ_TO_BLOCKS(lb);
if (!GC_is_initialized) GC_init();
/* Do our share of marking work */
if (GC_incremental && !GC_dont_gc)
GC_collect_a_little_inner((int)n_blocks);
h = GC_allochblk(lb, k, flags);
# ifdef USE_MUNMAP
if (0 == h) {
GC_merge_unmapped();
h = GC_allochblk(lb, k, flags);
}
# endif
while (0 == h && GC_collect_or_expand(n_blocks, flags != 0, retry)) {
h = GC_allochblk(lb, k, flags);
retry = TRUE;
}
if (h == 0) {
result = 0;
} else {
size_t total_bytes = n_blocks * HBLKSIZE;
if (n_blocks > 1) {
GC_large_allocd_bytes += total_bytes;
if (GC_large_allocd_bytes > GC_max_large_allocd_bytes)
GC_max_large_allocd_bytes = GC_large_allocd_bytes;
}
result = h -> hb_body;
}
return result;
}
GC_API void GC_CALL GC_init_finalized_malloc(void)
{
DCL_LOCK_STATE;
GC_init(); /* In case it's not already done. */
LOCK();
if (done_init) {
UNLOCK();
return;
}
done_init = TRUE;
/* The finalizer closure is placed in the first word in order to */
/* use the lower bits to distinguish live objects from objects on */
/* the free list. The downside of this is that we need one-word */
/* offset interior pointers, and that GC_base does not return the */
/* start of the user region. */
GC_register_displacement_inner(sizeof(word));
GC_finalized_kind = GC_new_kind_inner(GC_new_free_list_inner(),
GC_DS_LENGTH, TRUE, TRUE);
GC_register_disclaim_proc(GC_finalized_kind, GC_finalized_disclaim, TRUE);
UNLOCK();
}
/*
* Entry point of initlalizing Gauche runtime
*/
void Scm_Init(const char *signature)
{
/* make sure the main program links the same version of libgauche */
if (strcmp(signature, GAUCHE_SIGNATURE) != 0) {
Scm_Panic("libgauche ABI version mismatch: libgauche %s, expected %s",
GAUCHE_SIGNATURE, signature);
}
/* Some platforms require this. It is harmless if GC is
already initialized, so we call it here just in case. */
GC_init();
/* Set up GC parameters. We need to call finalizers at the safe
point of VM loop, so we disable auto finalizer invocation, and
ask GC to call us back when finalizers are queued. */
GC_oom_fn = oom_handler;
GC_finalize_on_demand = TRUE;
GC_finalizer_notifier = finalizable;
(void)SCM_INTERNAL_MUTEX_INIT(cond_features.mutex);
/* Initialize components. The order is important, for some components
rely on the other components to be initialized. */
Scm__InitParameter();
Scm__InitVM();
Scm__InitSymbol();
Scm__InitModule();
Scm__InitNumber();
Scm__InitChar();
Scm__InitClass();
Scm__InitModulePost();
Scm__InitCollection();
Scm__InitExceptions();
Scm__InitProc();
Scm__InitPort();
Scm__InitWrite();
Scm__InitCode();
Scm__InitMacro();
Scm__InitLoad();
Scm__InitRegexp();
Scm__InitRead();
Scm__InitSignal();
Scm__InitSystem();
Scm_Init_libalpha();
Scm_Init_libbool();
Scm_Init_libchar();
Scm_Init_libcode();
Scm_Init_libdict();
Scm_Init_libeval();
Scm_Init_libexc();
Scm_Init_libfmt();
Scm_Init_libio();
Scm_Init_liblazy();
Scm_Init_liblist();
Scm_Init_libmisc();
Scm_Init_libmod();
Scm_Init_libnum();
Scm_Init_libobj();
Scm_Init_libproc();
Scm_Init_librx();
Scm_Init_libstr();
Scm_Init_libsym();
Scm_Init_libsys();
Scm_Init_libvec();
Scm_Init_compile();
Scm_Init_libomega();
Scm__InitCompaux();
Scm_SelectModule(Scm_GaucheModule());
Scm__InitAutoloads();
Scm_SelectModule(Scm_UserModule());
/* Final setup of cond-features alist. */
init_cond_features();
#ifdef GAUCHE_USE_PTHREADS
/* a trick to make sure the gc thread object is linked */
ptr_pthread_create = (int (*)(void))GC_pthread_create;
#endif
}
gc_initializer() { GC_init(); }
/* debugging intolerably slow.) */
GC_API void * GC_CALL GC_same_obj(void *p, void *q)
{
struct hblk *h;
hdr *hhdr;
ptr_t base, limit;
word sz;
if (!GC_is_initialized) GC_init();
hhdr = HDR((word)p);
if (hhdr == 0) {
if (divHBLKSZ((word)p) != divHBLKSZ((word)q)
&& HDR((word)q) != 0) {
goto fail;
}
return(p);
}
/* If it's a pointer to the middle of a large object, move it */
/* to the beginning. */
if (IS_FORWARDING_ADDR_OR_NIL(hhdr)) {
h = HBLKPTR(p) - (word)hhdr;
hhdr = HDR(h);
while (IS_FORWARDING_ADDR_OR_NIL(hhdr)) {
h = FORWARDED_ADDR(h, hhdr);
hhdr = HDR(h);
}
limit = (ptr_t)h + hhdr -> hb_sz;
if ((ptr_t)p >= limit || (ptr_t)q >= limit || (ptr_t)q < (ptr_t)h ) {
goto fail;
}
return(p);
}
sz = hhdr -> hb_sz;
if (sz > MAXOBJBYTES) {
base = (ptr_t)HBLKPTR(p);
limit = base + sz;
if ((ptr_t)p >= limit) {
goto fail;
}
} else {
size_t offset;
size_t pdispl = HBLKDISPL(p);
offset = pdispl % sz;
if (HBLKPTR(p) != HBLKPTR(q)) goto fail;
/* W/o this check, we might miss an error if */
/* q points to the first object on a page, and */
/* points just before the page. */
base = (ptr_t)p - offset;
limit = base + sz;
}
/* [base, limit) delimits the object containing p, if any. */
/* If p is not inside a valid object, then either q is */
/* also outside any valid object, or it is outside */
/* [base, limit). */
if ((ptr_t)q >= limit || (ptr_t)q < base) {
goto fail;
}
return(p);
fail:
(*GC_same_obj_print_proc)((ptr_t)p, (ptr_t)q);
return(p);
}
/* Currently useless for multithreaded worlds. */
GC_API void * GC_CALL GC_is_visible(void *p)
{
hdr *hhdr;
if ((word)p & (ALIGNMENT - 1)) goto fail;
if (!GC_is_initialized) GC_init();
# ifdef THREADS
hhdr = HDR((word)p);
if (hhdr != 0 && GC_base(p) == 0) {
goto fail;
} else {
/* May be inside thread stack. We can't do much. */
return(p);
}
# else
/* Check stack first: */
if (GC_on_stack(p)) return(p);
hhdr = HDR((word)p);
if (hhdr == 0) {
if (GC_is_static_root(p)) return(p);
/* Else do it again correctly: */
# if (defined(DYNAMIC_LOADING) || defined(MSWIN32) || \
defined(MSWINCE) || defined(PCR))
GC_register_dynamic_libraries();
if (GC_is_static_root(p))
return(p);
# endif
goto fail;
} else {
/* p points to the heap. */
word descr;
ptr_t base = GC_base(p); /* Should be manually inlined? */
if (base == 0) goto fail;
if (HBLKPTR(base) != HBLKPTR(p)) hhdr = HDR((word)p);
descr = hhdr -> hb_descr;
retry:
switch(descr & GC_DS_TAGS) {
case GC_DS_LENGTH:
if ((word)((ptr_t)p - (ptr_t)base) > (word)descr) goto fail;
break;
case GC_DS_BITMAP:
if ((ptr_t)p - (ptr_t)base
>= WORDS_TO_BYTES(BITMAP_BITS)
|| ((word)p & (sizeof(word) - 1))) goto fail;
if (!(((word)1 << (WORDSZ - ((ptr_t)p - (ptr_t)base) - 1))
& descr)) goto fail;
break;
case GC_DS_PROC:
/* We could try to decipher this partially. */
/* For now we just punt. */
break;
case GC_DS_PER_OBJECT:
if ((signed_word)descr >= 0) {
descr = *(word *)((ptr_t)base + (descr & ~GC_DS_TAGS));
} else {
ptr_t type_descr = *(ptr_t *)base;
descr = *(word *)(type_descr
- (descr - (GC_DS_PER_OBJECT
- GC_INDIR_PER_OBJ_BIAS)));
}
goto retry;
}
return(p);
}
# endif
fail:
(*GC_is_visible_print_proc)((ptr_t)p);
return(p);
}
static void init_gc(void) {
GC_all_interior_pointers = INTERIOR_POINTERS || REPLACE_GETBLOCK && REPLACE_MALLOC_BY_GC_IN_GETBLOCK; /* getBlock uses interior pointers! */
GC_free_space_divisor = 2;
GC_init();
// GC_enable_incremental();
}
void
mono_gc_base_init (void)
{
MonoThreadInfoCallbacks cb;
char *env;
if (gc_initialized)
return;
/*
* Handle the case when we are called from a thread different from the main thread,
* confusing libgc.
* FIXME: Move this to libgc where it belongs.
*
* we used to do this only when running on valgrind,
* but it happens also in other setups.
*/
#if defined(HAVE_PTHREAD_GETATTR_NP) && defined(HAVE_PTHREAD_ATTR_GETSTACK)
{
size_t size;
void *sstart;
pthread_attr_t attr;
pthread_getattr_np (pthread_self (), &attr);
pthread_attr_getstack (&attr, &sstart, &size);
pthread_attr_destroy (&attr);
/*g_print ("stackbottom pth is: %p\n", (char*)sstart + size);*/
#ifdef __ia64__
/*
* The calculation above doesn't seem to work on ia64, also we need to set
* GC_register_stackbottom as well, but don't know how.
*/
#else
/* apparently with some linuxthreads implementations sstart can be NULL,
* fallback to the more imprecise method (bug# 78096).
*/
if (sstart) {
GC_stackbottom = (char*)sstart + size;
} else {
int dummy;
gsize stack_bottom = (gsize)&dummy;
stack_bottom += 4095;
stack_bottom &= ~4095;
GC_stackbottom = (char*)stack_bottom;
}
#endif
}
#elif defined(HAVE_PTHREAD_GET_STACKSIZE_NP) && defined(HAVE_PTHREAD_GET_STACKADDR_NP)
GC_stackbottom = (char*)pthread_get_stackaddr_np (pthread_self ());
#elif defined(__OpenBSD__)
# include <pthread_np.h>
{
stack_t ss;
int rslt;
rslt = pthread_stackseg_np(pthread_self(), &ss);
g_assert (rslt == 0);
GC_stackbottom = (char*)ss.ss_sp;
}
#elif defined(__native_client__)
/* Do nothing, GC_stackbottom is set correctly in libgc */
#else
{
int dummy;
gsize stack_bottom = (gsize)&dummy;
stack_bottom += 4095;
stack_bottom &= ~4095;
/*g_print ("stackbottom is: %p\n", (char*)stack_bottom);*/
GC_stackbottom = (char*)stack_bottom;
}
#endif
#if !defined(PLATFORM_ANDROID)
/* If GC_no_dls is set to true, GC_find_limit is not called. This causes a seg fault on Android. */
GC_no_dls = TRUE;
#endif
GC_init ();
GC_oom_fn = mono_gc_out_of_memory;
GC_set_warn_proc (mono_gc_warning);
GC_finalize_on_demand = 1;
GC_finalizer_notifier = mono_gc_finalize_notify;
#ifdef HAVE_GC_GCJ_MALLOC
GC_init_gcj_malloc (5, NULL);
#endif
#ifdef HAVE_GC_ALLOW_REGISTER_THREADS
GC_allow_register_threads();
#endif
if ((env = getenv ("MONO_GC_PARAMS"))) {
char **ptr, **opts = g_strsplit (env, ",", -1);
for (ptr = opts; *ptr; ++ptr) {
char *opt = *ptr;
if (g_str_has_prefix (opt, "max-heap-size=")) {
glong max_heap;
opt = strchr (opt, '=') + 1;
if (*opt && mono_gc_parse_environment_string_extract_number (opt, &max_heap)) {
if (max_heap < MIN_BOEHM_MAX_HEAP_SIZE) {
fprintf (stderr, "max-heap-size must be at least %dMb.\n", MIN_BOEHM_MAX_HEAP_SIZE_IN_MB);
exit (1);
}
GC_set_max_heap_size (max_heap);
} else {
fprintf (stderr, "max-heap-size must be an integer.\n");
exit (1);
}
continue;
} else {
fprintf (stderr, "MONO_GC_PARAMS must be a comma-delimited list of one or more of the following:\n");
fprintf (stderr, " max-heap-size=N (where N is an integer, possibly with a k, m or a g suffix)\n");
exit (1);
}
}
g_strfreev (opts);
}
memset (&cb, 0, sizeof (cb));
cb.thread_register = boehm_thread_register;
cb.mono_method_is_critical = (gpointer)mono_runtime_is_critical_method;
#ifndef HOST_WIN32
cb.mono_gc_pthread_create = (gpointer)mono_gc_pthread_create;
#endif
mono_threads_init (&cb, sizeof (MonoThreadInfo));
mono_gc_enable_events ();
gc_initialized = TRUE;
}
