src/cmd/gc/const.c

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
truncfltlit
convlit
convlit1
copyval
tocplx
toflt
toint
doesoverflow
overflow
tostr
consttype
isconst
saveorig
evconst
nodlit
nodcplxlit
idealkind
defaultlit
defaultlit2
cmpslit
smallintconst
nonnegconst
iconv
convconst
cmplxmpy
cmplxdiv
isgoconst
hascallchan
// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

#include        <u.h>
#include        <libc.h>
#include        "go.h"
#define TUP(x,y)        (((x)<<16)|(y))

static  Val     tocplx(Val);
static  Val     toflt(Val);
static  Val     tostr(Val);
static  Val     copyval(Val);
static  void    cmplxmpy(Mpcplx*, Mpcplx*);
static  void    cmplxdiv(Mpcplx*, Mpcplx*);

/*
 * truncate float literal fv to 32-bit or 64-bit precision
 * according to type; return truncated value.
 */
Mpflt*
truncfltlit(Mpflt *oldv, Type *t)
{
        double d;
        Mpflt *fv;
        Val v;

        if(t == T)
                return oldv;

        memset(&v, 0, sizeof v);
        v.ctype = CTFLT;
        v.u.fval = oldv;
        overflow(v, t);

        fv = mal(sizeof *fv);
        *fv = *oldv;

        // convert large precision literal floating
        // into limited precision (float64 or float32)
        switch(t->etype) {
        case TFLOAT64:
                d = mpgetflt(fv);
                mpmovecflt(fv, d);
                break;

        case TFLOAT32:
                d = mpgetflt32(fv);
                mpmovecflt(fv, d);

                break;
        }
        return fv;
}

/*
 * convert n, if literal, to type t.
 * implicit conversion.
 */
void
convlit(Node **np, Type *t)
{
        convlit1(np, t, 0);
}

/*
 * convert n, if literal, to type t.
 * return a new node if necessary
 * (if n is a named constant, can't edit n->type directly).
 */
void
convlit1(Node **np, Type *t, int explicit)
{
        int ct, et;
        Node *n, *nn;

        n = *np;
        if(n == N || t == T || n->type == T || isideal(t) || n->type == t)
                return;
        if(!explicit && !isideal(n->type))
                return;

        if(n->op == OLITERAL) {
                nn = nod(OXXX, N, N);
                *nn = *n;
                n = nn;
                *np = n;
        }

        switch(n->op) {
        default:
                if(n->type == idealbool) {
                        if(t->etype == TBOOL)
                                n->type = t;
                        else
                                n->type = types[TBOOL];
                }
                if(n->type->etype == TIDEAL) {
                        convlit(&n->left, t);
                        convlit(&n->right, t);
                        n->type = t;
                }
                return;
        case OLITERAL:
                // target is invalid type for a constant?  leave alone.
                if(!okforconst[t->etype] && n->type->etype != TNIL) {
                        defaultlit(&n, T);
                        *np = n;
                        return;
                }
                break;
        case OLSH:
        case ORSH:
                convlit1(&n->left, t, explicit && isideal(n->left->type));
                t = n->left->type;
                if(t != T && t->etype == TIDEAL && n->val.ctype != CTINT)
                        n->val = toint(n->val);
                if(t != T && !isint[t->etype]) {
                        yyerror("invalid operation: %N (shift of type %T)", n, t);
                        t = T;
                }
                n->type = t;
                return;
        case OCOMPLEX:
                if(n->type->etype == TIDEAL) {
                        switch(t->etype) {
                        default:
                                // If trying to convert to non-complex type,
                                // leave as complex128 and let typechecker complain.
                                t = types[TCOMPLEX128];
                                //fallthrough
                        case TCOMPLEX128:
                                n->type = t;
                                convlit(&n->left, types[TFLOAT64]);
                                convlit(&n->right, types[TFLOAT64]);
                                break;
                        case TCOMPLEX64:
                                n->type = t;
                                convlit(&n->left, types[TFLOAT32]);
                                convlit(&n->right, types[TFLOAT32]);
                                break;
                        }
                }
                return;
        }

        // avoided repeated calculations, errors
        if(eqtype(n->type, t))
                return;

        ct = consttype(n);
        if(ct < 0)
                goto bad;

        et = t->etype;
        if(et == TINTER) {
                if(ct == CTNIL && n->type == types[TNIL]) {
                        n->type = t;
                        return;
                }
                defaultlit(np, T);
                return;
        }

        switch(ct) {
        default:
                goto bad;

        case CTNIL:
                switch(et) {
                default:
                        n->type = T;
                        goto bad;

                case TSTRING:
                        // let normal conversion code handle it
                        return;

                case TARRAY:
                        if(!isslice(t))
                                goto bad;
                        break;

                case TPTR32:
                case TPTR64:
                case TINTER:
                case TMAP:
                case TCHAN:
                case TFUNC:
                case TUNSAFEPTR:
                        break;

                case TUINTPTR:
                        // A nil literal may be converted to uintptr
                        // if it is an unsafe.Pointer
                        if(n->type->etype == TUNSAFEPTR) {
                                n->val.u.xval = mal(sizeof(*n->val.u.xval));
                                mpmovecfix(n->val.u.xval, 0);
                                n->val.ctype = CTINT;
                        } else
                                goto bad;
                }
                break;

        case CTSTR:
        case CTBOOL:
                if(et != n->type->etype)
                        goto bad;
                break;

        case CTINT:
        case CTRUNE:
        case CTFLT:
        case CTCPLX:
                ct = n->val.ctype;
                if(isint[et]) {
                        switch(ct) {
                        default:
                                goto bad;
                        case CTCPLX:
                        case CTFLT:
                        case CTRUNE:
                                n->val = toint(n->val);
                                // flowthrough
                        case CTINT:
                                overflow(n->val, t);
                                break;
                        }
                } else
                if(isfloat[et]) {
                        switch(ct) {
                        default:
                                goto bad;
                        case CTCPLX:
                        case CTINT:
                        case CTRUNE:
                                n->val = toflt(n->val);
                                // flowthrough
                        case CTFLT:
                                n->val.u.fval = truncfltlit(n->val.u.fval, t);
                                break;
                        }
                } else
                if(iscomplex[et]) {
                        switch(ct) {
                        default:
                                goto bad;
                        case CTFLT:
                        case CTINT:
                        case CTRUNE:
                                n->val = tocplx(n->val);
                                break;
                        case CTCPLX:
                                overflow(n->val, t);
                                break;
                        }
                } else
                if(et == TSTRING && (ct == CTINT || ct == CTRUNE) && explicit)
                        n->val = tostr(n->val);
                else
                        goto bad;
                break;
        }
        n->type = t;
        return;

bad:
        if(!n->diag) {
                if(!t->broke)
                        yyerror("cannot convert %N to type %T", n, t);
                n->diag = 1;
        }
        if(isideal(n->type)) {
                defaultlit(&n, T);
                *np = n;
        }
        return;
}

