legion/src/support/sparcccgen.c

/*
* ========== Copyright Header Begin ==========================================
*
* OpenSPARC T2 Processor File: sparcccgen.c
* Copyright (c) 2006 Sun Microsystems, Inc.  All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES.
*
* The above named program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public
* License version 2 as published by the Free Software Foundation.
*
* The above named program is distributed in the hope that it will be
* useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public
* License along with this work; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
*
* ========== Copyright Header End ============================================
*/
        /*
         * Sparc condition code operations are nasty ...
         * Ideally we want a fast mechanism to determine if a conditional
         * operation is true or not based on the condition codes.
         * Except that the condition expressions dont well match
         * the condition code flags.
         *
         * Now we have a 4 bit condition expression and a 4 bit condition
         * code register, so we could combine to form an index for a 256
         * bit array of true and false ... except that the cond expression
         * is always encoded in the instruction ...
         *
         * For now we use the cond expression, as an index into a table of
         * 16bit words. The cond code register selects a bit from this
         * the result of which is true or false ...
         *
         * This code mechanically builds those 16bit words to be indexed
         * by the condition code register value.
         */

#include <ctype.h>      /* for islower / toupper */
#include <errno.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>     /* for strchr */
#include <sys/param.h>  /* for MAXPATHLEN */
#include <sys/types.h>
#include <unistd.h>

#include "hostcpu.h"


void fatal(char* fmt, ...);
void strcasecpy(char * top, char * fromp);

typedef enum {
        cond_a   = 0x8,
        cond_n   = 0x0,
        cond_ne  = 0x9,
        cond_e   = 0x1,
        cond_g   = 0xA,
        cond_le  = 0x2,
        cond_ge  = 0xB,
        cond_l   = 0x3,
        cond_gu  = 0xC,
        cond_leu = 0x4,
        cond_cc  = 0xD,
        cond_cs  = 0x5,
        cond_pos = 0xE,
        cond_neg = 0x6,
        cond_vc  = 0xF,
        cond_vs  = 0x7
} cond_type_t;


typedef enum {
        cc_bit_c = 0x1,
        cc_bit_v = 0x2,
        cc_bit_z = 0x4,
        cc_bit_n = 0x8
} cc_bit_t;


void
gencodes(FILE * fp)
{
        int cond, ccr;


        for (cond=0; cond<16; cond++) {
                uint16_t mask;

                mask = 0;
                for (ccr=0; ccr<16; ccr++) {

                        switch (cond) {
                        case    cond_a:
                                goto set_bit;
                        case    cond_n:
                                goto clear_bit;
                        case    cond_ne:
                                if (!(ccr & cc_bit_z)) goto set_bit;
                                goto clear_bit;
                        case    cond_e:
                                if (ccr & cc_bit_z) goto set_bit;
                                goto clear_bit;
                        case    cond_g:
                                if ( !( (ccr&cc_bit_z) ||  (((ccr>>2)^ccr)&cc_bit_v) ) ) goto set_bit;
                                goto clear_bit;
                        case    cond_le:
                                if ( (ccr&cc_bit_z) ||  (((ccr>>2)^ccr)&cc_bit_v) ) goto set_bit;
                                goto clear_bit;
                        case    cond_ge:
                                if (!(  ((ccr>>2)^ccr)&cc_bit_v )) goto set_bit;
                                goto clear_bit;
                        case    cond_l:
                                if (  ((ccr>>2)^ccr)&cc_bit_v ) goto set_bit;
                                goto clear_bit;
                        case    cond_gu:
                                if (!((ccr & cc_bit_c) || (ccr & cc_bit_z))) goto set_bit;
                                goto clear_bit;
                        case    cond_leu:
                                if ((ccr & cc_bit_c) || (ccr & cc_bit_z)) goto set_bit;
                                goto clear_bit;
                        case    cond_cc:
                                if (!(ccr & cc_bit_c)) goto set_bit;
                                goto clear_bit;
                        case    cond_cs:
                                if (ccr & cc_bit_c) goto set_bit;
                                goto clear_bit;
                        case    cond_pos:
                                if (!(ccr & cc_bit_n)) goto set_bit;
                                goto clear_bit;
                        case    cond_neg:
                                if (ccr & cc_bit_n) goto set_bit;
                                goto clear_bit;
                        case    cond_vc:
                                if (!(ccr & cc_bit_v)) goto set_bit;
                                goto clear_bit;
                        case    cond_vs:
                                if (ccr & cc_bit_v) goto set_bit;
                                goto clear_bit;
                        default:
                                abort();
                        }
set_bit:;
                        mask |= 1<<ccr;
clear_bit:;
                }
                fprintf(fp, "\t0x%04lx%s\n", (uint32_t)mask, cond!=15 ? "," : "");
        }
}


int main(int argc, char ** argv)
{
#define MAXBUF  1024
        char bufp[MAXPATHLEN];
        char caps[MAXPATHLEN];
        char * bnamep;
        FILE * dotc, * doth;
        char * basenamep;
        char * structnamep;
        char * specfilep;

        if (argc != 3) fatal("usage: %s <basefilename> <basestructname>\n",
                        argv[0]);

        basenamep = argv[1];
        structnamep = argv[2];
        if (strlen(structnamep)>MAXBUF-100) fatal("basestructname is too long!");

                /* Initialise the .h and .c files */

        sprintf(bufp, "%s.c", basenamep);
        dotc = fopen(bufp, "w");
        if (dotc == NULL) fatal("creating %s", bufp);

        sprintf(bufp, "%s.h", basenamep);
        doth = fopen(bufp, "w");
        if (doth == NULL) fatal("creating %s", bufp);

                /* remove any earlier path ... */
        bnamep = strrchr(basenamep, '/');
        if (bnamep == (char*)0)
                bnamep = basenamep;
        else
                bnamep ++;

        strcasecpy(caps, bnamep);


        fprintf(dotc,"\
/* Autogenerated file - DO NOT EDIT */\n\
#include \"basics.h\"\n\
#include \"%s.h\"\n\
\n\
uint16_t %s[16]={\n", bnamep, structnamep);
        gencodes(dotc);
        fprintf(dotc,"\
};\n\
\n\
\n", bnamep, structnamep);

        fclose(dotc);

        fprintf(doth,"\
#ifndef _%s_H_\n\
#define _%s_H_\n\
\n\
extern uint16_t %s[];\n\
\n\
#endif\n", caps, caps, structnamep);

        fclose(doth);
        exit(0);

        return 0;       /* compiler joy */
}


void fatal(char* fmt, ...)
{
        va_list         args;

        if (errno!=0) perror("FATAL: "); else fprintf(stderr,"FATAL: ");
        if (fmt) {
                va_start(args, fmt);
                (void)vfprintf(stderr, fmt, args);

                va_end(args);
        }

        fprintf(stderr,"\n");
        fflush(stderr);
        fflush(stdout);

        exit(1);
}


void strcasecpy(char * top, char * fromp)
{
        do {
                *top++ = islower((unsigned)*fromp) ? toupper((unsigned)*fromp) : *fromp;
        } while (*fromp++ != '\0');
}