rt.lifetime

void* _d_allocmemory(size_t sz);

Allocate memory using the garbage collector

DMD uses this to allocate closures:

void f(byte[24] x)
{
    return () => x; // `x` is on stack, must be moved to heap to keep it alive
}

Parameters:

size_t sz

number of bytes to allocate

Returns:

pointer to sz bytes of free, uninitialized memory, managed by the GC.

Object _d_newclass(const ClassInfo ci);

Create a new class instance.

Allocates memory and sets fields to their initial value, but does not call a constructor.

new Object() // _d_newclass(typeid(Object))

Parameters:

ClassInfo ci

TypeInfo_Class object, to provide instance size and initial bytes to copy

Returns:

newly created object

void _d_delinterface(void** p);

void _d_delclass(Object* p);

pure nothrow void[] _d_newarrayU(scope const TypeInfo ti, size_t length);

pure nothrow void[] _d_newarrayT(const TypeInfo ti, size_t length);

pure nothrow void[] _d_newarrayiT(const TypeInfo ti, size_t length);

Allocate an array with the garbage collector.

Has three variants:

• _d_newarrayU leave elements uninitialized
• _d_newarrayT initializes to 0 (e.g new int[])
• _d_newarrayiT initializes based on initializer retrieved from TypeInfo (e.g new float[])

Parameters:

TypeInfo ti	the type of the resulting array, (may also be the corresponding array.ptr type)
size_t length	.length of resulting array

Returns:

newly allocated array

pure nothrow void* _d_newitemU(scope const TypeInfo _ti);

Non-template version of core.lifetime.d_newitemT that does not perform initialization. Needed for rt.aaA.allocEntry.

Parameters:

TypeInfo _ti

TypeInfo of item to allocate

Returns:

newly allocated item

void _d_delmemory(void** p);

void _d_callinterfacefinalizer(void* p);

void _d_callfinalizer(void* p);

void rt_setCollectHandler(CollectHandler h);

CollectHandler rt_getCollectHandler();

nothrow int rt_hasFinalizerInSegment(void* p, size_t size, TypeInfo typeInfo, scope const(void)[] segment);

nothrow void rt_finalize2(void* p, bool det = true, bool resetMemory = true);

nothrow void rt_finalize(void* p, bool det = true);

Backwards compatibility

void[] _d_arrayappendcd(ref byte[] x, dchar c);

Append dchar to char[], converting UTF-32 to UTF-8

void main()
{
    char[] s;
    s ~= 'α';
}

Parameters:

byte[] x	array to append to cast to byte[]. Will be modified.
dchar c	dchar to append

Returns:

updated x cast to void[]

void[] _d_arrayappendwd(ref byte[] x, dchar c);

Append dchar to wchar[], converting UTF-32 to UTF-16

void main()
{
    dchar x;
    wchar[] s;
    s ~= 'α';
}

Parameters:

byte[] x	array to append to cast to byte[]. Will be modified.
dchar c	dchar to append

Returns:

updated x cast to void[]