static Val
copyval(Val v)
{
        Mpint *i;
        Mpflt *f;
        Mpcplx *c;

        switch(v.ctype) {
        case CTINT:
        case CTRUNE:
                i = mal(sizeof(*i));
                mpmovefixfix(i, v.u.xval);
                v.u.xval = i;
                break;
        case CTFLT:
                f = mal(sizeof(*f));
                mpmovefltflt(f, v.u.fval);
                v.u.fval = f;
                break;
        case CTCPLX:
                c = mal(sizeof(*c));
                mpmovefltflt(&c->real, &v.u.cval->real);
                mpmovefltflt(&c->imag, &v.u.cval->imag);
                v.u.cval = c;
                break;
        }
        return v;
}

static Val
tocplx(Val v)
{
        Mpcplx *c;

        switch(v.ctype) {
        case CTINT:
        case CTRUNE:
                c = mal(sizeof(*c));
                mpmovefixflt(&c->real, v.u.xval);
                mpmovecflt(&c->imag, 0.0);
                v.ctype = CTCPLX;
                v.u.cval = c;
                break;
        case CTFLT:
                c = mal(sizeof(*c));
                mpmovefltflt(&c->real, v.u.fval);
                mpmovecflt(&c->imag, 0.0);
                v.ctype = CTCPLX;
                v.u.cval = c;
                break;
        }
        return v;
}

static Val
toflt(Val v)
{
        Mpflt *f;

        switch(v.ctype) {
        case CTINT:
        case CTRUNE:
                f = mal(sizeof(*f));
                mpmovefixflt(f, v.u.xval);
                v.ctype = CTFLT;
                v.u.fval = f;
                break;
        case CTCPLX:
                f = mal(sizeof(*f));
                mpmovefltflt(f, &v.u.cval->real);
                if(mpcmpfltc(&v.u.cval->imag, 0) != 0)
                        yyerror("constant %#F%+#Fi truncated to real", &v.u.cval->real, &v.u.cval->imag);
                v.ctype = CTFLT;
                v.u.fval = f;
                break;
        }
        return v;
}

Val
toint(Val v)
{
        Mpint *i;

        switch(v.ctype) {
        case CTRUNE:
                v.ctype = CTINT;
                break;
        case CTFLT:
                i = mal(sizeof(*i));
                if(mpmovefltfix(i, v.u.fval) < 0)
                        yyerror("constant %#F truncated to integer", v.u.fval);
                v.ctype = CTINT;
                v.u.xval = i;
                break;
        case CTCPLX:
                i = mal(sizeof(*i));
                if(mpmovefltfix(i, &v.u.cval->real) < 0)
                        yyerror("constant %#F%+#Fi truncated to integer", &v.u.cval->real, &v.u.cval->imag);
                if(mpcmpfltc(&v.u.cval->imag, 0) != 0)
                        yyerror("constant %#F%+#Fi truncated to real", &v.u.cval->real, &v.u.cval->imag);
                v.ctype = CTINT;
                v.u.xval = i;
                break;
        }
        return v;
}

int
doesoverflow(Val v, Type *t)
{
        switch(v.ctype) {
        case CTINT:
        case CTRUNE:
                if(!isint[t->etype])
                        fatal("overflow: %T integer constant", t);
                if(mpcmpfixfix(v.u.xval, minintval[t->etype]) < 0 ||
                   mpcmpfixfix(v.u.xval, maxintval[t->etype]) > 0)
                        return 1;
                break;
        case CTFLT:
                if(!isfloat[t->etype])
                        fatal("overflow: %T floating-point constant", t);
                if(mpcmpfltflt(v.u.fval, minfltval[t->etype]) <= 0 ||
                   mpcmpfltflt(v.u.fval, maxfltval[t->etype]) >= 0)
                        return 1;
                break;
        case CTCPLX:
                if(!iscomplex[t->etype])
                        fatal("overflow: %T complex constant", t);
                if(mpcmpfltflt(&v.u.cval->real, minfltval[t->etype]) <= 0 ||
                   mpcmpfltflt(&v.u.cval->real, maxfltval[t->etype]) >= 0 ||
                   mpcmpfltflt(&v.u.cval->imag, minfltval[t->etype]) <= 0 ||
                   mpcmpfltflt(&v.u.cval->imag, maxfltval[t->etype]) >= 0)
                        return 1;
                break;
        }
        return 0;
}

void
overflow(Val v, Type *t)
{
        // v has already been converted
        // to appropriate form for t.
        if(t == T || t->etype == TIDEAL)
                return;

        if(!doesoverflow(v, t))
                return;

        switch(v.ctype) {
        case CTINT:
        case CTRUNE:
                yyerror("constant %B overflows %T", v.u.xval, t);
                break;
        case CTFLT:
                yyerror("constant %#F overflows %T", v.u.fval, t);
                break;
        case CTCPLX:
                yyerror("constant %#F overflows %T", v.u.fval, t);
                break;
        }
}

