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);

nothrow void _d_arrayshrinkfit(const TypeInfo ti, void[] arr);

Shrink the "allocated" length of an array to be the exact size of the array.

It doesn't matter what the current allocated length of the array is, the user is telling the runtime that he knows what he is doing.

Parameters:

TypeInfo ti	TypeInfo of array type
void[] arr	array to shrink. Its .length is element length, not byte length, despite void type

size_t _d_arraysetcapacity(const TypeInfo ti, size_t newcapacity, void[]* p);

Set the array capacity.

If the array capacity isn't currently large enough to hold the requested capacity (in number of elements), then the array is resized/reallocated to the appropriate size.

Pass in a requested capacity of 0 to get the current capacity.

Parameters:

TypeInfo ti	type info of element type
size_t newcapacity	requested new capacity
void[]* p	pointer to array to set. Its length is left unchanged.

Returns:

the number of elements that can actually be stored once the resizing is done

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_arraysetlengthT(const TypeInfo ti, size_t newlength, void[]* p);

void[] _d_arraysetlengthiT(const TypeInfo ti, size_t newlength, void[]* p);

Resize a dynamic array by setting the .length property

Newly created elements are initialized to their default value.

Has two variants:

• _d_arraysetlengthT for arrays with elements that initialize to 0
• _d_arraysetlengthiT for non-zero initializers retrieved from TypeInfo

void main()
{
    int[] a = [1, 2];
    a.length = 3; // gets lowered to `_d_arraysetlengthT(typeid(int[]), 3, &a)`
}

Parameters:

TypeInfo ti	TypeInfo of array
size_t newlength	new value for the array's .length
void[]* p	pointer to array to update the .length of. While it's cast to void[], its .length is still treated as element length.

Returns:

*p after being updated

size_t newCapacity(size_t newlength, size_t elemsize);

Given an array of length size that needs to be expanded to newlength, compute a new capacity.

Better version by Dave Fladebo, enhanced by Steven Schveighoffer: This uses an inverse logorithmic algorithm to pre-allocate a bit more space for larger arrays.

• The maximum "extra" space is about 80% of the requested space. This is for

PAGE size and smaller.

• As the arrays grow, the relative pre-allocated space shrinks.
• Perhaps most importantly, overall memory usage and stress on the GC

is decreased significantly for demanding environments.

• The algorithm is tuned to avoid any division at runtime.

Parameters:

size_t newlength	new .length
size_t elemsize	size of the element in the new array

Returns:

new capacity for array

byte[] _d_arrayappendcTX(const TypeInfo ti, ref return scope byte[] px, size_t n);

Extend an array by n elements.

Caller must initialize those elements.

Parameters:

TypeInfo ti	type info of array type (not element type)
byte[] px	array to append to, cast to byte[] while keeping the same .length. Will be updated.
size_t n	number of elements to append

Returns:

px after being appended to

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[]

void* _d_arrayliteralTX(const TypeInfo ti, size_t length);

Allocate an array literal

Rely on the caller to do the initialization of the array.

int[] getArr()
{
    return [10, 20];
    // auto res = cast(int*) _d_arrayliteralTX(typeid(int[]), 2);
    // res[0] = 10;
    // res[1] = 20;
    // return res[0..2];
}

Parameters:

TypeInfo ti	TypeInfo of resulting array type
size_t length	.length of array literal

Returns:

pointer to allocated array