* add p cc

[mascara-docs.git] / compilers / pcc / pcc-1.0.0 / cc / ccom / builtins.c

/*      $Id: builtins.c,v 1.18.2.2 2011/03/29 15:56:24 ragge Exp $      */
/*
 * Copyright (c) 2003 Anders Magnusson (ragge@ludd.luth.se).
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

# include "pass1.h"

#ifndef MIN
#define MIN(a,b) (((a)<(b))?(a):(b))
#endif
#ifndef MAX
#define MAX(a,b) (((a)>(b))?(a):(b))
#endif

#ifndef NO_C_BUILTINS
/*
 * replace an alloca function with direct allocation on stack.
 * return a destination temp node.
 */
static NODE *
builtin_alloca(NODE *f, NODE *a, TWORD rt)
{
        struct symtab *sp;
        NODE *t, *u;

#ifdef notyet
        if (xnobuiltins)
                return NULL;
#endif
        sp = f->n_sp;

        t = tempnode(0, VOID|PTR, 0, MKAP(INT) /* XXX */);
        u = tempnode(regno(t), VOID|PTR, 0, MKAP(INT) /* XXX */);
        spalloc(t, a, SZCHAR);
        tfree(f);
        return u;
}

/*
 * See if there is a goto in the tree.
 * XXX this function is a hack for a flaw in handling of 
 * compound expressions and inline functions and should not be 
 * needed.
 */
static int
hasgoto(NODE *p)
{
        int o = coptype(p->n_op);

        if (o == LTYPE)
                return 0;
        if (p->n_op == GOTO)
                return 1;
        if (o == UTYPE)
                return hasgoto(p->n_left);
        if (hasgoto(p->n_left))
                return 1;
        return hasgoto(p->n_right);
}

/*
 * Determine if a value is known to be constant at compile-time and
 * hence that PCC can perform constant-folding on expressions involving
 * that value.
 */
static NODE *
builtin_constant_p(NODE *f, NODE *a, TWORD rt)
{
        void putjops(NODE *p, void *arg);
        int isconst;

        tfree(f);
        walkf(a, putjops, 0);
        for (f = a; f->n_op == COMOP; f = f->n_right)
                ;
        isconst = nncon(f);
        tfree(a);
        return bcon(isconst);
}

/*
 * Hint to the compiler whether this expression will evaluate true or false.
 * Just ignored for now.
 */
static NODE *
builtin_expect(NODE *f, NODE *a, TWORD rt)
{

        tfree(f);
        if (a && a->n_op == CM) {
                tfree(a->n_right);
                f = a->n_left;
                nfree(a);
                a = f;
        }

        return a;
}

/*
 * Take integer absolute value.
 * Simply does: ((((x)>>(8*sizeof(x)-1))^(x))-((x)>>(8*sizeof(x)-1)))
 */
static NODE *
builtin_abs(NODE *f, NODE *a, TWORD rt)
{
        NODE *p, *q, *r, *t, *t2, *t3;
        int tmp1, tmp2, shift;

        if (a->n_type != INT)
                a = cast(a, INT, 0);

        tfree(f);

        if (a->n_op == ICON) {
                if (a->n_lval < 0)
                        a->n_lval = -a->n_lval;
                p = a;
        } else {
                t = tempnode(0, a->n_type, a->n_df, a->n_ap);
                tmp1 = regno(t);
                p = buildtree(ASSIGN, t, a);

                t = tempnode(tmp1, a->n_type, a->n_df, a->n_ap);
                shift = (int)tsize(a->n_type, a->n_df, a->n_ap) - 1;
                q = buildtree(RS, t, bcon(shift));

                t2 = tempnode(0, a->n_type, a->n_df, a->n_ap);
                tmp2 = regno(t2);
                q = buildtree(ASSIGN, t2, q);

                t = tempnode(tmp1, a->n_type, a->n_df, a->n_ap);
                t2 = tempnode(tmp2, a->n_type, a->n_df, a->n_ap);
                t3 = tempnode(tmp2, a->n_type, a->n_df, a->n_ap);
                r = buildtree(MINUS, buildtree(ER, t, t2), t3);

                p = buildtree(COMOP, p, buildtree(COMOP, q, r));
        }

        return p;
}