static Val
tostr(Val v)
{
        Rune rune;
        int l;
        Strlit *s;

        switch(v.ctype) {
        case CTINT:
        case CTRUNE:
                if(mpcmpfixfix(v.u.xval, minintval[TINT]) < 0 ||
                   mpcmpfixfix(v.u.xval, maxintval[TINT]) > 0)
                        yyerror("overflow in int -> string");
                rune = mpgetfix(v.u.xval);
                l = runelen(rune);
                s = mal(sizeof(*s)+l);
                s->len = l;
                runetochar((char*)s->s, &rune);
                memset(&v, 0, sizeof v);
                v.ctype = CTSTR;
                v.u.sval = s;
                break;

        case CTFLT:
                yyerror("no float -> string");

        case CTNIL:
                memset(&v, 0, sizeof v);
                v.ctype = CTSTR;
                v.u.sval = mal(sizeof *s);
                break;
        }
        return v;
}

int
consttype(Node *n)
{
        if(n == N || n->op != OLITERAL)
                return -1;
        return n->val.ctype;
}

int
isconst(Node *n, int ct)
{
        int t;
        
        t = consttype(n);
        // If the caller is asking for CTINT, allow CTRUNE too.
        // Makes life easier for back ends.
        return t == ct || (ct == CTINT && t == CTRUNE);
}

static Node*
saveorig(Node *n)
{
        Node *n1;

        if(n == n->orig) {
                // duplicate node for n->orig.
                n1 = nod(OLITERAL, N, N);
                n->orig = n1;
                *n1 = *n;
        }
        return n->orig;
}

/*
 * if n is constant, rewrite as OLITERAL node.
 */
