root/branches/dmdfe-2.0/e2ir.c

// Compiler implementation of the D programming language
// Copyright (c) 1999-2008 by Digital Mars
// All Rights Reserved
// written by Walter Bright
// http://www.digitalmars.com
// License for redistribution is by either the Artistic License
// in artistic.txt, or the GNU General Public License in gnu.txt.
// See the included readme.txt for details.

#include    <stdio.h>
#include    <string.h>
#include    <time.h>
#include    <complex.h>

#include    "lexer.h"
#include    "expression.h"
#include    "mtype.h"
#include    "dsymbol.h"
#include    "declaration.h"
#include    "enum.h"
#include    "aggregate.h"
#include    "attrib.h"
#include    "module.h"
#include    "init.h"
#include    "template.h"

#if _WIN32
#include    "..\tk\mem.h"   // for mem_malloc
#elif linux
#include    "../tk/mem.h"   // for mem_malloc
#endif

#include    "cc.h"
#include    "el.h"
#include    "oper.h"
#include    "global.h"
#include    "code.h"
#include    "type.h"
#include    "dt.h"
#include    "irstate.h"
#include    "id.h"
#include    "type.h"
#include    "toir.h"

static char __file__[] = __FILE__;  /* for tassert.h        */
#include    "tassert.h"


elem *addressElem(elem *e, Type *t);
elem *array_toPtr(Type *t, elem *e);
elem *bit_assign(enum OPER op, elem *eb, elem *ei, elem *ev, int result);
elem *bit_read(elem *eb, elem *ei, int result);
elem *exp2_copytotemp(elem *e);

#define el_setLoc(e,loc)    ((e)->Esrcpos.Sfilename = (loc).filename, \
                 (e)->Esrcpos.Slinnum = (loc).linnum)

/************************************
 * Call a function.
 */