/*
 * Get size of object, if possible.
 * Currently does nothing,
 */
static NODE *
builtin_object_size(NODE *f, NODE *a, TWORD rt)
{
        int v = icons(a->n_right);
        if (v < 0 || v > 3)
                uerror("arg2 must be between 0 and 3");

        tfree(f);
        f = buildtree(COMOP, a->n_left, xbcon(v < 2 ? -1 : 0, NULL, rt));
        nfree(a);
        return f;
}

#ifndef TARGET_STDARGS
static NODE *
builtin_stdarg_start(NODE *f, NODE *a, TWORD rt)
{
        NODE *p, *q;
        int sz;

        /* must first deal with argument size; use int size */
        p = a->n_right;
        if (p->n_type < INT) {
                sz = (int)(SZINT/tsize(p->n_type, p->n_df, p->n_ap));
        } else
                sz = 1;

        /* do the real job */
        p = buildtree(ADDROF, p, NIL); /* address of last arg */
#ifdef BACKAUTO
        p = optim(buildtree(PLUS, p, bcon(sz))); /* add one to it (next arg) */
#else
        p = optim(buildtree(MINUS, p, bcon(sz))); /* add one to it (next arg) */
#endif
        q = block(NAME, NIL, NIL, PTR+VOID, 0, 0); /* create cast node */
        q = buildtree(CAST, q, p); /* cast to void * (for assignment) */
        p = q->n_right;
        nfree(q->n_left);
        nfree(q);
        p = buildtree(ASSIGN, a->n_left, p); /* assign to ap */
        tfree(f);
        nfree(a);
        return p;
}

static NODE *
builtin_va_arg(NODE *f, NODE *a, TWORD rt)
{
        NODE *p, *q, *r, *rv;
        int sz, nodnum;

        /* create a copy to a temp node of current ap */
        p = ccopy(a->n_left);
        q = tempnode(0, p->n_type, p->n_df, p->n_ap);
        nodnum = regno(q);
        rv = buildtree(ASSIGN, q, p);

        r = a->n_right;
        sz = (int)tsize(r->n_type, r->n_df, r->n_ap)/SZCHAR;
        /* add one to ap */
#ifdef BACKAUTO
        rv = buildtree(COMOP, rv , buildtree(PLUSEQ, a->n_left, bcon(sz)));
#else
#error fix wrong eval order in builtin_va_arg
        ecomp(buildtree(MINUSEQ, a->n_left, bcon(sz)));
#endif

        nfree(a->n_right);
        nfree(a);
        nfree(f);
        r = tempnode(nodnum, INCREF(r->n_type), r->n_df, r->n_ap);
        return buildtree(COMOP, rv, buildtree(UMUL, r, NIL));

}

static NODE *
builtin_va_end(NODE *f, NODE *a, TWORD rt)
{
        tfree(f);
        tfree(a);
        return bcon(0); /* nothing */
}

static NODE *
builtin_va_copy(NODE *f, NODE *a, TWORD rt)
{
        tfree(f);
        f = buildtree(ASSIGN, a->n_left, a->n_right);
        nfree(a);
        return f;
}
#endif /* TARGET_STDARGS */

/*
 * For unimplemented "builtin" functions, try to invoke the
 * non-builtin name
 */
static NODE *
binhelp(NODE *f, NODE *a, TWORD rt, char *n)
{
        f->n_sp = lookup(addname(n), SNORMAL);
        if (f->n_sp->sclass == SNULL) {
                f->n_sp->sclass = EXTERN;
                f->n_sp->stype = INCREF(rt)+(FTN-PTR);
        }
        f->n_type = f->n_sp->stype;
        f = clocal(f);
        return buildtree(CALL, f, a);
}