void
evconst(Node *n)
{
        Node *nl, *nr, *norig;
        int32 len;
        Strlit *str;
        int wl, wr, lno, et;
        Val v, rv;
        Mpint b;
        NodeList *l1, *l2;

        // pick off just the opcodes that can be
        // constant evaluated.
        switch(n->op) {
        default:
                return;
        case OADD:
        case OAND:
        case OANDAND:
        case OANDNOT:
        case OARRAYBYTESTR:
        case OCOM:
        case ODIV:
        case OEQ:
        case OGE:
        case OGT:
        case OLE:
        case OLSH:
        case OLT:
        case OMINUS:
        case OMOD:
        case OMUL:
        case ONE:
        case ONOT:
        case OOR:
        case OOROR:
        case OPLUS:
        case ORSH:
        case OSUB:
        case OXOR:
                break;
        case OCONV:
                if(n->type == T)
                        return;
                if(!okforconst[n->type->etype] && n->type->etype != TNIL)
                        return;
                break;
        
        case OADDSTR:
                // merge adjacent constants in the argument list.
                for(l1=n->list; l1 != nil; l1= l1->next) {
                        if(isconst(l1->n, CTSTR) && l1->next != nil && isconst(l1->next->n, CTSTR)) {
                                l2 = l1;
                                len = 0;
                                while(l2 != nil && isconst(l2->n, CTSTR)) {
                                        nr = l2->n;
                                        len += nr->val.u.sval->len;
                                        l2 = l2->next;
                                }
                                // merge from l1 up to but not including l2
                                str = mal(sizeof(*str) + len);
                                str->len = len;
                                len = 0;
                                l2 = l1;
                                while(l2 != nil && isconst(l2->n, CTSTR)) {
                                        nr = l2->n;
                                        memmove(str->s+len, nr->val.u.sval->s, nr->val.u.sval->len);
                                        len += nr->val.u.sval->len;
                                        l2 = l2->next;
                                }
                                nl = nod(OXXX, N, N);
                                *nl = *l1->n;
                                nl->orig = nl;
                                nl->val.ctype = CTSTR;
                                nl->val.u.sval = str;
                                l1->n = nl;
                                l1->next = l2;
                        }
                }
                // fix list end pointer.
                for(l2=n->list; l2 != nil; l2=l2->next)
                        n->list->end = l2;
                // collapse single-constant list to single constant.
                if(count(n->list) == 1 && isconst(n->list->n, CTSTR)) {
                        n->op = OLITERAL;
                        n->val = n->list->n->val;
                }
                return;
        }

        nl = n->left;
        if(nl == N || nl->type == T)
                return;
        if(consttype(nl) < 0)
                return;
        wl = nl->type->etype;
        if(isint[wl] || isfloat[wl] || iscomplex[wl])
                wl = TIDEAL;

        nr = n->right;
        if(nr == N)
                goto unary;
        if(nr->type == T)
                return;
        if(consttype(nr) < 0)
                return;
        wr = nr->type->etype;
        if(isint[wr] || isfloat[wr] || iscomplex[wr])
                wr = TIDEAL;

        // check for compatible general types (numeric, string, etc)
        if(wl != wr)
                goto illegal;

        // check for compatible types.
        switch(n->op) {
        default:
                // ideal const mixes with anything but otherwise must match.
                if(nl->type->etype != TIDEAL) {
                        defaultlit(&nr, nl->type);
                        n->right = nr;
                }
                if(nr->type->etype != TIDEAL) {
                        defaultlit(&nl, nr->type);
                        n->left = nl;
                }
                if(nl->type->etype != nr->type->etype)
                        goto illegal;
                break;

        case OLSH:
        case ORSH:
                // right must be unsigned.
                // left can be ideal.
                defaultlit(&nr, types[TUINT]);
                n->right = nr;
                if(nr->type && (issigned[nr->type->etype] || !isint[nr->type->etype]))
                        goto illegal;
                if(nl->val.ctype != CTRUNE)
                        nl->val = toint(nl->val);
                nr->val = toint(nr->val);
                break;
        }

        // copy numeric value to avoid modifying
        // n->left, in case someone still refers to it (e.g. iota).
        v = nl->val;
        if(wl == TIDEAL)
                v = copyval(v);

        rv = nr->val;

        // convert to common ideal
        if(v.ctype == CTCPLX || rv.ctype == CTCPLX) {
                v = tocplx(v);
                rv = tocplx(rv);
        }
        if(v.ctype == CTFLT || rv.ctype == CTFLT) {
                v = toflt(v);
                rv = toflt(rv);
        }

        // Rune and int turns into rune.
        if(v.ctype == CTRUNE && rv.ctype == CTINT)
                rv.ctype = CTRUNE;
        if(v.ctype == CTINT && rv.ctype == CTRUNE) {
                if(n->op == OLSH || n->op == ORSH)
                        rv.ctype = CTINT;
                else
                        v.ctype = CTRUNE;
        }

        if(v.ctype != rv.ctype) {
                // Use of undefined name as constant?
                if((v.ctype == 0 || rv.ctype == 0) && nerrors > 0)
                        return;
                fatal("constant type mismatch %T(%d) %T(%d)", nl->type, v.ctype, nr->type, rv.ctype);
        }

        // run op
        switch(TUP(n->op, v.ctype)) {
        default:
        illegal:
                if(!n->diag) {
                        yyerror("illegal constant expression: %T %O %T",
                                nl->type, n->op, nr->type);
                        n->diag = 1;
                }
                return;

        case TUP(OADD, CTINT):
        case TUP(OADD, CTRUNE):
                mpaddfixfix(v.u.xval, rv.u.xval, 0);
                break;
        case TUP(OSUB, CTINT):
        case TUP(OSUB, CTRUNE):
                mpsubfixfix(v.u.xval, rv.u.xval);
                break;
        case TUP(OMUL, CTINT):
        case TUP(OMUL, CTRUNE):
                mpmulfixfix(v.u.xval, rv.u.xval);
                break;
        case TUP(ODIV, CTINT):
        case TUP(ODIV, CTRUNE):
                if(mpcmpfixc(rv.u.xval, 0) == 0) {
                        yyerror("division by zero");
                        mpmovecfix(v.u.xval, 1);
                        break;
                }
                mpdivfixfix(v.u.xval, rv.u.xval);
                break;
        case TUP(OMOD, CTINT):
        case TUP(OMOD, CTRUNE):
                if(mpcmpfixc(rv.u.xval, 0) == 0) {
                        yyerror("division by zero");
                        mpmovecfix(v.u.xval, 1);
                        break;
                }
                mpmodfixfix(v.u.xval, rv.u.xval);
                break;

        case TUP(OLSH, CTINT):
        case TUP(OLSH, CTRUNE):
                mplshfixfix(v.u.xval, rv.u.xval);
                break;
        case TUP(ORSH, CTINT):
        case TUP(ORSH, CTRUNE):
                mprshfixfix(v.u.xval, rv.u.xval);
                break;
        case TUP(OOR, CTINT):
        case TUP(OOR, CTRUNE):
                mporfixfix(v.u.xval, rv.u.xval);
                break;
        case TUP(OAND, CTINT):
        case TUP(OAND, CTRUNE):
                mpandfixfix(v.u.xval, rv.u.xval);
                break;
        case TUP(OANDNOT, CTINT):
        case TUP(OANDNOT, CTRUNE):
                mpandnotfixfix(v.u.xval, rv.u.xval);
                break;
        case TUP(OXOR, CTINT):
        case TUP(OXOR, CTRUNE):
                mpxorfixfix(v.u.xval, rv.u.xval);
                break;

        case TUP(OADD, CTFLT):
                mpaddfltflt(v.u.fval, rv.u.fval);
                break;
        case TUP(OSUB, CTFLT):
                mpsubfltflt(v.u.fval, rv.u.fval);
                break;
        case TUP(OMUL, CTFLT):
                mpmulfltflt(v.u.fval, rv.u.fval);
                break;
        case TUP(ODIV, CTFLT):
                if(mpcmpfltc(rv.u.fval, 0) == 0) {
                        yyerror("division by zero");
                        mpmovecflt(v.u.fval, 1.0);
                        break;
                }
                mpdivfltflt(v.u.fval, rv.u.fval);
                break;
        case TUP(OMOD, CTFLT):
                // The default case above would print 'ideal % ideal',
                // which is not quite an ideal error.
                if(!n->diag) {
                        yyerror("illegal constant expression: floating-point %% operation");
                        n->diag = 1;
                }
                return;

        case TUP(OADD, CTCPLX):
                mpaddfltflt(&v.u.cval->real, &rv.u.cval->real);
                mpaddfltflt(&v.u.cval->imag, &rv.u.cval->imag);
                break;
        case TUP(OSUB, CTCPLX):
                mpsubfltflt(&v.u.cval->real, &rv.u.cval->real);
                mpsubfltflt(&v.u.cval->imag, &rv.u.cval->imag);
                break;
        case TUP(OMUL, CTCPLX):
                cmplxmpy(v.u.cval, rv.u.cval);
                break;
        case TUP(ODIV, CTCPLX):
                if(mpcmpfltc(&rv.u.cval->real, 0) == 0 &&
                   mpcmpfltc(&rv.u.cval->imag, 0) == 0) {
                        yyerror("complex division by zero");
                        mpmovecflt(&rv.u.cval->real, 1.0);
                        mpmovecflt(&rv.u.cval->imag, 0.0);
                        break;
                }
                cmplxdiv(v.u.cval, rv.u.cval);
                break;

        case TUP(OEQ, CTNIL):
                goto settrue;
        case TUP(ONE, CTNIL):
                goto setfalse;

        case TUP(OEQ, CTINT):
        case TUP(OEQ, CTRUNE):
                if(mpcmpfixfix(v.u.xval, rv.u.xval) == 0)
                        goto settrue;
                goto setfalse;
        case TUP(ONE, CTINT):
        case TUP(ONE, CTRUNE):
                if(mpcmpfixfix(v.u.xval, rv.u.xval) != 0)
                        goto settrue;
                goto setfalse;
        case TUP(OLT, CTINT):
        case TUP(OLT, CTRUNE):
                if(mpcmpfixfix(v.u.xval, rv.u.xval) < 0)
                        goto settrue;
                goto setfalse;
        case TUP(OLE, CTINT):
        case TUP(OLE, CTRUNE):
                if(mpcmpfixfix(v.u.xval, rv.u.xval) <= 0)
                        goto settrue;
                goto setfalse;
        case TUP(OGE, CTINT):
        case TUP(OGE, CTRUNE):
                if(mpcmpfixfix(v.u.xval, rv.u.xval) >= 0)
                        goto settrue;
                goto setfalse;
        case TUP(OGT, CTINT):
        case TUP(OGT, CTRUNE):
                if(mpcmpfixfix(v.u.xval, rv.u.xval) > 0)
                        goto settrue;
                goto setfalse;

        case TUP(OEQ, CTFLT):
                if(mpcmpfltflt(v.u.fval, rv.u.fval) == 0)
                        goto settrue;
                goto setfalse;
        case TUP(ONE, CTFLT):
                if(mpcmpfltflt(v.u.fval, rv.u.fval) != 0)
                        goto settrue;
                goto setfalse;
        case TUP(OLT, CTFLT):
                if(mpcmpfltflt(v.u.fval, rv.u.fval) < 0)
                        goto settrue;
                goto setfalse;
        case TUP(OLE, CTFLT):
                if(mpcmpfltflt(v.u.fval, rv.u.fval) <= 0)
                        goto settrue;
                goto setfalse;
        case TUP(OGE, CTFLT):
                if(mpcmpfltflt(v.u.fval, rv.u.fval) >= 0)
                        goto settrue;
                goto setfalse;
        case TUP(OGT, CTFLT):
                if(mpcmpfltflt(v.u.fval, rv.u.fval) > 0)
                        goto settrue;
                goto setfalse;

        case TUP(OEQ, CTCPLX):
                if(mpcmpfltflt(&v.u.cval->real, &rv.u.cval->real) == 0 &&
                   mpcmpfltflt(&v.u.cval->imag, &rv.u.cval->imag) == 0)
                        goto settrue;
                goto setfalse;
        case TUP(ONE, CTCPLX):
                if(mpcmpfltflt(&v.u.cval->real, &rv.u.cval->real) != 0 ||
                   mpcmpfltflt(&v.u.cval->imag, &rv.u.cval->imag) != 0)
                        goto settrue;
                goto setfalse;

        case TUP(OEQ, CTSTR):
                if(cmpslit(nl, nr) == 0)
                        goto settrue;
                goto setfalse;
        case TUP(ONE, CTSTR):
                if(cmpslit(nl, nr) != 0)
                        goto settrue;
                goto setfalse;
        case TUP(OLT, CTSTR):
                if(cmpslit(nl, nr) < 0)
                        goto settrue;
                goto setfalse;
        case TUP(OLE, CTSTR):
                if(cmpslit(nl, nr) <= 0)
                        goto settrue;
                goto setfalse;
        case TUP(OGE, CTSTR):
                if(cmpslit(nl, nr) >= 0l)
                        goto settrue;
                goto setfalse;
        case TUP(OGT, CTSTR):
                if(cmpslit(nl, nr) > 0)
                        goto settrue;
                goto setfalse;

        case TUP(OOROR, CTBOOL):
                if(v.u.bval || rv.u.bval)
                        goto settrue;
                goto setfalse;
        case TUP(OANDAND, CTBOOL):
                if(v.u.bval && rv.u.bval)
                        goto settrue;
                goto setfalse;
        case TUP(OEQ, CTBOOL):
                if(v.u.bval == rv.u.bval)
                        goto settrue;
                goto setfalse;
        case TUP(ONE, CTBOOL):
                if(v.u.bval != rv.u.bval)
                        goto settrue;
                goto setfalse;
        }
        goto ret;

unary:
        // copy numeric value to avoid modifying
        // nl, in case someone still refers to it (e.g. iota).
        v = nl->val;
        if(wl == TIDEAL)
                v = copyval(v);

        switch(TUP(n->op, v.ctype)) {
        default:
                if(!n->diag) {
                        yyerror("illegal constant expression %O %T", n->op, nl->type);
                        n->diag = 1;
                }
                return;

        case TUP(OCONV, CTNIL):
        case TUP(OARRAYBYTESTR, CTNIL):
                if(n->type->etype == TSTRING) {
                        v = tostr(v);
                        nl->type = n->type;
                        break;
                }
                // fall through
        case TUP(OCONV, CTINT):
        case TUP(OCONV, CTRUNE):
        case TUP(OCONV, CTFLT):
        case TUP(OCONV, CTSTR):
                convlit1(&nl, n->type, 1);
                v = nl->val;
                break;

        case TUP(OPLUS, CTINT):
        case TUP(OPLUS, CTRUNE):
                break;
        case TUP(OMINUS, CTINT):
        case TUP(OMINUS, CTRUNE):
                mpnegfix(v.u.xval);
                break;
        case TUP(OCOM, CTINT):
        case TUP(OCOM, CTRUNE):
                et = Txxx;
                if(nl->type != T)
                        et = nl->type->etype;

                // calculate the mask in b
                // result will be (a ^ mask)
                switch(et) {
                default:
                        // signed guys change sign
                        mpmovecfix(&b, -1);
                        break;

                case TUINT8:
                case TUINT16:
                case TUINT32:
                case TUINT64:
                case TUINT:
                case TUINTPTR:
                        // unsigned guys invert their bits
                        mpmovefixfix(&b, maxintval[et]);
                        break;
                }
                mpxorfixfix(v.u.xval, &b);
                break;

        case TUP(OPLUS, CTFLT):
                break;
        case TUP(OMINUS, CTFLT):
                mpnegflt(v.u.fval);
                break;

        case TUP(OPLUS, CTCPLX):
                break;
        case TUP(OMINUS, CTCPLX):
                mpnegflt(&v.u.cval->real);
                mpnegflt(&v.u.cval->imag);
                break;

        case TUP(ONOT, CTBOOL):
                if(!v.u.bval)
                        goto settrue;
                goto setfalse;
        }

ret:
        norig = saveorig(n);
        *n = *nl;
        // restore value of n->orig.
        n->orig = norig;
        n->val = v;

        // check range.
        lno = setlineno(n);
        overflow(v, n->type);
        lineno = lno;

        // truncate precision for non-ideal float.
        if(v.ctype == CTFLT && n->type->etype != TIDEAL)
                n->val.u.fval = truncfltlit(v.u.fval, n->type);
        return;

settrue:
        norig = saveorig(n);
        *n = *nodbool(1);
        n->orig = norig;
        return;

setfalse:
        norig = saveorig(n);
        *n = *nodbool(0);
        n->orig = norig;
        return;
}

