dmd-frontend GC

gcstub.d

/**
 * This module contains a minimal garbage collector implementation according to
 * published requirements.  This library is mostly intended to serve as an
 * example, but it is usable in applications which do not rely on a garbage
 * collector to clean up memory (ie. when dynamic array resizing is not used,
 * and all memory allocated with 'new' is freed deterministically with
 * 'delete').
 *
 * Please note that block attribute data must be tracked, or at a minimum, the
 * FINALIZE bit must be tracked for any allocated memory block because calling
 * rt_finalize on a non-object block can result in an access violation.  In the
 * allocator below, this tracking is done via a leading uint bitmask.  A real
 * allocator may do better to store this data separately, similar to the basic
 * GC.
 *
 * Copyright: Copyright Sean Kelly 2005 - 2009.
 * License:   $(WEB www.boost.org/LICENSE_1_0.txt, Boost License 1.0).
 * Authors:   Sean Kelly
 */

/*		  Copyright Sean Kelly 2005 - 2009.
 * Distributed under the Boost Software License, Version 1.0.
 *	(See accompanying file LICENSE or copy at
 *		  http://www.boost.org/LICENSE_1_0.txt)
 */
module gcstub;

import W32_ = core.sys.windows.windows;
import RtMem_ = core.memory;
private alias BlkAttr = RtMem_.GC.BlkAttr;
private alias BlkInfo = RtMem_.GC.BlkInfo;

/* -------------------------------------------------------------------------- */

private {
	__gshared W32_.HANDLE GlobalHeap;

	void* malloc(size_t Sz) {
		return W32_.HeapAlloc(
			enforce(GlobalHeap),
			0,
			Sz
		);
	};

	void* calloc(size_t Sz, size_t Num) {
		return W32_.HeapAlloc(
			enforce(GlobalHeap),
			W32_.HEAP_ZERO_MEMORY,
			Sz * Num
		);
	};

	void* realloc(void* Ptr, size_t Sz) {
		if (!Ptr) {
			return malloc(Sz);
		};
		return W32_.HeapReAlloc(
			enforce(GlobalHeap),
			0,
			Ptr,
			Sz
		);
	};

	void free(void* Ptr) {
		W32_.HeapFree(
			enforce(GlobalHeap),
			0,
			Ptr
		);
	};

	Tº enforce(Tº)(Tº X) {
		if (!X) {asm {int 8;};};
		return X;
	};
};

extern(C) void gc_init() {
	gc_annihilate(true);
	// NOTE: The GC must initialize the thread library before its first
	// collection, and always before returning from gc_init().
	thread_init();
	initProxy();
};

extern(C) void gc_term() {
	free(roots);
	free(ranges);
	gc_annihilate(false);
};

/* destroy and optionally re-create the global GC heap */
export extern(C) void gc_annihilate(bool Create) {
	if (GlobalHeap) {
		auto X = W32_.HeapDestroy(GlobalHeap);
		assert(X);
		GlobalHeap = null;
	};
	if (Create) {
		GlobalHeap = W32_.HeapCreate(
			W32_.HEAP_NO_SERIALIZE,
			0, /* dwInitialSize */
			0 /* dwMaximumSize  */
		);
		assert(GlobalHeap);
	};
};

export extern(C) Proxy* gc_getProxy() {
	return &pthis;
};

export extern(C) void gc_setProxy(Proxy* Prx) {
	assert(proxy is null);
	proxy = Prx;
	foreach (X; roots[0 .. nroots]) {
		proxy.gc_addRoot(X);
	};
	foreach (X; ranges[0 .. nranges]) {
		proxy.gc_addRange(X.pos, X.len, X.ti);
	};
};

export extern(C) void gc_clrProxy() {
	foreach (X; ranges[0 .. nranges]) {
		proxy.gc_removeRange(X.pos);
	};
	foreach (X; roots[0 .. nroots]) {
		proxy.gc_removeRoot(X);
	};
	proxy = null;
};

/* -------------------------------------------------------------------------- */

