root/branches/dmdfe-2.0/constfold.c

// Compiler implementation of the D programming language
// Copyright (c) 1999-2007 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 <stdlib.h>
#include <assert.h>
#include <math.h>

#if __DMC__
#include <complex.h>
#endif

#include "mem.h"
#include "root.h"

#include "mtype.h"
#include "expression.h"
#include "aggregate.h"
#include "declaration.h"

#ifdef IN_GCC
#include "d-gcc-real.h"

/* %% fix? */
extern "C" bool real_isnan (const real_t *);
#endif

static real_t zero; // work around DMC bug for now

#define LOG 0

Expression *expType(Type *type, Expression *e)
{
    if (type != e->type)
    {
    e = e->copy();
    e->type = type;
    }
    return e;
}

/* ================================== isConst() ============================== */

int Expression::isConst()
{
    //printf("Expression::isConst(): %s\n", toChars());
    return 0;
}

int IntegerExp::isConst()
{
    return 1;
}

int RealExp::isConst()
{
    return 1;
}

int ComplexExp::isConst()
{
    return 1;
}

int SymOffExp::isConst()
{
    return 2;
}

/* =============================== constFold() ============================== */

/* The constFold() functions were redundant with the optimize() ones,
 * and so have been folded in with them.
 */

/* ========================================================================== */

Expression *Neg(Type *type, Expression *e1)
{   Expression *e;
    Loc loc = e1->loc;

    if (e1->type->isreal())
    {
    e = new RealExp(loc, -e1->toReal(), type);
    }
    else if (e1->type->isimaginary())
    {
    e = new RealExp(loc, -e1->toImaginary(), type);
    }
    else if (e1->type->iscomplex())
    {
    e = new ComplexExp(loc, -e1->toComplex(), type);
    }
    else
    e = new IntegerExp(loc, -e1->toInteger(), type);
    return e;
}

Expression *Com(Type *type, Expression *e1)
{   Expression *e;
    Loc loc = e1->loc;

    e = new IntegerExp(loc, ~e1->toInteger(), type);
    return e;
}

Expression *Not(Type *type, Expression *e1)
{   Expression *e;
    Loc loc = e1->loc;

    e = new IntegerExp(loc, e1->isBool(0), type);
    return e;
}

Expression *Bool(Type *type, Expression *e1)
{   Expression *e;
    Loc loc = e1->loc;

    e = new IntegerExp(loc, e1->isBool(1), type);
    return e;
}