Node*
nodlit(Val v)
{
        Node *n;

        n = nod(OLITERAL, N, N);
        n->val = v;
        switch(v.ctype) {
        default:
                fatal("nodlit ctype %d", v.ctype);
        case CTSTR:
                n->type = idealstring;
                break;
        case CTBOOL:
                n->type = idealbool;
                break;
        case CTINT:
        case CTRUNE:
        case CTFLT:
        case CTCPLX:
                n->type = types[TIDEAL];
                break;
        case CTNIL:
                n->type = types[TNIL];
                break;
        }
        return n;
}

Node*
nodcplxlit(Val r, Val i)
{
        Node *n;
        Mpcplx *c;

        r = toflt(r);
        i = toflt(i);

        c = mal(sizeof(*c));
        n = nod(OLITERAL, N, N);
        n->type = types[TIDEAL];
        n->val.u.cval = c;
        n->val.ctype = CTCPLX;

        if(r.ctype != CTFLT || i.ctype != CTFLT)
                fatal("nodcplxlit ctype %d/%d", r.ctype, i.ctype);

        mpmovefltflt(&c->real, r.u.fval);
        mpmovefltflt(&c->imag, i.u.fval);
        return n;
}

// idealkind returns a constant kind like consttype
// but for an arbitrary "ideal" (untyped constant) expression.
static int
idealkind(Node *n)
{
        int k1, k2;

        if(n == N || !isideal(n->type))
                return CTxxx;

        switch(n->op) {
        default:
                return CTxxx;
        case OLITERAL:
                return n->val.ctype;
        case OADD:
        case OAND:
        case OANDNOT:
        case OCOM:
        case ODIV:
        case OMINUS:
        case OMOD:
        case OMUL:
        case OSUB:
        case OXOR:
        case OOR:
        case OPLUS:
                // numeric kinds.
                k1 = idealkind(n->left);
                k2 = idealkind(n->right);
                if(k1 > k2)
                        return k1;
                else
                        return k2;
        case OREAL:
        case OIMAG:
                return CTFLT;
        case OCOMPLEX:
                return CTCPLX;
        case OADDSTR:
                return CTSTR;
        case OANDAND:
        case OEQ:
        case OGE:
        case OGT:
        case OLE:
        case OLT:
        case ONE:
        case ONOT:
        case OOROR:
        case OCMPSTR:
        case OCMPIFACE:
                return CTBOOL;
        case OLSH:
        case ORSH:
                // shifts (beware!).
                return idealkind(n->left);
        }
}