elem *callfunc(Loc loc,
    IRState *irs,
    int directcall,     // 1: don't do virtual call
    Type *tret,     // return type
    elem *ec,       // evaluates to function address
    Type *ectype,       // original type of ec
    FuncDeclaration *fd,    // if !=NULL, this is the function being called
    Type *t,        // TypeDelegate or TypeFunction for this function
    elem *ehidden,      // if !=NULL, this is the 'hidden' argument
    Array *arguments)
{
    elem *ep;
    elem *e;
    elem *ethis = NULL;
    elem *eside = NULL;
    int i;
    tym_t ty;
    tym_t tyret;
    enum RET retmethod;
    int reverse;
    TypeFunction *tf;
    int op;

#if 0
    printf("callfunc(directcall = %d, tret = '%s', ec = %p, fd = %p)\n",
    directcall, tret->toChars(), ec, fd);
    printf("ec: "); elem_print(ec);
    if (fd)
    printf("fd = '%s'\n", fd->toChars());
#endif

    t = t->toBasetype();
    if (t->ty == Tdelegate)
    {
    // A delegate consists of:
    //  { Object *this; Function *funcptr; }
    assert(!fd);
    assert(t->nextOf()->ty == Tfunction);
    tf = (TypeFunction *)(t->nextOf());
    ethis = ec;
    ec = el_same(&ethis);
    ethis = el_una(OP64_32, TYnptr, ethis); // get this
    ec = array_toPtr(t, ec);        // get funcptr
    ec = el_una(OPind, tf->totym(), ec);
    }
    else
    {   assert(t->ty == Tfunction);
    tf = (TypeFunction *)(t);
    }
    retmethod = tf->retStyle();
    ty = ec->Ety;
    if (fd)
    ty = fd->toSymbol()->Stype->Tty;
    reverse = tyrevfunc(ty);
    ep = NULL;
    if (arguments)
    {
    // j=1 if _arguments[] is first argument
    int j = (tf->linkage == LINKd && tf->varargs == 1);

    for (i = 0; i < arguments->dim ; i++)
    {   Expression *arg;
        elem *ea;

        arg = (Expression *)arguments->data[i];
        //printf("\targ[%d]: %s\n", i, arg->toChars());

        size_t nparams = Argument::dim(tf->parameters);
        if (i - j < nparams && i >= j)
        {
        Argument *p = Argument::getNth(tf->parameters, i - j);

        if (p->storageClass & (STCout | STCref))
        {
            // Convert argument to a pointer,
            // use AddrExp::toElem()
            Expression *ae = arg->addressOf(NULL);
            ea = ae->toElem(irs);
            goto L1;
        }
        }
        ea = arg->toElem(irs);
    L1:
        if (ea->Ety == TYstruct)
        {
        ea = el_una(OPstrpar, TYstruct, ea);
        ea->Enumbytes = ea->E1->Enumbytes;
        assert(ea->Enumbytes);
        }
        if (reverse)
        ep = el_param(ep,ea);
        else
        ep = el_param(ea,ep);
    }
    }

    if (retmethod == RETstack)
    {
    if (!ehidden)
    {   // Don't have one, so create one
        type *t;

        if (tf->next->toBasetype()->ty == Tstruct)
        t = tf->next->toCtype();
        else
        t = type_fake(tf->next->totym());
        Symbol *stmp = symbol_genauto(t);
        ehidden = el_ptr(stmp);
    }
    if (ep)
    {
#if 0 // BUG: implement
        if (reverse && type_mangle(tfunc) == mTYman_cpp)
        ep = el_param(ehidden,ep);
        else
#endif
        ep = el_param(ep,ehidden);
    }
    else
        ep = ehidden;
    ehidden = NULL;
    }
    assert(ehidden == NULL);

    if (fd && fd->isMember2())
    {
    InterfaceDeclaration *intd;
    Symbol *sfunc;
    AggregateDeclaration *ad;

    ad = fd->isThis();
    if (ad)
    {
        ethis = ec;
        if (ad->handle->ty == Tpointer && tybasic(ec->Ety) != TYnptr)
        {
        ethis = addressElem(ec, ectype);
        }
    }
    else
    {
        // Evaluate ec for side effects
        eside = ec;
    }
    sfunc = fd->toSymbol();

    if (!fd->isVirtual() ||
        directcall ||       // BUG: fix
        fd->isFinal()
       )
    {
        // make static call
        ec = el_var(sfunc);
    }
    else
    {
        // make virtual call
        elem *ev;
        unsigned vindex;

        assert(ethis);
        ev = el_same(&ethis);
        ev = el_una(OPind, TYnptr, ev);
        vindex = fd->vtblIndex;

        // Build *(ev + vindex * 4)
        ec = el_bin(OPadd,TYnptr,ev,el_long(TYint, vindex * 4));
        ec = el_una(OPind,TYnptr,ec);
        ec = el_una(OPind,tybasic(sfunc->Stype->Tty),ec);
    }
    }
    else if (fd && fd->isNested())
    {
    assert(!ethis);
    ethis = getEthis(0, irs, fd);

    }

    ep = el_param(ep, ethis);

    tyret = tret->totym();

    // Look for intrinsic functions
    if (ec->Eoper == OPvar && (op = intrinsic_op(ec->EV.sp.Vsym->Sident)) != -1)
    {
    el_free(ec);
    if (OTbinary(op))
    {
        ep->Eoper = op;
        ep->Ety = tyret;
        e = ep;
        if (op == OPscale)
        {   elem *et;

        et = e->E1;
        e->E1 = el_una(OPs32_d, TYdouble, e->E2);
        e->E1 = el_una(OPd_ld, TYldouble, e->E1);
        e->E2 = et;
        e->Ety = tyret;
        }
    }
    else
        e = el_una(op,tyret,ep);
    }
    else if (ep)
    e = el_bin(OPcall,tyret,ec,ep);
    else
    e = el_una(OPucall,tyret,ec);

    if (retmethod == RETstack)
    {
    e->Ety = TYnptr;
    e = el_una(OPind, tyret, e);
    }
    if (tybasic(tyret) == TYstruct)
    {
    e->Enumbytes = tret->size();
    }
    e = el_combine(eside, e);
    return e;
}

/*******************************************
 * Take address of an elem.
 */

elem *addressElem(elem *e, Type *t)
{
    elem **pe;

    //printf("addressElem()\n");

    for (pe = &e; (*pe)->Eoper == OPcomma; pe = &(*pe)->E2)
    ;
    if ((*pe)->Eoper != OPvar && (*pe)->Eoper != OPind)
    {   Symbol *stmp;
    elem *eeq;
    elem *e = *pe;
    type *tx;

    // Convert to ((tmp=e),tmp)
    TY ty;
    if (t && ((ty = t->toBasetype()->ty) == Tstruct || ty == Tsarray))
        tx = t->toCtype();
    else
        tx = type_fake(e->Ety);
    stmp = symbol_genauto(tx);
    eeq = el_bin(OPeq,e->Ety,el_var(stmp),e);
    if (e->Ety == TYstruct)
    {
        eeq->Eoper = OPstreq;
        eeq->Enumbytes = e->Enumbytes;
    }
    else if (e->Ety == TYarray)
    {
        eeq->Eoper = OPstreq;
        eeq->Ejty = eeq->Ety = TYstruct;
        eeq->Enumbytes = t->size();
    }
    *pe = el_bin(OPcomma,e->Ety,eeq,el_var(stmp));
    }
    e = el_una(OPaddr,TYnptr,e);
    return e;
}