Expression *Add(Type *type, Expression *e1, Expression *e2)
{   Expression *e;
    Loc loc = e1->loc;

#if LOG
    printf("Add(e1 = %s, e2 = %s)\n", e1->toChars(), e2->toChars());
#endif
    if (type->isreal())
    {
    e = new RealExp(loc, e1->toReal() + e2->toReal(), type);
    }
    else if (type->isimaginary())
    {
    e = new RealExp(loc, e1->toImaginary() + e2->toImaginary(), type);
    }
    else if (type->iscomplex())
    {
    // This rigamarole is necessary so that -0.0 doesn't get
    // converted to +0.0 by doing an extraneous add with +0.0
    complex_t c1;
    real_t r1;
    real_t i1;

    complex_t c2;
    real_t r2;
    real_t i2;

    complex_t v;
    int x;

    if (e1->type->isreal())
    {   r1 = e1->toReal();
        x = 0;
    }
    else if (e1->type->isimaginary())
    {   i1 = e1->toImaginary();
        x = 3;
    }
    else
    {   c1 = e1->toComplex();
        x = 6;
    }

    if (e2->type->isreal())
    {   r2 = e2->toReal();
    }
    else if (e2->type->isimaginary())
    {   i2 = e2->toImaginary();
        x += 1;
    }
    else
    {   c2 = e2->toComplex();
        x += 2;
    }

    switch (x)
    {
#if __DMC__
        case 0+0:   v = (complex_t) (r1 + r2);  break;
        case 0+1:   v = r1 + i2 * I;        break;
        case 0+2:   v = r1 + c2;            break;
        case 3+0:   v = i1 * I + r2;        break;
        case 3+1:   v = (complex_t) ((i1 + i2) * I); break;
        case 3+2:   v = i1 * I + c2;        break;
        case 6+0:   v = c1 + r2;            break;
        case 6+1:   v = c1 + i2 * I;        break;
        case 6+2:   v = c1 + c2;            break;
#else
        case 0+0:   v = complex_t(r1 + r2, 0);  break;
        case 0+1:   v = complex_t(r1, i2);      break;
        case 0+2:   v = complex_t(r1 + creall(c2), cimagl(c2)); break;
        case 3+0:   v = complex_t(r2, i1);      break;
        case 3+1:   v = complex_t(0, i1 + i2);  break;
        case 3+2:   v = complex_t(creall(c2), i1 + cimagl(c2)); break;
        case 6+0:   v = complex_t(creall(c1) + r2, cimagl(c2)); break;
        case 6+1:   v = complex_t(creall(c1), cimagl(c1) + i2); break;
        case 6+2:   v = c1 + c2;            break;
#endif
        default: assert(0);
    }
    e = new ComplexExp(loc, v, type);
    }
    else if (e1->op == TOKsymoff)
    {
    SymOffExp *soe = (SymOffExp *)e1;
    e = new SymOffExp(loc, soe->var, soe->offset + e2->toInteger());
    e->type = type;
    }
    else if (e2->op == TOKsymoff)
    {
    SymOffExp *soe = (SymOffExp *)e2;
    e = new SymOffExp(loc, soe->var, soe->offset + e1->toInteger());
    e->type = type;
    }
    else
    e = new IntegerExp(loc, e1->toInteger() + e2->toInteger(), type);
    return e;
}


Expression *Min(Type *type, Expression *e1, Expression *e2)
{   Expression *e;
    Loc loc = e1->loc;

    if (type->isreal())
    {
    e = new RealExp(loc, e1->toReal() - e2->toReal(), type);
    }
    else if (type->isimaginary())
    {
    e = new RealExp(loc, e1->toImaginary() - e2->toImaginary(), type);
    }
    else if (type->iscomplex())
    {
    // This rigamarole is necessary so that -0.0 doesn't get
    // converted to +0.0 by doing an extraneous add with +0.0
    complex_t c1;
    real_t r1;
    real_t i1;

    complex_t c2;
    real_t r2;
    real_t i2;

    complex_t v;
    int x;

    if (e1->type->isreal())
    {   r1 = e1->toReal();
        x = 0;
    }
    else if (e1->type->isimaginary())
    {   i1 = e1->toImaginary();
        x = 3;
    }
    else
    {   c1 = e1->toComplex();
        x = 6;
    }

    if (e2->type->isreal())
    {   r2 = e2->toReal();
    }
    else if (e2->type->isimaginary())
    {   i2 = e2->toImaginary();
        x += 1;
    }
    else
    {   c2 = e2->toComplex();
        x += 2;
    }

    switch (x)
    {
#if __DMC__
        case 0+0:   v = (complex_t) (r1 - r2);  break;
        case 0+1:   v = r1 - i2 * I;        break;
        case 0+2:   v = r1 - c2;            break;
        case 3+0:   v = i1 * I - r2;        break;
        case 3+1:   v = (complex_t) ((i1 - i2) * I); break;
        case 3+2:   v = i1 * I - c2;        break;
        case 6+0:   v = c1 - r2;            break;
        case 6+1:   v = c1 - i2 * I;        break;
        case 6+2:   v = c1 - c2;            break;
#else
        case 0+0:   v = complex_t(r1 - r2, 0);  break;
        case 0+1:   v = complex_t(r1, -i2);     break;
        case 0+2:   v = complex_t(r1 - creall(c2), -cimagl(c2));    break;
        case 3+0:   v = complex_t(-r2, i1);     break;
        case 3+1:   v = complex_t(0, i1 - i2);  break;
        case 3+2:   v = complex_t(-creall(c2), i1 - cimagl(c2));    break;
        case 6+0:   v = complex_t(creall(c1) - r2, cimagl(c1)); break;
        case 6+1:   v = complex_t(creall(c1), cimagl(c1) - i2); break;
        case 6+2:   v = c1 - c2;            break;
#endif
        default: assert(0);
    }
    e = new ComplexExp(loc, v, type);
    }
    else if (e1->op == TOKsymoff)
    {
    SymOffExp *soe = (SymOffExp *)e1;
    e = new SymOffExp(loc, soe->var, soe->offset - e2->toInteger());
    e->type = type;
    }
    else
    {
    e = new IntegerExp(loc, e1->toInteger() - e2->toInteger(), type);
    }
    return e;
}