void
defaultlit(Node **np, Type *t)
{
        int lno;
        int ctype;
        Node *n, *nn;
        Type *t1;

        n = *np;
        if(n == N || !isideal(n->type))
                return;

        if(n->op == OLITERAL) {
                nn = nod(OXXX, N, N);
                *nn = *n;
                n = nn;
                *np = n;
        }

        lno = setlineno(n);
        ctype = idealkind(n);
        switch(ctype) {
        default:
                if(t != T) {
                        convlit(np, t);
                        return;
                }
                if(n->val.ctype == CTNIL) {
                        lineno = lno;
                        if(!n->diag) {
                                yyerror("use of untyped nil");
                                n->diag = 1;
                        }
                        n->type = T;
                        break;
                }
                if(n->val.ctype == CTSTR) {
                        t1 = types[TSTRING];
                        convlit(np, t1);
                        break;
                }
                yyerror("defaultlit: unknown literal: %N", n);
                break;
        case CTxxx:
                fatal("defaultlit: idealkind is CTxxx: %+N", n);
                break;
        case CTBOOL:
                t1 = types[TBOOL];
                if(t != T && t->etype == TBOOL)
                        t1 = t;
                convlit(np, t1);
                break;
        case CTINT:
                t1 = types[TINT];
                goto num;
        case CTRUNE:
                t1 = runetype;
                goto num;
        case CTFLT:
                t1 = types[TFLOAT64];
                goto num;
        case CTCPLX:
                t1 = types[TCOMPLEX128];
                goto num;
        num:
                if(t != T) {
                        if(isint[t->etype]) {
                                t1 = t;
                                n->val = toint(n->val);
                        }
                        else
                        if(isfloat[t->etype]) {
                                t1 = t;
                                n->val = toflt(n->val);
                        }
                        else
                        if(iscomplex[t->etype]) {
                                t1 = t;
                                n->val = tocplx(n->val);
                        }
                }
                overflow(n->val, t1);
                convlit(np, t1);
                break;
        }
        lineno = lno;
}