private
{
	extern(C) void thread_init();
	extern(C) void onOutOfMemoryError(void* pretend_sideffect = null)
		@trusted pure nothrow @nogc; /* dmd @@@BUG11461@@@ */

	struct Proxy
	{
		extern(C) void function() gc_enable;
		extern(C) void function() gc_disable;
		extern(C) void function() gc_collect;
		extern(C) void function() gc_minimize;

		extern(C) uint function(void*) gc_getAttr;
		extern(C) uint function(void*, uint) gc_setAttr;
		extern(C) uint function(void*, uint) gc_clrAttr;

		extern(C) void* function(size_t, uint, const TypeInfo) gc_malloc;
		extern(C) BlkInfo function(size_t, uint, const TypeInfo) gc_qalloc;
		extern(C) void* function(size_t, uint, const TypeInfo) gc_calloc;
		extern(C) void* function(void*, size_t, uint ba, const TypeInfo)
			gc_realloc;
		extern(C) size_t function(void*, size_t, size_t, const TypeInfo)
			gc_extend;
		extern(C) size_t function(size_t) gc_reserve;
		extern(C) void function(void*) gc_free;

		extern(C) void* function(void*) gc_addrOf;
		extern(C) size_t function(void*) gc_sizeOf;

		extern(C) BlkInfo function(void*) gc_query;

		extern(C) void function(void*) gc_addRoot;
		extern(C) void function(void*, size_t, const TypeInfo ti) gc_addRange;

		extern(C) void function(void*) gc_removeRoot;
		extern(C) void function(void*) gc_removeRange;
		extern(C) void function(in void[]) gc_runFinalizers;

		extern(C) bool function() gc_inFinalizer;
	}

	__gshared Proxy  pthis;
	__gshared Proxy* proxy;

	void initProxy()
	{
		pthis.gc_enable = &gc_enable;
		pthis.gc_disable = &gc_disable;
		pthis.gc_collect = &gc_collect;
		pthis.gc_minimize = &gc_minimize;

		pthis.gc_getAttr = &gc_getAttr;
		pthis.gc_setAttr = &gc_setAttr;
		pthis.gc_clrAttr = &gc_clrAttr;

		pthis.gc_malloc = &gc_malloc;
		pthis.gc_qalloc = &gc_qalloc;
		pthis.gc_calloc = &gc_calloc;
		pthis.gc_realloc = &gc_realloc;
		pthis.gc_extend = &gc_extend;
		pthis.gc_reserve = &gc_reserve;
		pthis.gc_free = &gc_free;

		pthis.gc_addrOf = &gc_addrOf;
		pthis.gc_sizeOf = &gc_sizeOf;

		pthis.gc_query = &gc_query;

		pthis.gc_addRoot = &gc_addRoot;
		pthis.gc_addRange = &gc_addRange;

		pthis.gc_removeRoot = &gc_removeRoot;
		pthis.gc_removeRange = &gc_removeRange;
		pthis.gc_runFinalizers = &gc_runFinalizers;

		pthis.gc_inFinalizer = &gc_inFinalizer;
	}

	__gshared void** roots  = null;
	__gshared size_t nroots = 0;

	struct Range
	{
		void*  pos;
		size_t len;
		TypeInfo ti; // should be tail const, but doesn't exist for references
	}

	__gshared Range* ranges  = null;
	__gshared size_t nranges = 0;
}

extern(C) void gc_enable()
{
	if( proxy is null )
		return;
	return proxy.gc_enable();
}

extern(C) void gc_disable()
{
	if( proxy is null )
		return;
	return proxy.gc_disable();
}

extern(C) void gc_collect()
{
	if( proxy is null )
		return;
	return proxy.gc_collect();
}

extern(C) void gc_minimize()
{
	if( proxy is null )
		return;
	return proxy.gc_minimize();
}

extern(C) uint gc_getAttr( void* p )
{
	if( proxy is null )
		return 0;
	return proxy.gc_getAttr( p );
}

extern(C) uint gc_setAttr( void* p, uint a )
{
	if( proxy is null )
		return 0;
	return proxy.gc_setAttr( p, a );
}

extern(C) uint gc_clrAttr( void* p, uint a )
{
	if( proxy is null )
		return 0;
	return proxy.gc_clrAttr( p, a );
}

