Re: Does foreach on array literal allocate?

[Walter Bright]

Bill Baxter wrote:
Does anyone know off the top of their head if code like this allocates
or not with current DMD 1.x compilers?
foreach(x; [1, 2, 3, 4])
{
     // do something non-allocating with x
}

Here's how to find out. Compile:

void test()
{
    foreach(x; [1, 2, 3, 4])
    {
         // do something non-allocating with x
    }
}

Obj2asm the output:

_D5test44testFZv        comdat
        assume  CS:_D5test44testFZv
L0:             enter   8,0
                push    EBX
                push    4
                push    3
                push    2
                push    1
                push    4
                push    offset FLAT:_D12TypeInfo_G4i6__initZ
                call    near ptr __d_arrayliteralT
                mov     -8[EBP],EAX
                lea     EAX,010h[EAX]
                mov     -4[EBP],EAX
                add     ESP,018h
L25:            mov     ECX,-8[EBP]
                cmp     ECX,-4[EBP]
                jae     L38
                mov     EDX,-8[EBP]
                mov     EBX,[EDX]
                add     dword ptr -8[EBP],4
                jmp short       L25
L38:            pop     EBX
                leave
                ret
_D5test44testFZv        ends

Look up _d_arrayliteralT in the runtime library:

extern (C) void* _d_arrayliteralT(TypeInfo ti, size_t length, ...)
{
    auto sizeelem = ti.next.tsize();            // array element size
    void* result;

    debug(PRINTF) printf("_d_arrayliteralT(sizeelem = %d, length = 
%d)\n", sizeelem, length);
    if (length == 0 || sizeelem == 0)
        result = null;
    else
    {
        result = gc_malloc(length * sizeelem, !(ti.next.flags() & 1) ? 
BlkAttr.NO_SCAN : 0);

        va_list q;
        va_start!(size_t)(q, length);

        size_t stacksize = (sizeelem + int.sizeof - 1) & ~(int.sizeof - 1);

        if (stacksize == sizeelem)
        {
            memcpy(result, q, length * sizeelem);
        }
        else
        {
            for (size_t i = 0; i < length; i++)
            {
                memcpy(result + i * sizeelem, q, sizeelem);
                q += stacksize;
            }
        }

        va_end(q);
    }
    return result;
}

and note the call to gc_malloc().