/*
 * defaultlit on both nodes simultaneously;
 * if they're both ideal going in they better
 * get the same type going out.
 * force means must assign concrete (non-ideal) type.
 */
void
defaultlit2(Node **lp, Node **rp, int force)
{
        Node *l, *r;
        int lkind, rkind;

        l = *lp;
        r = *rp;
        if(l->type == T || r->type == T)
                return;
        if(!isideal(l->type)) {
                convlit(rp, l->type);
                return;
        }
        if(!isideal(r->type)) {
                convlit(lp, r->type);
                return;
        }
        if(!force)
                return;
        if(l->type->etype == TBOOL) {
                convlit(lp, types[TBOOL]);
                convlit(rp, types[TBOOL]);
        }
        lkind = idealkind(l);
        rkind = idealkind(r);
        if(lkind == CTCPLX || rkind == CTCPLX) {
                convlit(lp, types[TCOMPLEX128]);
                convlit(rp, types[TCOMPLEX128]);
                return;
        }
        if(lkind == CTFLT || rkind == CTFLT) {
                convlit(lp, types[TFLOAT64]);
                convlit(rp, types[TFLOAT64]);
                return;
        }

        if(lkind == CTRUNE || rkind == CTRUNE) {
                convlit(lp, runetype);
                convlit(rp, runetype);
                return;
        }

        convlit(lp, types[TINT]);
        convlit(rp, types[TINT]);
}

int
cmpslit(Node *l, Node *r)
{
        int32 l1, l2, i, m;
        uchar *s1, *s2;

        l1 = l->val.u.sval->len;
        l2 = r->val.u.sval->len;
        s1 = (uchar*)l->val.u.sval->s;
        s2 = (uchar*)r->val.u.sval->s;

        m = l1;
        if(l2 < m)
                m = l2;

        for(i=0; i<m; i++) {
                if(s1[i] == s2[i])
                        continue;
                if(s1[i] > s2[i])
                        return +1;
                return -1;
        }
        if(l1 == l2)
                return 0;
        if(l1 > l2)
                return +1;
        return -1;
}

int
smallintconst(Node *n)
{
        if(n->op == OLITERAL && isconst(n, CTINT) && n->type != T)
        switch(simtype[n->type->etype]) {
        case TINT8:
        case TUINT8:
        case TINT16:
        case TUINT16:
        case TINT32:
        case TUINT32:
        case TBOOL:
        case TPTR32:
                return 1;
        case TIDEAL:
        case TINT64:
        case TUINT64:
        case TPTR64:
                if(mpcmpfixfix(n->val.u.xval, minintval[TINT32]) < 0
                || mpcmpfixfix(n->val.u.xval, maxintval[TINT32]) > 0)
                        break;
                return 1;
        }
        return 0;
}

long
nonnegconst(Node *n)
{
        if(n->op == OLITERAL && n->type != T)
        switch(simtype[n->type->etype]) {
        case TINT8:
        case TUINT8:
        case TINT16:
        case TUINT16:
        case TINT32:
        case TUINT32:
        case TINT64:
        case TUINT64:
        case TIDEAL:
                // check negative and 2^31
                if(mpcmpfixfix(n->val.u.xval, minintval[TUINT32]) < 0
                || mpcmpfixfix(n->val.u.xval, maxintval[TINT32]) > 0)
                        break;
                return mpgetfix(n->val.u.xval);
        }
        return -1;
}

/*
 * convert x to type et and back to int64
 * for sign extension and truncation.
 */
static int64
iconv(int64 x, int et)
{
        switch(et) {
        case TINT8:
                x = (int8)x;
                break;
        case TUINT8:
                x = (uint8)x;
                break;
        case TINT16:
                x = (int16)x;
                break;
        case TUINT16:
                x = (uint64)x;
                break;
        case TINT32:
                x = (int32)x;
                break;
        case TUINT32:
                x = (uint32)x;
                break;
        case TINT64:
        case TUINT64:
                break;
        }
        return x;
}

/*
 * convert constant val to type t; leave in con.
 * for back end.
 */
void
convconst(Node *con, Type *t, Val *val)
{
        int64 i;
        int tt;

        tt = simsimtype(t);

        // copy the constant for conversion
        nodconst(con, types[TINT8], 0);
        con->type = t;
        con->val = *val;

        if(isint[tt]) {
                con->val.ctype = CTINT;
                con->val.u.xval = mal(sizeof *con->val.u.xval);
                switch(val->ctype) {
                default:
                        fatal("convconst ctype=%d %lT", val->ctype, t);
                case CTINT:
                case CTRUNE:
                        i = mpgetfix(val->u.xval);
                        break;
                case CTBOOL:
                        i = val->u.bval;
                        break;
                case CTNIL:
                        i = 0;
                        break;
                }
                i = iconv(i, tt);
                mpmovecfix(con->val.u.xval, i);
                return;
        }

        if(isfloat[tt]) {
                con->val = toflt(con->val);
                if(con->val.ctype != CTFLT)
                        fatal("convconst ctype=%d %T", con->val.ctype, t);
                if(tt == TFLOAT32)
                        con->val.u.fval = truncfltlit(con->val.u.fval, t);
                return;
        }

        if(iscomplex[tt]) {
                con->val = tocplx(con->val);
                if(tt == TCOMPLEX64) {
                        con->val.u.cval->real = *truncfltlit(&con->val.u.cval->real, types[TFLOAT32]);
                        con->val.u.cval->imag = *truncfltlit(&con->val.u.cval->imag, types[TFLOAT32]);
                }
                return;
        }

        fatal("convconst %lT constant", t);

}