static NODE *
builtin_unimp(NODE *f, NODE *a, TWORD rt)
{
        char *n = f->n_sp->sname;

        if (strncmp("__builtin_", n, 10) == 0)
                n += 10;
        return binhelp(f, a, rt, n);
}

static NODE *
builtin_unimp_f(NODE *f, NODE *a, TWORD rt)
{
        return binhelp(f, a, rt, f->n_sp->sname);
}

#ifndef TARGET_ISMATH
/*
 * Handle the builtin macros for the math functions is*
 * To get something that is be somewhat generic assume that 
 * isnan() is a real function and that cast of a NaN type 
 * to double will still be a NaN.
 */
static NODE *
mtisnan(NODE *p)
{
        NODE *q = block(NAME, NIL, NIL, INT, 0, MKAP(INT));

        return binhelp(q, cast(ccopy(p), DOUBLE, 0), INT, "isnan");
}

static TWORD
mtcheck(NODE *p)
{
        TWORD t1 = p->n_left->n_type, t2 = p->n_right->n_type;

        if ((t1 >= FLOAT && t1 <= LDOUBLE) ||
            (t2 >= FLOAT && t2 <= LDOUBLE))
                return MAX(t1, t2);
        return 0;
}

static NODE *
builtin_isunordered(NODE *f, NODE *a, TWORD rt)
{
        NODE *p;

        if (mtcheck(a) == 0)
                return bcon(0);

        p = buildtree(OROR, mtisnan(a->n_left), mtisnan(a->n_right));
        tfree(f);
        tfree(a);
        return p;
}
static NODE *
builtin_isany(NODE *f, NODE *a, TWORD rt, int cmpt)
{
        NODE *p, *q;
        TWORD t;

        if ((t = mtcheck(a)) == 0)
                return bcon(0);
        p = buildtree(OROR, mtisnan(a->n_left), mtisnan(a->n_right));
        p = buildtree(NOT, p, NIL);
        q = buildtree(cmpt, cast(ccopy(a->n_left), t, 0),
            cast(ccopy(a->n_right), t, 0));
        p = buildtree(ANDAND, p, q);
        tfree(f);
        tfree(a);
        return p;
}
static NODE *
builtin_isgreater(NODE *f, NODE *a, TWORD rt)
{
        return builtin_isany(f, a, rt, GT);
}
static NODE *
builtin_isgreaterequal(NODE *f, NODE *a, TWORD rt)
{
        return builtin_isany(f, a, rt, GE);
}
static NODE *
builtin_isless(NODE *f, NODE *a, TWORD rt)
{
        return builtin_isany(f, a, rt, LT);
}
static NODE *
builtin_islessequal(NODE *f, NODE *a, TWORD rt)
{
        return builtin_isany(f, a, rt, LE);
}
static NODE *
builtin_islessgreater(NODE *f, NODE *a, TWORD rt)
{
        NODE *p, *q, *r;
        TWORD t;

        if ((t = mtcheck(a)) == 0)
                return bcon(0);
        p = buildtree(OROR, mtisnan(a->n_left), mtisnan(a->n_right));
        p = buildtree(NOT, p, NIL);
        q = buildtree(GT, cast(ccopy(a->n_left), t, 0),
            cast(ccopy(a->n_right), t, 0));
        r = buildtree(LT, cast(ccopy(a->n_left), t, 0),
            cast(ccopy(a->n_right), t, 0));
        q = buildtree(OROR, q, r);
        p = buildtree(ANDAND, p, q);
        tfree(f);
        tfree(a);
        return p;
}
#endif

/*
 * Math-specific builtins that expands to constants.
 * Versins here is for IEEE FP, vax needs its own versions.
 */