extern(C) void* gc_malloc( size_t sz, uint ba = 0, const TypeInfo ti = null )
{
	if( proxy is null )
	{
		void* p = malloc( sz );

		if( sz && p is null )
			onOutOfMemoryError();
		return p;
	}
	return proxy.gc_malloc( sz, ba, ti );
}

extern(C) BlkInfo gc_qalloc( size_t sz, uint ba = 0, const TypeInfo ti = null )
{
	if( proxy is null )
	{
		BlkInfo retval;
		retval.base = gc_malloc(sz, ba);
		retval.size = sz;
		retval.attr = ba;
		return retval;
	}
	return proxy.gc_qalloc( sz, ba, ti );
}

extern(C) void* gc_calloc( size_t sz, uint ba = 0, const TypeInfo ti = null )
{
	if( proxy is null )
	{
		void* p = calloc( 1, sz );

		if( sz && p is null )
			onOutOfMemoryError();
		return p;
	}
	return proxy.gc_calloc( sz, ba, ti );
}

extern(C) void* gc_realloc(
	void* p, size_t sz, uint ba = 0, const TypeInfo ti = null
) {
	if( proxy is null )
	{
		p = realloc( p, sz );

		if( sz && p is null )
			onOutOfMemoryError();
		return p;
	}
	return proxy.gc_realloc( p, sz, ba, ti );
}

extern(C) size_t gc_extend(
	void* p, size_t mx, size_t sz, const TypeInfo ti = null
) {
	if( proxy is null )
		return 0;
	return proxy.gc_extend( p, mx, sz, ti );
}

extern(C) size_t gc_reserve( size_t sz )
{
	if( proxy is null )
		return 0;
	return proxy.gc_reserve( sz );
}

extern(C) void gc_free( void* p )
{
	if( proxy is null )
		return free( p );
	return proxy.gc_free( p );
}

extern(C) void* gc_addrOf( void* p )
{
	if( proxy is null )
		return null;
	return proxy.gc_addrOf( p );
}

extern(C) size_t gc_sizeOf( void* p )
{
	if( proxy is null )
		return 0;
	return proxy.gc_sizeOf( p );
}

extern(C) BlkInfo gc_query( void* p )
{
	if( proxy is null )
		return BlkInfo.init;
	return proxy.gc_query( p );
}

extern(C) void gc_addRoot( void* p )
{
	if( proxy is null )
	{
		void** r = cast(void**) realloc( roots,
										 (nroots+1) * roots[0].sizeof );
		if( r is null )
			onOutOfMemoryError();
		r[nroots++] = p;
		roots = r;
		return;
	}
	return proxy.gc_addRoot( p );
}

extern(C) void gc_addRange( void* p, size_t sz, const TypeInfo ti = null )
{
	//printf("gcstub::gc_addRange() proxy = %p\n", proxy);
	if( proxy is null )
	{
		Range* r = cast(Range*) realloc( ranges,
										 (nranges+1) * ranges[0].sizeof );
		if( r is null )
			onOutOfMemoryError();
		r[nranges].pos = p;
		r[nranges].len = sz;
		r[nranges].ti = cast()ti;
		ranges = r;
		++nranges;
		return;
	}
	return proxy.gc_addRange( p, sz, ti );
}

extern(C) void gc_removeRoot( void *p )
{
	if( proxy is null )
	{
		for( size_t i = 0; i < nroots; ++i )
		{
			if( roots[i] is p )
			{
				roots[i] = roots[--nroots];
				return;
			}
		}
		assert( false );
	}
	return proxy.gc_removeRoot( p );
}

extern(C) void gc_removeRange( void *p )
{
	if( proxy is null )
	{
		for( size_t i = 0; i < nranges; ++i )
		{
			if( ranges[i].pos is p )
			{
				ranges[i] = ranges[--nranges];
				return;
			}
		}
		assert( false );
	}
	return proxy.gc_removeRange( p );
}

extern(C) void gc_runFinalizers( in void[] segment )
{
	if( proxy !is null )
		proxy.gc_runFinalizers( segment );
}

extern(C) bool gc_inFinalizer()
{
	if( proxy !is null )
		return proxy.gc_inFinalizer();
	return false;
}

/* -------------------------------------------------------------------------- */