// complex multiply v *= rv
//      (a, b) * (c, d) = (a*c - b*d, b*c + a*d)
static void
cmplxmpy(Mpcplx *v, Mpcplx *rv)
{
        Mpflt ac, bd, bc, ad;

        mpmovefltflt(&ac, &v->real);
        mpmulfltflt(&ac, &rv->real);    // ac

        mpmovefltflt(&bd, &v->imag);
        mpmulfltflt(&bd, &rv->imag);    // bd

        mpmovefltflt(&bc, &v->imag);
        mpmulfltflt(&bc, &rv->real);    // bc

        mpmovefltflt(&ad, &v->real);
        mpmulfltflt(&ad, &rv->imag);    // ad

        mpmovefltflt(&v->real, &ac);
        mpsubfltflt(&v->real, &bd);     // ac-bd

        mpmovefltflt(&v->imag, &bc);
        mpaddfltflt(&v->imag, &ad);     // bc+ad
}

// complex divide v /= rv
//      (a, b) / (c, d) = ((a*c + b*d), (b*c - a*d))/(c*c + d*d)
static void
cmplxdiv(Mpcplx *v, Mpcplx *rv)
{
        Mpflt ac, bd, bc, ad, cc_plus_dd;

        mpmovefltflt(&cc_plus_dd, &rv->real);
        mpmulfltflt(&cc_plus_dd, &rv->real);    // cc

        mpmovefltflt(&ac, &rv->imag);
        mpmulfltflt(&ac, &rv->imag);            // dd

        mpaddfltflt(&cc_plus_dd, &ac);          // cc+dd

        mpmovefltflt(&ac, &v->real);
        mpmulfltflt(&ac, &rv->real);            // ac

        mpmovefltflt(&bd, &v->imag);
        mpmulfltflt(&bd, &rv->imag);            // bd

        mpmovefltflt(&bc, &v->imag);
        mpmulfltflt(&bc, &rv->real);            // bc

        mpmovefltflt(&ad, &v->real);
        mpmulfltflt(&ad, &rv->imag);            // ad

        mpmovefltflt(&v->real, &ac);
        mpaddfltflt(&v->real, &bd);             // ac+bd
        mpdivfltflt(&v->real, &cc_plus_dd);     // (ac+bd)/(cc+dd)

        mpmovefltflt(&v->imag, &bc);
        mpsubfltflt(&v->imag, &ad);             // bc-ad
        mpdivfltflt(&v->imag, &cc_plus_dd);     // (bc+ad)/(cc+dd)
}

static int hascallchan(Node*);

// Is n a Go language constant (as opposed to a compile-time constant)?
// Expressions derived from nil, like string([]byte(nil)), while they
// may be known at compile time, are not Go language constants.
// Only called for expressions known to evaluated to compile-time
// constants.
int
isgoconst(Node *n)
{
        Node *l;
        Type *t;

        if(n->orig != N)
                n = n->orig;

        switch(n->op) {
        case OADD:
        case OADDSTR:
        case OAND:
        case OANDAND:
        case OANDNOT:
        case OCOM:
        case ODIV:
        case OEQ:
        case OGE:
        case OGT:
        case OLE:
        case OLSH:
        case OLT:
        case OMINUS:
        case OMOD:
        case OMUL:
        case ONE:
        case ONOT:
        case OOR:
        case OOROR:
        case OPLUS:
        case ORSH:
        case OSUB:
        case OXOR:
        case OCONV:
        case OIOTA:
        case OCOMPLEX:
        case OREAL:
        case OIMAG:
                if(isgoconst(n->left) && (n->right == N || isgoconst(n->right)))
                        return 1;
                break;
        
        case OLEN:
        case OCAP:
                l = n->left;
                if(isgoconst(l))
                        return 1;
                // Special case: len/cap is constant when applied to array or
                // pointer to array when the expression does not contain
                // function calls or channel receive operations.
                t = l->type;
                if(t != T && isptr[t->etype])
                        t = t->type;
                if(isfixedarray(t) && !hascallchan(l))
                        return 1;
                break;

        case OLITERAL:
                if(n->val.ctype != CTNIL)
                        return 1;
                break;

        case ONAME:
                l = n->sym->def;
                if(l && l->op == OLITERAL && n->val.ctype != CTNIL)
                        return 1;
                break;
        
        case ONONAME:
                if(n->sym->def != N && n->sym->def->op == OIOTA)
                        return 1;
                break;
        
        case OCALL:
                // Only constant calls are unsafe.Alignof, Offsetof, and Sizeof.
                l = n->left;
                while(l->op == OPAREN)
                        l = l->left;
                if(l->op != ONAME || l->sym->pkg != unsafepkg)
                        break;
                if(strcmp(l->sym->name, "Alignof") == 0 ||
                   strcmp(l->sym->name, "Offsetof") == 0 ||
                   strcmp(l->sym->name, "Sizeof") == 0)
                        return 1;
                break;          
        }

        //dump("nonconst", n);
        return 0;
}

static int
hascallchan(Node *n)
{
        NodeList *l;

        if(n == N)
                return 0;
        switch(n->op) {
        case OAPPEND:
        case OCALL:
        case OCALLFUNC:
        case OCALLINTER:
        case OCALLMETH:
        case OCAP:
        case OCLOSE:
        case OCOMPLEX:
        case OCOPY:
        case ODELETE:
        case OIMAG:
        case OLEN:
        case OMAKE:
        case ONEW:
        case OPANIC:
        case OPRINT:
        case OPRINTN:
        case OREAL:
        case ORECOVER:
        case ORECV:
                return 1;
        }
        
        if(hascallchan(n->left) ||
           hascallchan(n->right))
                return 1;
        
        for(l=n->list; l; l=l->next)
                if(hascallchan(l->n))
                        return 1;
        for(l=n->rlist; l; l=l->next)
                if(hascallchan(l->n))
                        return 1;

        return 0;
}
/* [<][>][^][v][top][bottom][index][help] */
root/src/cmd/gc/const.c

DEFINITIONS