#ifdef RTOLBYTES
static char vFLOAT[] = { 0, 0, 0x80, 0x7f };
static char vDOUBLE[] = { 0, 0, 0, 0, 0, 0, 0xf0, 0x7f };
#ifdef LDBL_128
static char vLDOUBLE[] = { 0,0,0,0,0,0,0, 0, 0, 0, 0, 0, 0, 0x80, 0xff, 0x7f };
#else /* LDBL_80 */
static char vLDOUBLE[] = { 0, 0, 0, 0, 0, 0, 0, 0x80, 0xff, 0x7f };
#endif
static char nFLOAT[] = { 0, 0, 0xc0, 0x7f };
static char nDOUBLE[] = { 0, 0, 0, 0, 0, 0, 0xf8, 0x7f };
#ifdef LDBL_128
static char nLDOUBLE[] = { 0,0,0,0,0,0,0,0, 0, 0, 0, 0, 0, 0xc0, 0xff, 0x7f };
#else /* LDBL_80 */
static char nLDOUBLE[] = { 0, 0, 0, 0, 0, 0, 0, 0xc0, 0xff, 0x7f, 0, 0 };
#endif
#else
static char vFLOAT[] = { 0x7f, 0x80, 0, 0 };
static char vDOUBLE[] = { 0x7f, 0xf0, 0, 0, 0, 0, 0, 0 };
#ifdef LDBL_128
static char vLDOUBLE[] = { 0x7f, 0xff, 0x80, 0, 0, 0, 0, 0, 0, 0,0,0,0,0,0,0 };
#else /* LDBL_80 */
static char vLDOUBLE[] = { 0x7f, 0xff, 0x80, 0, 0, 0, 0, 0, 0, 0 };
#endif
static char nFLOAT[] = { 0x7f, 0xc0, 0, 0 };
static char nDOUBLE[] = { 0x7f, 0xf8, 0, 0, 0, 0, 0, 0 };
#ifdef LDBL_128
static char nLDOUBLE[] = { 0x7f, 0xff, 0xc0, 0, 0, 0, 0, 0, 0, 0,0,0,0,0,0,0 };
#else /* LDBL_80 */
static char nLDOUBLE[] = { 0x7f, 0xff, 0xc0, 0, 0, 0, 0, 0, 0, 0 };
#endif
#endif