Expression *Mul(Type *type, Expression *e1, Expression *e2)
{   Expression *e;
    Loc loc = e1->loc;

    if (type->isfloating())
    {   complex_t c;
#ifdef IN_GCC
    real_t r;
#else
    d_float80 r;
#endif

    if (e1->type->isreal())
    {
#if __DMC__
        c = e1->toReal() * e2->toComplex();
#else
        r = e1->toReal();
        c = e2->toComplex();
        c = complex_t(r * creall(c), r * cimagl(c));
#endif
    }
    else if (e1->type->isimaginary())
    {
#if __DMC__
        c = e1->toImaginary() * I * e2->toComplex();
#else
        r = e1->toImaginary();
        c = e2->toComplex();
        c = complex_t(-r * cimagl(c), r * creall(c));
#endif
    }
    else if (e2->type->isreal())
    {
#if __DMC__
        c = e2->toReal() * e1->toComplex();
#else
        r = e2->toReal();
        c = e1->toComplex();
        c = complex_t(r * creall(c), r * cimagl(c));
#endif
    }
    else if (e2->type->isimaginary())
    {
#if __DMC__
        c = e1->toComplex() * e2->toImaginary() * I;
#else
        r = e2->toImaginary();
        c = e1->toComplex();
        c = complex_t(-r * cimagl(c), r * creall(c));
#endif
    }
    else
        c = e1->toComplex() * e2->toComplex();

    if (type->isreal())
        e = new RealExp(loc, creall(c), type);
    else if (type->isimaginary())
        e = new RealExp(loc, cimagl(c), type);
    else if (type->iscomplex())
        e = new ComplexExp(loc, c, type);
    else
        assert(0);
    }
    else
    {
    e = new IntegerExp(loc, e1->toInteger() * e2->toInteger(), type);
    }
    return e;
}

Expression *Div(Type *type, Expression *e1, Expression *e2)
{   Expression *e;
    Loc loc = e1->loc;

    if (type->isfloating())
    {   complex_t c;
#ifdef IN_GCC
    real_t r;
#else
    d_float80 r;
#endif

    //e1->type->print();
    //e2->type->print();
    if (e2->type->isreal())
    {
        if (e1->type->isreal())
        {
        e = new RealExp(loc, e1->toReal() / e2->toReal(), type);
        return e;
        }
#if __DMC__
        //r = e2->toReal();
        //c = e1->toComplex();
        //printf("(%Lg + %Lgi) / %Lg\n", creall(c), cimagl(c), r);

        c = e1->toComplex() / e2->toReal();
#else
        r = e2->toReal();
        c = e1->toComplex();
        c = complex_t(creall(c) / r, cimagl(c) / r);
#endif
    }
    else if (e2->type->isimaginary())
    {
#if __DMC__
        //r = e2->toImaginary();
        //c = e1->toComplex();
        //printf("(%Lg + %Lgi) / %Lgi\n", creall(c), cimagl(c), r);

        c = e1->toComplex() / (e2->toImaginary() * I);
#else
        r = e2->toImaginary();
        c = e1->toComplex();
        c = complex_t(cimagl(c) / r, -creall(c) / r);
#endif
    }
    else
    {
        c = e1->toComplex() / e2->toComplex();
    }

    if (type->isreal())
        e = new RealExp(loc, creall(c), type);
    else if (type->isimaginary())
        e = new RealExp(loc, cimagl(c), type);
    else if (type->iscomplex())
        e = new ComplexExp(loc, c, type);
    else
        assert(0);
    }
    else
    {   sinteger_t n1;
    sinteger_t n2;
    sinteger_t n;

    n1 = e1->toInteger();
    n2 = e2->toInteger();
    if (n2 == 0)
    {   e2->error("divide by 0");
        e2 = new IntegerExp(loc, 1, e2->type);
        n2 = 1;
    }
    if (e1->type->isunsigned() || e2->type->isunsigned())
        n = ((d_uns64) n1) / ((d_uns64) n2);
    else
        n = n1 / n2;
    e = new IntegerExp(loc, n, type);
    }
    return e;
}