/*****************************************
 * Convert array to a pointer to the data.
 */

elem *array_toPtr(Type *t, elem *e)
{
    //printf("array_toPtr()\n");
    //elem_print(e);
    t = t->toBasetype();
    switch (t->ty)
    {
    case Tpointer:
        break;

    case Tarray:
    case Tdelegate:
        if (e->Eoper == OPcomma)
        {
        e->Ety = TYnptr;
        e->E2 = array_toPtr(t, e->E2);
        }
        else if (e->Eoper == OPpair)
        {
        e->Eoper = OPcomma;
        e->Ety = TYnptr;
        }
        else
        {
#if 1
        e = el_una(OPmsw, TYnptr, e);
#else
        e = el_una(OPaddr, TYnptr, e);
        e = el_bin(OPadd, TYnptr, e, el_long(TYint, 4));
        e = el_una(OPind, TYnptr, e);
#endif
        }
        break;

    case Tsarray:
        e = el_una(OPaddr, TYnptr, e);
        break;

    default:
        t->print();
        assert(0);
    }
    return e;
}

/*****************************************
 * Convert array to a dynamic array.
 */

elem *array_toDarray(Type *t, elem *e)
{
    unsigned dim;
    elem *ef = NULL;
    elem *ex;

    //printf("array_toDarray(t = %s)\n", t->toChars());
    //elem_print(e);
    t = t->toBasetype();
    switch (t->ty)
    {
    case Tarray:
        break;

    case Tsarray:
        e = el_una(OPaddr, TYnptr, e);
        dim = ((TypeSArray *)t)->dim->toInteger();
        e = el_pair(TYullong, el_long(TYint, dim), e);
        break;

    default:
    L1:
        switch (e->Eoper)
        {
        case OPconst:
        {
            size_t len = tysize[tybasic(e->Ety)];
            elem *es = el_calloc();
            es->Eoper = OPstring;

            // Match MEM_PH_FREE for OPstring in ztc\el.c
            es->EV.ss.Vstring = (char *)mem_malloc(len);
            memcpy(es->EV.ss.Vstring, &e->EV, len);

            es->EV.ss.Vstrlen = len;
            es->Ety = TYnptr;
            e = es;
            break;
        }

        case OPvar:
            e = el_una(OPaddr, TYnptr, e);
            break;

        case OPcomma:
            ef = el_combine(ef, e->E1);
            ex = e;
            e = e->E2;
            ex->E1 = NULL;
            ex->E2 = NULL;
            el_free(ex);
            goto L1;

        case OPind:
            ex = e;
            e = e->E1;
            ex->E1 = NULL;
            ex->E2 = NULL;
            el_free(ex);
            break;

        default:
        {
            // Copy expression to a variable and take the
            // address of that variable.
            Symbol *stmp;
            tym_t ty = tybasic(e->Ety);

            if (ty == TYstruct)
            {
            if (e->Enumbytes == 4)
                ty = TYint;
            else if (e->Enumbytes == 8)
                ty = TYllong;
            }
            e->Ety = ty;
            stmp = symbol_genauto(type_fake(ty));
            e = el_bin(OPeq, e->Ety, el_var(stmp), e);
            e = el_bin(OPcomma, TYnptr, e, el_una(OPaddr, TYnptr, el_var(stmp)));
            break;
        }
        }
        dim = 1;
        e = el_pair(TYullong, el_long(TYint, dim), e);
        break;
    }
    return el_combine(ef, e);
}

/*****************************************
 * Evaluate elem and convert to dynamic array.
 */

elem *eval_Darray(IRState *irs, Expression *e)
{
    elem *ex;

    ex = e->toElem(irs);
    return array_toDarray(e->type, ex);
}

/************************************
 */

elem *sarray_toDarray(Loc loc, Type *tfrom, Type *tto, elem *e)
{
    //printf("sarray_toDarray()\n");
    //elem_print(e);

    elem *elen;
    unsigned dim = ((TypeSArray *)tfrom)->dim->toInteger();

    if (tto)
    {
    unsigned fsize = tfrom->nextOf()->size();
    unsigned tsize = tto->nextOf()->size();

    if ((dim * fsize) % tsize != 0)
    {
      Lerr:
        error(loc, "cannot cast %s to %s since sizes don't line up", tfrom->toChars(), tto->toChars());
    }
    dim = (dim * fsize) / tsize;
    }
  L1:
    elen = el_long(TYint, dim);
    e = el_una(OPaddr, TYnptr, e);
    e = el_pair(TYullong, elen, e);
    return e;
}