#define VALX(typ,TYP) {                                         \
        typ d;                                                  \
        int x;                                                  \
        x = MIN(sizeof(n ## TYP), sizeof(d));                   \
        memcpy(&d, v ## TYP, x);                                \
        nfree(f);                                               \
        f = block(FCON, NIL, NIL, TYP, NULL, MKAP(TYP));        \
        f->n_dcon = d;                                          \
        return f;                                               \
}

static NODE *
builtin_huge_valf(NODE *f, NODE *a, TWORD rt) VALX(float,FLOAT)
static NODE *
builtin_huge_val(NODE *f, NODE *a, TWORD rt) VALX(double,DOUBLE)
static NODE *
builtin_huge_vall(NODE *f, NODE *a, TWORD rt) VALX(long double,LDOUBLE)

#define builtin_inff    builtin_huge_valf
#define builtin_inf     builtin_huge_val
#define builtin_infl    builtin_huge_vall

#define NANX(typ,TYP) {                                                 \
        typ d;                                                          \
        int x;                                                          \
        if ((a->n_op == ICON && a->n_sp && a->n_sp->sname[0] == '\0') ||\
            (a->n_op == ADDROF && a->n_left->n_op == NAME &&            \
             a->n_left->n_sp && a->n_left->n_sp->sname[0] == '\0')) {   \
                x = MIN(sizeof(n ## TYP), sizeof(d));                   \
                memcpy(&d, n ## TYP, x);                                \
                tfree(a); tfree(f);                                     \
                f = block(FCON, NIL, NIL, TYP, NULL, MKAP(TYP));        \
                f->n_dcon = d;                                          \
                return f;                                               \
        }                                                               \
        return buildtree(CALL, f, a);                                   \
}

/*
 * Return NANs, if reasonable.
 */
static NODE *
builtin_nanf(NODE *f, NODE *a, TWORD rt) NANX(float,FLOAT)
static NODE *
builtin_nan(NODE *f, NODE *a, TWORD rt) NANX(double,DOUBLE)
static NODE *
builtin_nanl(NODE *f, NODE *a, TWORD rt) NANX(long double,LDOUBLE)

/*
 * Target defines, to implement target versions of the generic builtins
 */
#ifndef TARGET_MEMCMP
#define builtin_memcmp builtin_unimp
#endif
#ifndef TARGET_MEMCPY
#define builtin_memcpy builtin_unimp
#endif
#ifndef TARGET_MEMSET
#define builtin_memset builtin_unimp
#endif

/* Reasonable type of size_t */
#ifndef SIZET
#if SZINT == SZSHORT
#define SIZET UNSIGNED
#elif SZLONG > SZINT
#define SIZET ULONG
#else
#define SIZET UNSIGNED
#endif
#endif

static TWORD memcpyt[] = { VOID|PTR, VOID|PTR, SIZET, INT };
static TWORD memsett[] = { VOID|PTR, INT, SIZET, INT };
static TWORD allocat[] = { SIZET };
static TWORD expectt[] = { LONG, LONG };
static TWORD strcmpt[] = { CHAR|PTR, CHAR|PTR };
static TWORD strcpyt[] = { CHAR|PTR, CHAR|PTR, INT };
static TWORD strncpyt[] = { CHAR|PTR, CHAR|PTR, SIZET, INT };
static TWORD strchrt[] = { CHAR|PTR, INT };
static TWORD strcspnt[] = { CHAR|PTR, CHAR|PTR };
static TWORD nant[] = { CHAR|PTR };
static TWORD bitt[] = { UNSIGNED };
static TWORD bitlt[] = { ULONG };
static TWORD ffst[] = { INT };

static const struct bitable {
        char *name;
        NODE *(*fun)(NODE *f, NODE *a, TWORD);
        int narg;
        TWORD *tp;
        TWORD rt;
} bitable[] = {
        { "__builtin___memcpy_chk", builtin_unimp, 4, memcpyt, VOID|PTR },
        { "__builtin___memmove_chk", builtin_unimp, 4, memcpyt, VOID|PTR },
        { "__builtin___memset_chk", builtin_unimp, 4, memsett, VOID|PTR },

        { "__builtin___strcat_chk", builtin_unimp, 3, strcpyt, CHAR|PTR },
        { "__builtin___strcpy_chk", builtin_unimp, 3, strcpyt, CHAR|PTR },
        { "__builtin___strncat_chk", builtin_unimp, 4, strncpyt,CHAR|PTR },
        { "__builtin___strncpy_chk", builtin_unimp, 4, strncpyt,CHAR|PTR },

        { "__builtin___printf_chk", builtin_unimp, -1, 0, INT },
        { "__builtin___fprintf_chk", builtin_unimp, -1, 0, INT },
        { "__builtin___sprintf_chk", builtin_unimp, -1, 0, INT },
        { "__builtin___snprintf_chk", builtin_unimp, -1, 0, INT },
        { "__builtin___vprintf_chk", builtin_unimp, -1, 0, INT },
        { "__builtin___vfprintf_chk", builtin_unimp, -1, 0, INT },
        { "__builtin___vsprintf_chk", builtin_unimp, -1, 0, INT },
        { "__builtin___vsnprintf_chk", builtin_unimp, -1, 0, INT },

        { "__builtin_alloca", builtin_alloca, 1, allocat },
        { "__builtin_abs", builtin_abs, 1 },
        { "__builtin_clz", builtin_unimp_f, 1, bitt, INT },
        { "__builtin_ctz", builtin_unimp_f, 1, bitt, INT },
        { "__builtin_clzl", builtin_unimp_f, 1, bitlt, INT },
        { "__builtin_ctzl", builtin_unimp_f, 1, bitlt, INT },
        { "__builtin_ffs", builtin_unimp, 1, ffst, INT },

        { "__builtin_constant_p", builtin_constant_p, 1 },
        { "__builtin_expect", builtin_expect, 2, expectt },
        { "__builtin_memcmp", builtin_memcmp, 3, memcpyt, INT },
        { "__builtin_memcpy", builtin_memcpy, 3, memcpyt, VOID|PTR },
        { "__builtin_memset", builtin_memset, 3, memsett, VOID|PTR },
        { "__builtin_huge_valf", builtin_huge_valf, 0 },
        { "__builtin_huge_val", builtin_huge_val, 0 },
        { "__builtin_huge_vall", builtin_huge_vall, 0 },
        { "__builtin_inff", builtin_inff, 0 },
        { "__builtin_inf", builtin_inf, 0 },
        { "__builtin_infl", builtin_infl, 0 },
        { "__builtin_isgreater", builtin_isgreater, 2, NULL, INT },
        { "__builtin_isgreaterequal", builtin_isgreaterequal, 2, NULL, INT },
        { "__builtin_isless", builtin_isless, 2, NULL, INT },
        { "__builtin_islessequal", builtin_islessequal, 2, NULL, INT },
        { "__builtin_islessgreater", builtin_islessgreater, 2, NULL, INT },
        { "__builtin_isunordered", builtin_isunordered, 2, NULL, INT },
        { "__builtin_nanf", builtin_nanf, 1, nant, FLOAT },
        { "__builtin_nan", builtin_nan, 1, nant, DOUBLE },
        { "__builtin_nanl", builtin_nanl, 1, nant, LDOUBLE },
        { "__builtin_object_size", builtin_object_size, 2, memsett, SIZET },
        { "__builtin_strcmp", builtin_unimp, 2, strcmpt, INT },
        { "__builtin_strcpy", builtin_unimp, 2, strcmpt, CHAR|PTR },
        { "__builtin_strchr", builtin_unimp, 2, strchrt, CHAR|PTR },
        { "__builtin_strlen", builtin_unimp, 1, strcmpt, SIZET },
        { "__builtin_strrchr", builtin_unimp, 2, strchrt, CHAR|PTR },
        { "__builtin_strncpy", builtin_unimp, 3, strncpyt, CHAR|PTR },
        { "__builtin_strncat", builtin_unimp, 3, strncpyt, CHAR|PTR },
        { "__builtin_strcspn", builtin_unimp, 2, strcspnt, SIZET },
#ifndef TARGET_STDARGS
        { "__builtin_stdarg_start", builtin_stdarg_start, 2 },
        { "__builtin_va_start", builtin_stdarg_start, 2 },
        { "__builtin_va_arg", builtin_va_arg, 2 },
        { "__builtin_va_end", builtin_va_end, 1 },
        { "__builtin_va_copy", builtin_va_copy, 2 },
#endif
#ifdef TARGET_BUILTINS
        TARGET_BUILTINS
#endif
};

/*
 * Check and cast arguments for builtins.
 */
static int
acnt(NODE *a, int narg, TWORD *tp)
{
        NODE *q;
        TWORD t;

        if (a == NIL)
                return narg;
        for (; a->n_op == CM; a = a->n_left, narg--) {
                if (tp == NULL)
                        continue;
                q = a->n_right;
                t = tp[narg-1];
                if (q->n_type == t)
                        continue;
                a->n_right = ccast(q, t, 0, NULL, MKAP(BTYPE(t)));
        }

        /* Last arg is ugly to deal with */
        if (narg == 1 && tp != NULL) {
                q = talloc();
                *q = *a;
                q = ccast(q, tp[0], 0, NULL, MKAP(BTYPE(tp[0])));
                *a = *q;
                nfree(q);
        }
        return narg != 1;
}

NODE *
builtin_check(NODE *f, NODE *a)
{
        const struct bitable *bt;
        int i;

        for (i = 0; i < (int)(sizeof(bitable)/sizeof(bitable[0])); i++) {
                bt = &bitable[i];
                if (strcmp(bt->name, f->n_sp->sname))
                        continue;
                if (bt->narg >= 0 && acnt(a, bt->narg, bt->tp)) {
                        uerror("wrong argument count to %s", bt->name);
                        return bcon(0);
                }
                return (*bt->fun)(f, a, bt->rt);
        }
        return NIL;
}
#endif