Expression *Mod(Type *type, Expression *e1, Expression *e2)
{   Expression *e;
    Loc loc = e1->loc;

    if (type->isfloating())
    {
    complex_t c;

    if (e2->type->isreal())
    {   real_t r2 = e2->toReal();

#ifdef __DMC__
        c = fmodl(e1->toReal(), r2) + fmodl(e1->toImaginary(), r2) * I;
#elif defined(IN_GCC)
        c = complex_t(e1->toReal() % r2, e1->toImaginary() % r2);
#else
        c = complex_t(fmodl(e1->toReal(), r2), fmodl(e1->toImaginary(), r2));
#endif
    }
    else if (e2->type->isimaginary())
    {   real_t i2 = e2->toImaginary();

#ifdef __DMC__
        c = fmodl(e1->toReal(), i2) + fmodl(e1->toImaginary(), i2) * I;
#elif defined(IN_GCC)
        c = complex_t(e1->toReal() % i2, e1->toImaginary() % i2);
#else
        c = complex_t(fmodl(e1->toReal(), i2), fmodl(e1->toImaginary(), i2));
#endif
    }
    else
        assert(0);

    if (type->isreal())
        e = new RealExp(loc, creall(c), type);
    else if (type->isimaginary())
        e = new RealExp(loc, cimagl(c), type);
    else if (type->iscomplex())
        e = new ComplexExp(loc, c, type);
    else
        assert(0);
    }
    else
    {   sinteger_t n1;
    sinteger_t n2;
    sinteger_t n;

    n1 = e1->toInteger();
    n2 = e2->toInteger();
    if (n2 == 0)
    {   e2->error("divide by 0");
        e2 = new IntegerExp(loc, 1, e2->type);
        n2 = 1;
    }
    if (e1->type->isunsigned() || e2->type->isunsigned())
        n = ((d_uns64) n1) % ((d_uns64) n2);
    else
        n = n1 % n2;
    e = new IntegerExp(loc, n, type);
    }
    return e;
}

Expression *Shl(Type *type, Expression *e1, Expression *e2)
{   Expression *e;
    Loc loc = e1->loc;

    e = new IntegerExp(loc, e1->toInteger() << e2->toInteger(), type);
    return e;
}

Expression *Shr(Type *type, Expression *e1, Expression *e2)
{   Expression *e;
    Loc loc = e1->loc;
    unsigned count;
    integer_t value;

    value = e1->toInteger();
    count = e2->toInteger();
    switch (e1->type->toBasetype()->ty)
    {
    case Tint8:
        value = (d_int8)(value) >> count;
        break;

    case Tuns8:
        value = (d_uns8)(value) >> count;
        break;

    case Tint16:
        value = (d_int16)(value) >> count;
        break;

    case Tuns16:
        value = (d_uns16)(value) >> count;
        break;

    case Tint32:
        value = (d_int32)(value) >> count;
        break;

    case Tuns32:
        value = (d_uns32)(value) >> count;
        break;

    case Tint64:
        value = (d_int64)(value) >> count;
        break;<