/*******************************************
 * Set an array pointed to by eptr to evalue:
 *  eptr[0..edim] = evalue;
 * Input:
 *  eptr    where to write the data to
 *  evalue  value to write
 *  edim    number of times to write evalue to eptr[]
 *  tb  type of evalue
 */

elem *setArray(elem *eptr, elem *edim, Type *tb, elem *evalue, IRState *irs, int op)
{   int r;
    elem *e;
    int sz = tb->size();

    if (tb->ty == Tfloat80 || tb->ty == Timaginary80)
    r = RTLSYM_MEMSET80;
    else if (tb->ty == Tcomplex80)
    r = RTLSYM_MEMSET160;
    else if (tb->ty == Tcomplex64)
    r = RTLSYM_MEMSET128;
    else
    {
    switch (sz)
    {
        case 1:  r = RTLSYM_MEMSET8;    break;
        case 2:  r = RTLSYM_MEMSET16;   break;
        case 4:  r = RTLSYM_MEMSET32;   break;
        case 8:  r = RTLSYM_MEMSET64;   break;
        default:     r = RTLSYM_MEMSETN;    break;
    }

    /* Determine if we need to do postblit
     */
    if (op != TOKblit)
    {
        Type *t = tb;
        while (t->ty == Tsarray)
        t = t->nextOf()->toBasetype();
        if (t->ty == Tstruct)
        {   StructDeclaration *sd = ((TypeStruct *)t)->sym;
        if (sd->postblit)
        {   /* Need to do postblit.
             *   void *_d_arraysetassign(void *p, void *value, int dim, TypeInfo ti);
             */
            r = (op == TOKconstruct) ? RTLSYM_ARRAYSETCTOR : RTLSYM_ARRAYSETASSIGN;
            evalue = el_una(OPaddr, TYnptr, evalue);
            Expression *ti = tb->getTypeInfo(NULL);
            elem *eti = ti->toElem(irs);
            e = el_params(eti, edim, evalue, eptr, NULL);
            e = el_bin(OPcall,TYnptr,el_var(rtlsym[r]),e);
            return e;
        }
        }
    }

    if (r == RTLSYM_MEMSETN)
    {
        // void *_memsetn(void *p, void *value, int dim, int sizelem)
        evalue = el_una(OPaddr, TYnptr, evalue);
        elem *esz = el_long(TYint, sz);
        e = el_params(esz, edim, evalue, eptr, NULL);
        e = el_bin(OPcall,TYnptr,el_var(rtlsym[r]),e);
        return e;
    }
    }
    if (sz > 1 && sz <= 8 &&
    evalue->Eoper == OPconst && el_allbits(evalue, 0))
    {
    r = RTLSYM_MEMSET8;
    edim = el_bin(OPmul, TYuint, edim, el_long(TYuint, sz));
    }

    if (evalue->Ety == TYstruct)
    {
    evalue = el_una(OPstrpar, TYstruct, evalue);
    evalue->Enumbytes = evalue->E1->Enumbytes;
    assert(evalue->Enumbytes);
    }

    // Be careful about parameter side effect ordering
    if (r == RTLSYM_MEMSET8)
    {
    e = el_param(edim, evalue);
    e = el_bin(OPmemset,TYnptr,eptr,e);
    }
    else
    {
    e = el_params(edim, evalue, eptr, NULL);
    e = el_bin(OPcall,TYnptr,el_var(rtlsym[r]),e);
    }
    return e;
}

/***************************************
 */

elem *Expression::toElem(IRState *irs)
{
    print();
    assert(0);
    return NULL;
}

/************************************
 */

elem *SymbolExp::toElem(IRState *irs)
{   Symbol *s;
    elem *e;
    tym_t tym;
    Type *tb = (op == TOKsymoff) ? var->type->toBasetype() : type->toBasetype();
    int offset = (op == TOKsymoff) ? ((SymOffExp*)this)->offset : 0;
    FuncDeclaration *fd;
    VarDeclaration *v = var->isVarDeclaration();

    //printf("SymbolExp::toElem('%s') %p\n", toChars(), this);
    //printf("\tparent = '%s'\n", var->parent ? var->parent->toChars() : "null");
    if (op == TOKvar && var->needThis())
    {
    error("need 'this' to access member %s",