- reverting back to original romcc.c before hdama checkin broke all

[coreboot.git] / util / romcc / romcc.c

#undef VERSION_MAJOR
#undef VERSION_MINOR
#undef RELEASE_DATE
#undef VERSION
#define VERSION_MAJOR "0"
#define VERSION_MINOR "68"
#define RELEASE_DATE "15 November 2004"
#define VERSION VERSION_MAJOR "." VERSION_MINOR

#include <stdarg.h>
#include <errno.h>
#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <limits.h>
#include <locale.h>
#include <time.h>

#define MAX_CWD_SIZE 4096
#define MAX_ALLOCATION_PASSES 100

#define DEBUG_CONSISTENCY 1
#define DEBUG_SDP_BLOCKS 0
#define DEBUG_TRIPLE_COLOR 0

#define DEBUG_DISPLAY_USES 1
#define DEBUG_DISPLAY_TYPES 1
#define DEBUG_REPLACE_CLOSURE_TYPE_HIRES 0
#define DEBUG_DECOMPOSE_PRINT_TUPLES 0
#define DEBUG_DECOMPOSE_HIRES  0
#define DEBUG_INITIALIZER 0
#define DEBUG_UPDATE_CLOSURE_TYPE 0
#define DEBUG_LOCAL_TRIPLE 0
#define DEBUG_BASIC_BLOCKS_VERBOSE 0
#define DEBUG_CPS_RENAME_VARIABLES_HIRES 0
#define DEBUG_SIMPLIFY_HIRES 0
#define DEBUG_SHRINKING 0
#define DEBUG_COALESCE_HITCHES 0
#define DEBUG_CODE_ELIMINATION 0

#define DEBUG_EXPLICIT_CLOSURES 0

#warning "FIXME give clear error messages about unused variables"
#warning "FIXME properly handle multi dimensional arrays"
#warning "FIXME handle multiple register sizes"

/*  Control flow graph of a loop without goto.
 * 
 *        AAA
 *   +---/
 *  /
 * / +--->CCC
 * | |    / \
 * | |  DDD EEE    break;
 * | |    \    \
 * | |    FFF   \
 *  \|    / \    \
 *   |\ GGG HHH   |   continue;
 *   | \  \   |   |
 *   |  \ III |  /
 *   |   \ | /  / 
 *   |    vvv  /  
 *   +----BBB /   
 *         | /
 *         vv
 *        JJJ
 *
 * 
 *             AAA
 *     +-----+  |  +----+
 *     |      \ | /     |
 *     |       BBB  +-+ |
 *     |       / \ /  | |
 *     |     CCC JJJ / /
 *     |     / \    / / 
 *     |   DDD EEE / /  
 *     |    |   +-/ /
 *     |   FFF     /    
 *     |   / \    /     
 *     | GGG HHH /      
 *     |  |   +-/
 *     | III
 *     +--+ 
 *
 * 
 * DFlocal(X) = { Y <- Succ(X) | idom(Y) != X }
 * DFup(Z)    = { Y <- DF(Z) | idom(Y) != X }
 *
 *
 * [] == DFlocal(X) U DF(X)
 * () == DFup(X)
 *
 * Dominator graph of the same nodes.
 *
 *           AAA     AAA: [ ] ()
 *          /   \
 *        BBB    JJJ BBB: [ JJJ ] ( JJJ )  JJJ: [ ] ()
 *         |
 *        CCC        CCC: [ ] ( BBB, JJJ )
 *        / \
 *     DDD   EEE     DDD: [ ] ( BBB ) EEE: [ JJJ ] ()
 *      |
 *     FFF           FFF: [ ] ( BBB )
 *     / \         
 *  GGG   HHH        GGG: [ ] ( BBB ) HHH: [ BBB ] ()
 *   |
 *  III              III: [ BBB ] ()
 *
 *
 * BBB and JJJ are definitely the dominance frontier.
 * Where do I place phi functions and how do I make that decision.
 *   
 */
static void die(char *fmt, ...)
{
        va_list args;

        va_start(args, fmt);
        vfprintf(stderr, fmt, args);
        va_end(args);
        fflush(stdout);
        fflush(stderr);
        exit(1);
}

static void *xmalloc(size_t size, const char *name)
{
        void *buf;
        buf = malloc(size);
        if (!buf) {
                die("Cannot malloc %ld bytes to hold %s: %s\n",
                        size + 0UL, name, strerror(errno));
        }
        return buf;
}

static void *xcmalloc(size_t size, const char *name)
{
        void *buf;
        buf = xmalloc(size, name);
        memset(buf, 0, size);
        return buf;
}

static void *xrealloc(void *ptr, size_t size, const char *name)
{
        void *buf;
        buf = realloc(ptr, size);
        if (!buf) {
                die("Cannot realloc %ld bytes to hold %s: %s\n",
                        size + 0UL, name, strerror(errno));
        }
        return buf;
}

static void xfree(const void *ptr)
{
        free((void *)ptr);
}

static char *xstrdup(const char *str)
{
        char *new;
        int len;
        len = strlen(str);
        new = xmalloc(len + 1, "xstrdup string");
        memcpy(new, str, len);
        new[len] = '\0';
        return new;
}

static void xchdir(const char *path)
{
        if (chdir(path) != 0) {
                die("chdir to `%s' failed: %s\n",
                        path, strerror(errno));
        }
}

static int exists(const char *dirname, const char *filename)
{
        char cwd[MAX_CWD_SIZE];
        int does_exist;

        if (getcwd(cwd, sizeof(cwd)) == 0) {
                die("cwd buffer to small");
        }

        does_exist = 1;
        if (chdir(dirname) != 0) {
                does_exist = 0;
        }
        if (does_exist && (access(filename, O_RDONLY) < 0)) {
                if ((errno != EACCES) && (errno != EROFS)) {
                        does_exist = 0;
                }
        }
        xchdir(cwd);
        return does_exist;
}


static char *slurp_file(const char *dirname, const char *filename, off_t *r_size)
{
        char cwd[MAX_CWD_SIZE];
        int fd;
        char *buf;
        off_t size, progress;
        ssize_t result;
        struct stat stats;
        
        if (!filename) {
                *r_size = 0;
                return 0;
        }
        if (getcwd(cwd, sizeof(cwd)) == 0) {
                die("cwd buffer to small");
        }
        xchdir(dirname);
        fd = open(filename, O_RDONLY);
        xchdir(cwd);
        if (fd < 0) {
                die("Cannot open '%s' : %s\n",
                        filename, strerror(errno));
        }
        result = fstat(fd, &stats);
        if (result < 0) {
                die("Cannot stat: %s: %s\n",
                        filename, strerror(errno));
        }
        size = stats.st_size;
        *r_size = size +1;
        buf = xmalloc(size +2, filename);
        buf[size] = '\n'; /* Make certain the file is newline terminated */
        buf[size+1] = '\0'; /* Null terminate the file for good measure */
        progress = 0;
        while(progress < size) {
                result = read(fd, buf + progress, size - progress);
                if (result < 0) {
                        if ((errno == EINTR) || (errno == EAGAIN))
                                continue;
                        die("read on %s of %ld bytes failed: %s\n",
                                filename, (size - progress)+ 0UL, strerror(errno));
                }
                progress += result;
        }
        result = close(fd);
        if (result < 0) {
                die("Close of %s failed: %s\n",
                        filename, strerror(errno));
        }
        return buf;
}

/* Types on the destination platform */
#warning "FIXME this assumes 32bit x86 is the destination"
typedef int8_t   schar_t;
typedef uint8_t  uchar_t;
typedef int8_t   char_t;
typedef int16_t  short_t;
typedef uint16_t ushort_t;
typedef int32_t  int_t;
typedef uint32_t uint_t;
typedef int32_t  long_t;
typedef uint32_t ulong_t;

#define SCHAR_T_MIN (-128)
#define SCHAR_T_MAX 127
#define UCHAR_T_MAX 255
#define CHAR_T_MIN  SCHAR_T_MIN
#define CHAR_T_MAX  SCHAR_T_MAX
#define SHRT_T_MIN  (-32768)
#define SHRT_T_MAX  32767
#define USHRT_T_MAX 65535
#define INT_T_MIN   (-LONG_T_MAX - 1)
#define INT_T_MAX   2147483647
#define UINT_T_MAX  4294967295U
#define LONG_T_MIN  (-LONG_T_MAX - 1)
#define LONG_T_MAX  2147483647
#define ULONG_T_MAX 4294967295U

#define SIZEOF_I8    8
#define SIZEOF_I16   16
#define SIZEOF_I32   32
#define SIZEOF_I64   64

#define SIZEOF_CHAR    8
#define SIZEOF_SHORT   16
#define SIZEOF_INT     32
#define SIZEOF_LONG    (sizeof(long_t)*SIZEOF_CHAR)


#define ALIGNOF_CHAR    8
#define ALIGNOF_SHORT   16
#define ALIGNOF_INT     32
#define ALIGNOF_LONG    (sizeof(long_t)*SIZEOF_CHAR)

#define REG_SIZEOF_REG     32
#define REG_SIZEOF_CHAR    REG_SIZEOF_REG
#define REG_SIZEOF_SHORT   REG_SIZEOF_REG
#define REG_SIZEOF_INT     REG_SIZEOF_REG
#define REG_SIZEOF_LONG    REG_SIZEOF_REG

#define REG_ALIGNOF_REG     REG_SIZEOF_REG
#define REG_ALIGNOF_CHAR    REG_SIZEOF_REG
#define REG_ALIGNOF_SHORT   REG_SIZEOF_REG
#define REG_ALIGNOF_INT     REG_SIZEOF_REG
#define REG_ALIGNOF_LONG    REG_SIZEOF_REG

/* Additional definitions for clarity.
 * I currently assume a long is the largest native
 * machine word and that a pointer fits into it.
 */
#define SIZEOF_WORD     SIZEOF_LONG
#define SIZEOF_POINTER  SIZEOF_LONG
#define ALIGNOF_WORD    ALIGNOF_LONG
#define ALIGNOF_POINTER ALIGNOF_LONG
#define REG_SIZEOF_POINTER  REG_SIZEOF_LONG
#define REG_ALIGNOF_POINTER REG_ALIGNOF_LONG

struct file_state {
        struct file_state *prev;
        const char *basename;
        char *dirname;
        const char *buf;
        off_t size;
        const char *pos;
        int line;
        const char *line_start;
        int report_line;
        const char *report_name;
        const char *report_dir;
        int macro      : 1;
        int trigraphs  : 1;
        int join_lines : 1;
};
struct hash_entry;
struct token {
        int tok;
        struct hash_entry *ident;
        const char *pos;
        int str_len;
        union {
                ulong_t integer;
                const char *str;
                int notmacro;
        } val;
};

/* I have two classes of types:
 * Operational types.
 * Logical types.  (The type the C standard says the operation is of)
 *
 * The operational types are:
 * chars
 * shorts
 * ints
 * longs
 *
 * floats
 * doubles
 * long doubles
 *
 * pointer
 */


/* Machine model.
 * No memory is useable by the compiler.
 * There is no floating point support.
 * All operations take place in general purpose registers.
 * There is one type of general purpose register.
 * Unsigned longs are stored in that general purpose register.
 */

/* Operations on general purpose registers.
 */

#define OP_SDIVT      0
#define OP_UDIVT      1
#define OP_SMUL       2
#define OP_UMUL       3
#define OP_SDIV       4
#define OP_UDIV       5
#define OP_SMOD       6
#define OP_UMOD       7
#define OP_ADD        8
#define OP_SUB        9
#define OP_SL        10
#define OP_USR       11
#define OP_SSR       12 
#define OP_AND       13 
#define OP_XOR       14
#define OP_OR        15
#define OP_POS       16 /* Dummy positive operator don't use it */
#define OP_NEG       17
#define OP_INVERT    18
                     
#define OP_EQ        20
#define OP_NOTEQ     21
#define OP_SLESS     22
#define OP_ULESS     23
#define OP_SMORE     24
#define OP_UMORE     25
#define OP_SLESSEQ   26
#define OP_ULESSEQ   27
#define OP_SMOREEQ   28
#define OP_UMOREEQ   29
                     
#define OP_LFALSE    30  /* Test if the expression is logically false */
#define OP_LTRUE     31  /* Test if the expression is logcially true */

#define OP_LOAD      32
#define OP_STORE     33
/* For OP_STORE ->type holds the type
 * RHS(0) holds the destination address
 * RHS(1) holds the value to store.
 */

#define OP_UEXTRACT  34
/* OP_UEXTRACT extracts an unsigned bitfield from a pseudo register
 * RHS(0) holds the psuedo register to extract from
 * ->type holds the size of the bitfield.
 * ->u.bitfield.size holds the size of the bitfield.
 * ->u.bitfield.offset holds the offset to extract from
 */
#define OP_SEXTRACT  35
/* OP_SEXTRACT extracts a signed bitfield from a pseudo register
 * RHS(0) holds the psuedo register to extract from
 * ->type holds the size of the bitfield.
 * ->u.bitfield.size holds the size of the bitfield.
 * ->u.bitfield.offset holds the offset to extract from
 */
#define OP_DEPOSIT   36
/* OP_DEPOSIT replaces a bitfield with a new value.
 * RHS(0) holds the value to replace a bitifield in.
 * RHS(1) holds the replacement value
 * ->u.bitfield.size holds the size of the bitfield.
 * ->u.bitfield.offset holds the deposit into
 */

#define OP_NOOP      37

#define OP_MIN_CONST 50
#define OP_MAX_CONST 58
#define IS_CONST_OP(X) (((X) >= OP_MIN_CONST) && ((X) <= OP_MAX_CONST))
#define OP_INTCONST  50
/* For OP_INTCONST ->type holds the type.
 * ->u.cval holds the constant value.
 */
#define OP_BLOBCONST 51
/* For OP_BLOBCONST ->type holds the layout and size
 * information.  u.blob holds a pointer to the raw binary
 * data for the constant initializer.
 */
#define OP_ADDRCONST 52
/* For OP_ADDRCONST ->type holds the type.
 * MISC(0) holds the reference to the static variable.
 * ->u.cval holds an offset from that value.
 */
#define OP_UNKNOWNVAL 59
/* For OP_UNKNOWNAL ->type holds the type.
 * For some reason we don't know what value this type has.
 * This allows for variables that have don't have values
 * assigned yet, or variables whose value we simply do not know.
 */

#define OP_WRITE     60 
/* OP_WRITE moves one pseudo register to another.
 * MISC(0) holds the destination pseudo register, which must be an OP_DECL.
 * RHS(0) holds the psuedo to move.
 */

#define OP_READ      61
/* OP_READ reads the value of a variable and makes
 * it available for the pseudo operation.
 * Useful for things like def-use chains.
 * RHS(0) holds points to the triple to read from.
 */
#define OP_COPY      62
/* OP_COPY makes a copy of the pseudo register or constant in RHS(0).
 */
#define OP_CONVERT   63
/* OP_CONVERT makes a copy of the pseudo register or constant in RHS(0).
 * And then the type is converted appropriately.
 */
#define OP_PIECE     64
/* OP_PIECE returns one piece of a instruction that returns a structure.
 * MISC(0) is the instruction
 * u.cval is the LHS piece of the instruction to return.
 */
#define OP_ASM       65
/* OP_ASM holds a sequence of assembly instructions, the result
 * of a C asm directive.
 * RHS(x) holds input value x to the assembly sequence.
 * LHS(x) holds the output value x from the assembly sequence.
 * u.blob holds the string of assembly instructions.
 */

#define OP_DEREF     66
/* OP_DEREF generates an lvalue from a pointer.
 * RHS(0) holds the pointer value.
 * OP_DEREF serves as a place holder to indicate all necessary
 * checks have been done to indicate a value is an lvalue.
 */
#define OP_DOT       67
/* OP_DOT references a submember of a structure lvalue.
 * MISC(0) holds the lvalue.
 * ->u.field holds the name of the field we want.
 *
 * Not seen after structures are flattened.
 */
#define OP_INDEX     68
/* OP_INDEX references a submember of a tuple or array lvalue.
 * MISC(0) holds the lvalue.
 * ->u.cval holds the index into the lvalue.
 *
 * Not seen after structures are flattened.
 */
#define OP_VAL       69
/* OP_VAL returns the value of a subexpression of the current expression.
 * Useful for operators that have side effects.
 * RHS(0) holds the expression.
 * MISC(0) holds the subexpression of RHS(0) that is the
 * value of the expression.
 *
 * Not seen outside of expressions.
 */

#define OP_TUPLE     70
/* OP_TUPLE is an array of triples that are either variable
 * or values for a structure or an array.  It is used as
 * a place holder when flattening compound types.
 * The value represented by an OP_TUPLE is held in N registers.
 * LHS(0..N-1) refer to those registers.
 * ->use is a list of statements that use the value.
 * 
 * Although OP_TUPLE always has register sized pieces they are not
 * used until structures are flattened/decomposed into their register
 * components. 
 * ???? registers ????
 */

#define OP_BITREF    71
/* OP_BITREF describes a bitfield as an lvalue.
 * RHS(0) holds the register value.
 * ->type holds the type of the bitfield.
 * ->u.bitfield.size holds the size of the bitfield.
 * ->u.bitfield.offset holds the offset of the bitfield in the register
 */


#define OP_FCALL     72
/* OP_FCALL performs a procedure call. 
 * MISC(0) holds a pointer to the OP_LIST of a function
 * RHS(x) holds argument x of a function
 * 
 * Currently not seen outside of expressions.
 */
#define OP_PROG      73
/* OP_PROG is an expression that holds a list of statements, or
 * expressions.  The final expression is the value of the expression.
 * RHS(0) holds the start of the list.
 */

/* statements */
#define OP_LIST      80
/* OP_LIST Holds a list of statements that compose a function, and a result value.
 * RHS(0) holds the list of statements.
 * A list of all functions is maintained.
 */

#define OP_BRANCH    81 /* an unconditional branch */
/* For branch instructions
 * TARG(0) holds the branch target.
 * ->next holds where to branch to if the branch is not taken.
 * The branch target can only be a label
 */

#define OP_CBRANCH   82 /* a conditional branch */
/* For conditional branch instructions
 * RHS(0) holds the branch condition.
 * TARG(0) holds the branch target.
 * ->next holds where to branch to if the branch is not taken.
 * The branch target can only be a label
 */

#define OP_CALL      83 /* an uncontional branch that will return */
/* For call instructions
 * MISC(0) holds the OP_RET that returns from the branch
 * TARG(0) holds the branch target.
 * ->next holds where to branch to if the branch is not taken.
 * The branch target can only be a label
 */

#define OP_RET       84 /* an uncontinonal branch through a variable back to an OP_CALL */
/* For call instructions
 * RHS(0) holds the variable with the return address
 * The branch target can only be a label
 */

#define OP_LABEL     86
/* OP_LABEL is a triple that establishes an target for branches.
 * ->use is the list of all branches that use this label.
 */

#define OP_ADECL     87 
/* OP_ADECL is a triple that establishes an lvalue for assignments.
 * A variable takes N registers to contain.
 * LHS(0..N-1) refer to an OP_PIECE triple that represents
 * the Xth register that the variable is stored in.
 * ->use is a list of statements that use the variable.
 * 
 * Although OP_ADECL always has register sized pieces they are not
 * used until structures are flattened/decomposed into their register
 * components. 
 */

#define OP_SDECL     88
/* OP_SDECL is a triple that establishes a variable of static
 * storage duration.
 * ->use is a list of statements that use the variable.
 * MISC(0) holds the initializer expression.
 */


#define OP_PHI       89
/* OP_PHI is a triple used in SSA form code.  
 * It is used when multiple code paths merge and a variable needs
 * a single assignment from any of those code paths.
 * The operation is a cross between OP_DECL and OP_WRITE, which
 * is what OP_PHI is generated from.
 * 
 * RHS(x) points to the value from code path x
 * The number of RHS entries is the number of control paths into the block
 * in which OP_PHI resides.  The elements of the array point to point
 * to the variables OP_PHI is derived from.
 *
 * MISC(0) holds a pointer to the orginal OP_DECL node.
 */

#if 0
/* continuation helpers
 */
#define OP_CPS_BRANCH    90 /* an unconditional branch */
/* OP_CPS_BRANCH calls a continuation 
 * RHS(x) holds argument x of the function
 * TARG(0) holds OP_CPS_START target
 */
#define OP_CPS_CBRANCH   91  /* a conditional branch */
/* OP_CPS_CBRANCH conditionally calls one of two continuations 
 * RHS(0) holds the branch condition
 * RHS(x + 1) holds argument x of the function
 * TARG(0) holds the OP_CPS_START to jump to when true
 * ->next holds the OP_CPS_START to jump to when false
 */
#define OP_CPS_CALL      92  /* an uncontional branch that will return */
/* For OP_CPS_CALL instructions
 * RHS(x) holds argument x of the function
 * MISC(0) holds the OP_CPS_RET that returns from the branch
 * TARG(0) holds the branch target.
 * ->next holds where the OP_CPS_RET will return to.
 */
#define OP_CPS_RET       93
/* OP_CPS_RET conditionally calls one of two continuations 
 * RHS(0) holds the variable with the return function address
 * RHS(x + 1) holds argument x of the function
 * The branch target may be any OP_CPS_START
 */
#define OP_CPS_END       94
/* OP_CPS_END is the triple at the end of the program.
 * For most practical purposes it is a branch.
 */
#define OP_CPS_START     95
/* OP_CPS_START is a triple at the start of a continuation
 * The arguments variables takes N registers to contain.
 * LHS(0..N-1) refer to an OP_PIECE triple that represents
 * the Xth register that the arguments are stored in.
 */
#endif

/* Architecture specific instructions */
#define OP_CMP         100
#define OP_TEST        101
#define OP_SET_EQ      102
#define OP_SET_NOTEQ   103
#define OP_SET_SLESS   104
#define OP_SET_ULESS   105
#define OP_SET_SMORE   106
#define OP_SET_UMORE   107
#define OP_SET_SLESSEQ 108
#define OP_SET_ULESSEQ 109
#define OP_SET_SMOREEQ 110
#define OP_SET_UMOREEQ 111

#define OP_JMP         112
#define OP_JMP_EQ      113
#define OP_JMP_NOTEQ   114
#define OP_JMP_SLESS   115
#define OP_JMP_ULESS   116
#define OP_JMP_SMORE   117
#define OP_JMP_UMORE   118
#define OP_JMP_SLESSEQ 119
#define OP_JMP_ULESSEQ 120
#define OP_JMP_SMOREEQ 121
#define OP_JMP_UMOREEQ 122

/* Builtin operators that it is just simpler to use the compiler for */
#define OP_INB         130
#define OP_INW         131
#define OP_INL         132
#define OP_OUTB        133
#define OP_OUTW        134
#define OP_OUTL        135
#define OP_BSF         136
#define OP_BSR         137
#define OP_RDMSR       138
#define OP_WRMSR       139
#define OP_HLT         140

struct op_info {
        const char *name;
        unsigned flags;
#define PURE       0x001 /* Triple has no side effects */
#define IMPURE     0x002 /* Triple has side effects */
#define PURE_BITS(FLAGS) ((FLAGS) & 0x3)
#define DEF        0x004 /* Triple is a variable definition */
#define BLOCK      0x008 /* Triple stores the current block */
#define STRUCTURAL 0x010 /* Triple does not generate a machine instruction */
#define BRANCH_BITS(FLAGS) ((FLAGS) & 0xe0 )
#define UBRANCH    0x020 /* Triple is an unconditional branch instruction */
#define CBRANCH    0x040 /* Triple is a conditional branch instruction */
#define RETBRANCH  0x060 /* Triple is a return instruction */
#define CALLBRANCH 0x080 /* Triple is a call instruction */
#define ENDBRANCH  0x0a0 /* Triple is an end instruction */
#define PART       0x100 /* Triple is really part of another triple */
#define BITFIELD   0x200 /* Triple manipulates a bitfield */
        signed char lhs, rhs, misc, targ;
};

#define OP(LHS, RHS, MISC, TARG, FLAGS, NAME) { \
        .name = (NAME), \
        .flags = (FLAGS), \
        .lhs = (LHS), \
        .rhs = (RHS), \
        .misc = (MISC), \
        .targ = (TARG), \
         }
static const struct op_info table_ops[] = {
[OP_SDIVT      ] = OP( 2,  2, 0, 0, PURE | BLOCK , "sdivt"),
[OP_UDIVT      ] = OP( 2,  2, 0, 0, PURE | BLOCK , "udivt"),
[OP_SMUL       ] = OP( 0,  2, 0, 0, PURE | DEF | BLOCK , "smul"),
[OP_UMUL       ] = OP( 0,  2, 0, 0, PURE | DEF | BLOCK , "umul"),
[OP_SDIV       ] = OP( 0,  2, 0, 0, PURE | DEF | BLOCK , "sdiv"),
[OP_UDIV       ] = OP( 0,  2, 0, 0, PURE | DEF | BLOCK , "udiv"),
[OP_SMOD       ] = OP( 0,  2, 0, 0, PURE | DEF | BLOCK , "smod"),
[OP_UMOD       ] = OP( 0,  2, 0, 0, PURE | DEF | BLOCK , "umod"),
[OP_ADD        ] = OP( 0,  2, 0, 0, PURE | DEF | BLOCK , "add"),
[OP_SUB        ] = OP( 0,  2, 0, 0, PURE | DEF | BLOCK , "sub"),
[OP_SL         ] = OP( 0,  2, 0, 0, PURE | DEF | BLOCK , "sl"),
[OP_USR        ] = OP( 0,  2, 0, 0, PURE | DEF | BLOCK , "usr"),
[OP_SSR        ] = OP( 0,  2, 0, 0, PURE | DEF | BLOCK , "ssr"),
[OP_AND        ] = OP( 0,  2, 0, 0, PURE | DEF | BLOCK , "and"),
[OP_XOR        ] = OP( 0,  2, 0, 0, PURE | DEF | BLOCK , "xor"),
[OP_OR         ] = OP( 0,  2, 0, 0, PURE | DEF | BLOCK , "or"),
[OP_POS        ] = OP( 0,  1, 0, 0, PURE | DEF | BLOCK , "pos"),
[OP_NEG        ] = OP( 0,  1, 0, 0, PURE | DEF | BLOCK , "neg"),
[OP_INVERT     ] = OP( 0,  1, 0, 0, PURE | DEF | BLOCK , "invert"),

[OP_EQ         ] = OP( 0,  2, 0, 0, PURE | DEF | BLOCK , "eq"),
[OP_NOTEQ      ] = OP( 0,  2, 0, 0, PURE | DEF | BLOCK , "noteq"),
[OP_SLESS      ] = OP( 0,  2, 0, 0, PURE | DEF | BLOCK , "sless"),
[OP_ULESS      ] = OP( 0,  2, 0, 0, PURE | DEF | BLOCK , "uless"),
[OP_SMORE      ] = OP( 0,  2, 0, 0, PURE | DEF | BLOCK , "smore"),
[OP_UMORE      ] = OP( 0,  2, 0, 0, PURE | DEF | BLOCK , "umore"),
[OP_SLESSEQ    ] = OP( 0,  2, 0, 0, PURE | DEF | BLOCK , "slesseq"),
[OP_ULESSEQ    ] = OP( 0,  2, 0, 0, PURE | DEF | BLOCK , "ulesseq"),
[OP_SMOREEQ    ] = OP( 0,  2, 0, 0, PURE | DEF | BLOCK , "smoreeq"),
[OP_UMOREEQ    ] = OP( 0,  2, 0, 0, PURE | DEF | BLOCK , "umoreeq"),
[OP_LFALSE     ] = OP( 0,  1, 0, 0, PURE | DEF | BLOCK , "lfalse"),
[OP_LTRUE      ] = OP( 0,  1, 0, 0, PURE | DEF | BLOCK , "ltrue"),

[OP_LOAD       ] = OP( 0,  1, 0, 0, PURE | DEF | BLOCK, "load"),
[OP_STORE      ] = OP( 0,  2, 0, 0, PURE | BLOCK , "store"),

[OP_UEXTRACT   ] = OP( 0,  1, 0, 0, PURE | DEF | BITFIELD, "uextract"),
[OP_SEXTRACT   ] = OP( 0,  1, 0, 0, PURE | DEF | BITFIELD, "sextract"),
[OP_DEPOSIT    ] = OP( 0,  2, 0, 0, PURE | DEF | BITFIELD, "deposit"),

[OP_NOOP       ] = OP( 0,  0, 0, 0, PURE | BLOCK | STRUCTURAL, "noop"),

[OP_INTCONST   ] = OP( 0,  0, 0, 0, PURE | DEF, "intconst"),
[OP_BLOBCONST  ] = OP( 0,  0, 0, 0, PURE , "blobconst"),
[OP_ADDRCONST  ] = OP( 0,  0, 1, 0, PURE | DEF, "addrconst"),
[OP_UNKNOWNVAL ] = OP( 0,  0, 0, 0, PURE | DEF, "unknown"),

#warning "FIXME is it correct for OP_WRITE to be a def?  I currently use it as one..."
[OP_WRITE      ] = OP( 0,  1, 1, 0, PURE | DEF | BLOCK, "write"),
[OP_READ       ] = OP( 0,  1, 0, 0, PURE | DEF | BLOCK, "read"),
[OP_COPY       ] = OP( 0,  1, 0, 0, PURE | DEF | BLOCK, "copy"),
[OP_CONVERT    ] = OP( 0,  1, 0, 0, PURE | DEF | BLOCK, "convert"),
[OP_PIECE      ] = OP( 0,  0, 1, 0, PURE | DEF | STRUCTURAL | PART, "piece"),
[OP_ASM        ] = OP(-1, -1, 0, 0, PURE, "asm"),
[OP_DEREF      ] = OP( 0,  1, 0, 0, 0 | DEF | BLOCK, "deref"), 
[OP_DOT        ] = OP( 0,  0, 1, 0, PURE | DEF | PART, "dot"),
[OP_INDEX      ] = OP( 0,  0, 1, 0, PURE | DEF | PART, "index"),

[OP_VAL        ] = OP( 0,  1, 1, 0, 0 | DEF | BLOCK, "val"),
[OP_TUPLE      ] = OP(-1,  0, 0, 0, 0 | PURE | BLOCK | STRUCTURAL, "tuple"),
[OP_BITREF     ] = OP( 0,  1, 0, 0, 0 | DEF | PURE | STRUCTURAL | BITFIELD, "bitref"),
/* Call is special most it can stand in for anything so it depends on context */
[OP_FCALL      ] = OP( 0, -1, 1, 0, 0 | BLOCK | CALLBRANCH, "fcall"),
[OP_PROG       ] = OP( 0,  1, 0, 0, 0 | IMPURE | BLOCK | STRUCTURAL, "prog"),
/* The sizes of OP_FCALL depends upon context */

[OP_LIST       ] = OP( 0,  1, 1, 0, 0 | DEF | STRUCTURAL, "list"),
[OP_BRANCH     ] = OP( 0,  0, 0, 1, PURE | BLOCK | UBRANCH, "branch"),
[OP_CBRANCH    ] = OP( 0,  1, 0, 1, PURE | BLOCK | CBRANCH, "cbranch"),
[OP_CALL       ] = OP( 0,  0, 1, 1, PURE | BLOCK | CALLBRANCH, "call"),
[OP_RET        ] = OP( 0,  1, 0, 0, PURE | BLOCK | RETBRANCH, "ret"),
[OP_LABEL      ] = OP( 0,  0, 0, 0, PURE | BLOCK | STRUCTURAL, "label"),
[OP_ADECL      ] = OP( 0,  0, 0, 0, PURE | BLOCK | STRUCTURAL, "adecl"),
[OP_SDECL      ] = OP( 0,  0, 1, 0, PURE | BLOCK | STRUCTURAL, "sdecl"),
/* The number of RHS elements of OP_PHI depend upon context */
[OP_PHI        ] = OP( 0, -1, 1, 0, PURE | DEF | BLOCK, "phi"),

#if 0
[OP_CPS_BRANCH ] = OP( 0, -1, 0, 1, PURE | BLOCK | UBRANCH,     "cps_branch"),
[OP_CPS_CBRANCH] = OP( 0, -1, 0, 1, PURE | BLOCK | CBRANCH,     "cps_cbranch"),
[OP_CPS_CALL   ] = OP( 0, -1, 1, 1, PURE | BLOCK | CALLBRANCH,  "cps_call"),
[OP_CPS_RET    ] = OP( 0, -1, 0, 0, PURE | BLOCK | RETBRANCH,   "cps_ret"),
[OP_CPS_END    ] = OP( 0, -1, 0, 0, IMPURE | BLOCK | ENDBRANCH, "cps_end"),
[OP_CPS_START  ] = OP( -1, 0, 0, 0, PURE | BLOCK | STRUCTURAL,  "cps_start"),
#endif

[OP_CMP        ] = OP( 0,  2, 0, 0, PURE | DEF | BLOCK, "cmp"),
[OP_TEST       ] = OP( 0,  1, 0, 0, PURE | DEF | BLOCK, "test"),
[OP_SET_EQ     ] = OP( 0,  1, 0, 0, PURE | DEF | BLOCK, "set_eq"),
[OP_SET_NOTEQ  ] = OP( 0,  1, 0, 0, PURE | DEF | BLOCK, "set_noteq"),
[OP_SET_SLESS  ] = OP( 0,  1, 0, 0, PURE | DEF | BLOCK, "set_sless"),
[OP_SET_ULESS  ] = OP( 0,  1, 0, 0, PURE | DEF | BLOCK, "set_uless"),
[OP_SET_SMORE  ] = OP( 0,  1, 0, 0, PURE | DEF | BLOCK, "set_smore"),
[OP_SET_UMORE  ] = OP( 0,  1, 0, 0, PURE | DEF | BLOCK, "set_umore"),
[OP_SET_SLESSEQ] = OP( 0,  1, 0, 0, PURE | DEF | BLOCK, "set_slesseq"),
[OP_SET_ULESSEQ] = OP( 0,  1, 0, 0, PURE | DEF | BLOCK, "set_ulesseq"),
[OP_SET_SMOREEQ] = OP( 0,  1, 0, 0, PURE | DEF | BLOCK, "set_smoreq"),
[OP_SET_UMOREEQ] = OP( 0,  1, 0, 0, PURE | DEF | BLOCK, "set_umoreq"),
[OP_JMP        ] = OP( 0,  0, 0, 1, PURE | BLOCK | UBRANCH, "jmp"),
[OP_JMP_EQ     ] = OP( 0,  1, 0, 1, PURE | BLOCK | CBRANCH, "jmp_eq"),
[OP_JMP_NOTEQ  ] = OP( 0,  1, 0, 1, PURE | BLOCK | CBRANCH, "jmp_noteq"),
[OP_JMP_SLESS  ] = OP( 0,  1, 0, 1, PURE | BLOCK | CBRANCH, "jmp_sless"),
[OP_JMP_ULESS  ] = OP( 0,  1, 0, 1, PURE | BLOCK | CBRANCH, "jmp_uless"),
[OP_JMP_SMORE  ] = OP( 0,  1, 0, 1, PURE | BLOCK | CBRANCH, "jmp_smore"),
[OP_JMP_UMORE  ] = OP( 0,  1, 0, 1, PURE | BLOCK | CBRANCH, "jmp_umore"),
[OP_JMP_SLESSEQ] = OP( 0,  1, 0, 1, PURE | BLOCK | CBRANCH, "jmp_slesseq"),
[OP_JMP_ULESSEQ] = OP( 0,  1, 0, 1, PURE | BLOCK | CBRANCH, "jmp_ulesseq"),
[OP_JMP_SMOREEQ] = OP( 0,  1, 0, 1, PURE | BLOCK | CBRANCH, "jmp_smoreq"),
[OP_JMP_UMOREEQ] = OP( 0,  1, 0, 1, PURE | BLOCK | CBRANCH, "jmp_umoreq"),

[OP_INB        ] = OP( 0,  1, 0, 0, IMPURE | DEF | BLOCK, "__inb"),
[OP_INW        ] = OP( 0,  1, 0, 0, IMPURE | DEF | BLOCK, "__inw"),
[OP_INL        ] = OP( 0,  1, 0, 0, IMPURE | DEF | BLOCK, "__inl"),
[OP_OUTB       ] = OP( 0,  2, 0, 0, IMPURE| BLOCK, "__outb"),
[OP_OUTW       ] = OP( 0,  2, 0, 0, IMPURE| BLOCK, "__outw"),
[OP_OUTL       ] = OP( 0,  2, 0, 0, IMPURE| BLOCK, "__outl"),
[OP_BSF        ] = OP( 0,  1, 0, 0, PURE | DEF | BLOCK, "__bsf"),
[OP_BSR        ] = OP( 0,  1, 0, 0, PURE | DEF | BLOCK, "__bsr"),
[OP_RDMSR      ] = OP( 2,  1, 0, 0, IMPURE | BLOCK, "__rdmsr"),
[OP_WRMSR      ] = OP( 0,  3, 0, 0, IMPURE | BLOCK, "__wrmsr"),
[OP_HLT        ] = OP( 0,  0, 0, 0, IMPURE | BLOCK, "__hlt"),
};
#undef OP
#define OP_MAX      (sizeof(table_ops)/sizeof(table_ops[0]))

static const char *tops(int index) 
{
        static const char unknown[] = "unknown op";
        if (index < 0) {
                return unknown;
        }
        if (index > OP_MAX) {
                return unknown;
        }
        return table_ops[index].name;
}

struct asm_info;
struct triple;
struct block;
struct triple_set {
        struct triple_set *next;
        struct triple *member;
};

#define MAX_LHS  63
#define MAX_RHS  127
#define MAX_MISC 3
#define MAX_TARG 1

struct occurance {
        int count;
        const char *filename;
        const char *function;
        int line;
        int col;
        struct occurance *parent;
};
struct bitfield {
        ulong_t size : 8;
        ulong_t offset : 24;
};
struct triple {
        struct triple *next, *prev;
        struct triple_set *use;
        struct type *type;
        unsigned int op : 8;
        unsigned int template_id : 7;
        unsigned int lhs  : 6;
        unsigned int rhs  : 7;
        unsigned int misc : 2;
        unsigned int targ : 1;
#define TRIPLE_SIZE(TRIPLE) \
        ((TRIPLE)->lhs + (TRIPLE)->rhs + (TRIPLE)->misc + (TRIPLE)->targ)
#define TRIPLE_LHS_OFF(PTR)  (0)
#define TRIPLE_RHS_OFF(PTR)  (TRIPLE_LHS_OFF(PTR) + (PTR)->lhs)
#define TRIPLE_MISC_OFF(PTR) (TRIPLE_RHS_OFF(PTR) + (PTR)->rhs)
#define TRIPLE_TARG_OFF(PTR) (TRIPLE_MISC_OFF(PTR) + (PTR)->misc)
#define LHS(PTR,INDEX) ((PTR)->param[TRIPLE_LHS_OFF(PTR) + (INDEX)])
#define RHS(PTR,INDEX) ((PTR)->param[TRIPLE_RHS_OFF(PTR) + (INDEX)])
#define TARG(PTR,INDEX) ((PTR)->param[TRIPLE_TARG_OFF(PTR) + (INDEX)])
#define MISC(PTR,INDEX) ((PTR)->param[TRIPLE_MISC_OFF(PTR) + (INDEX)])
        unsigned id; /* A scratch value and finally the register */
#define TRIPLE_FLAG_FLATTENED   (1 << 31)
#define TRIPLE_FLAG_PRE_SPLIT   (1 << 30)
#define TRIPLE_FLAG_POST_SPLIT  (1 << 29)
#define TRIPLE_FLAG_VOLATILE    (1 << 28)
#define TRIPLE_FLAG_INLINE      (1 << 27) /* ???? */
#define TRIPLE_FLAG_LOCAL       (1 << 26)

#define TRIPLE_FLAG_COPY TRIPLE_FLAG_VOLATILE
        struct occurance *occurance;
        union {
                ulong_t cval;
                struct bitfield bitfield;
                struct block  *block;
                void *blob;
                struct hash_entry *field;
                struct asm_info *ainfo;
                struct triple *func;
                struct symbol *symbol;
        } u;
        struct triple *param[2];
};

struct reg_info {
        unsigned reg;
        unsigned regcm;
};
struct ins_template {
        struct reg_info lhs[MAX_LHS + 1], rhs[MAX_RHS + 1];
};

struct asm_info {
        struct ins_template tmpl;
        char *str;
};

struct block_set {
        struct block_set *next;
        struct block *member;
};
struct block {
        struct block *work_next;
        struct triple *first, *last;
        int edge_count;
        struct block_set *edges;
        int users;
        struct block_set *use;
        struct block_set *idominates;
        struct block_set *domfrontier;
        struct block *idom;
        struct block_set *ipdominates;
        struct block_set *ipdomfrontier;
        struct block *ipdom;
        int vertex;
        
};

struct symbol {
        struct symbol *next;
        struct hash_entry *ident;
        struct triple *def;
        struct type *type;
        int scope_depth;
};

struct macro_arg {
        struct macro_arg *next;
        struct hash_entry *ident;
};
struct macro {
        struct hash_entry *ident;
        const char *buf;
        int buf_len;
        struct macro_arg *args;
        int argc;
};

struct hash_entry {
        struct hash_entry *next;
        const char *name;
        int name_len;
        int tok;
        struct macro *sym_define;
        struct symbol *sym_label;
        struct symbol *sym_tag;
        struct symbol *sym_ident;
};

#define HASH_TABLE_SIZE 2048

struct compiler_state {
        const char *label_prefix;
        const char *ofilename;
        unsigned long flags;
        unsigned long debug;
        unsigned long max_allocation_passes;

        size_t include_path_count;
        const char **include_paths;

        size_t define_count;
        const char **defines;

        size_t undef_count;
        const char **undefs;
};
struct arch_state {
        unsigned long features;
};
struct basic_blocks {
        struct triple *func;
        struct triple *first;
        struct block *first_block, *last_block;
        int last_vertex;
};
#define MAX_PP_IF_DEPTH 63
struct compile_state {
        struct compiler_state *compiler;
        struct arch_state *arch;
        FILE *output;
        FILE *errout;
        FILE *dbgout;
        struct file_state *file;
        struct occurance *last_occurance;
        const char *function;
        int    token_base;
        struct token token[6];
        struct hash_entry *hash_table[HASH_TABLE_SIZE];
        struct hash_entry *i_switch;
        struct hash_entry *i_case;
        struct hash_entry *i_continue;
        struct hash_entry *i_break;
        struct hash_entry *i_default;
        struct hash_entry *i_return;
        /* Additional hash entries for predefined macros */
        struct hash_entry *i_defined;
        struct hash_entry *i___VA_ARGS__;
        struct hash_entry *i___FILE__;
        struct hash_entry *i___LINE__;
        /* Additional hash entries for predefined identifiers */
        struct hash_entry *i___func__;
        /* Additional hash entries for attributes */
        struct hash_entry *i_noinline;
        struct hash_entry *i_always_inline;
        int scope_depth;
        unsigned char if_bytes[(MAX_PP_IF_DEPTH + CHAR_BIT -1)/CHAR_BIT];
        int if_depth;
        int eat_depth, eat_targ;
        struct file_state *macro_file;
        struct triple *functions;
        struct triple *main_function;
        struct triple *first;
        struct triple *global_pool;
        struct basic_blocks bb;
        int functions_joined;
};

/* visibility global/local */
/* static/auto duration */
/* typedef, register, inline */
#define STOR_SHIFT         0
#define STOR_MASK     0x001f
/* Visibility */
#define STOR_GLOBAL   0x0001
/* Duration */
#define STOR_PERM     0x0002
/* Definition locality */
#define STOR_NONLOCAL 0x0004  /* The definition is not in this translation unit */
/* Storage specifiers */
#define STOR_AUTO     0x0000
#define STOR_STATIC   0x0002
#define STOR_LOCAL    0x0003
#define STOR_EXTERN   0x0007
#define STOR_INLINE   0x0008
#define STOR_REGISTER 0x0010
#define STOR_TYPEDEF  0x0018

#define QUAL_SHIFT         5
#define QUAL_MASK     0x00e0
#define QUAL_NONE     0x0000
#define QUAL_CONST    0x0020
#define QUAL_VOLATILE 0x0040
#define QUAL_RESTRICT 0x0080

#define TYPE_SHIFT         8
#define TYPE_MASK     0x1f00
#define TYPE_INTEGER(TYPE)    ((((TYPE) >= TYPE_CHAR) && ((TYPE) <= TYPE_ULLONG)) || ((TYPE) == TYPE_ENUM) || ((TYPE) == TYPE_BITFIELD))
#define TYPE_ARITHMETIC(TYPE) ((((TYPE) >= TYPE_CHAR) && ((TYPE) <= TYPE_LDOUBLE)) || ((TYPE) == TYPE_ENUM) || ((TYPE) == TYPE_BITFIELD))
#define TYPE_UNSIGNED(TYPE)   ((TYPE) & 0x0100)
#define TYPE_SIGNED(TYPE)     (!TYPE_UNSIGNED(TYPE))
#define TYPE_MKUNSIGNED(TYPE) (((TYPE) & ~0xF000) | 0x0100)
#define TYPE_RANK(TYPE)       ((TYPE) & ~0xF1FF)
#define TYPE_PTR(TYPE)        (((TYPE) & TYPE_MASK) == TYPE_POINTER)
#define TYPE_DEFAULT  0x0000
#define TYPE_VOID     0x0100
#define TYPE_CHAR     0x0200
#define TYPE_UCHAR    0x0300
#define TYPE_SHORT    0x0400
#define TYPE_USHORT   0x0500
#define TYPE_INT      0x0600
#define TYPE_UINT     0x0700
#define TYPE_LONG     0x0800
#define TYPE_ULONG    0x0900
#define TYPE_LLONG    0x0a00 /* long long */
#define TYPE_ULLONG   0x0b00
#define TYPE_FLOAT    0x0c00
#define TYPE_DOUBLE   0x0d00
#define TYPE_LDOUBLE  0x0e00 /* long double */

/* Note: TYPE_ENUM is chosen very carefully so TYPE_RANK works */
#define TYPE_ENUM     0x1600
#define TYPE_LIST     0x1700
/* TYPE_LIST is a basic building block when defining enumerations
 * type->field_ident holds the name of this enumeration entry.
 * type->right holds the entry in the list.
 */

#define TYPE_STRUCT   0x1000
/* For TYPE_STRUCT
 * type->left holds the link list of TYPE_PRODUCT entries that
 * make up the structure.
 * type->elements hold the length of the linked list
 */
#define TYPE_UNION    0x1100
/* For TYPE_UNION
 * type->left holds the link list of TYPE_OVERLAP entries that
 * make up the union.
 * type->elements hold the length of the linked list
 */
#define TYPE_POINTER  0x1200 
/* For TYPE_POINTER:
 * type->left holds the type pointed to.
 */
#define TYPE_FUNCTION 0x1300 
/* For TYPE_FUNCTION:
 * type->left holds the return type.
 * type->right holds the type of the arguments
 * type->elements holds the count of the arguments
 */
#define TYPE_PRODUCT  0x1400
/* TYPE_PRODUCT is a basic building block when defining structures
 * type->left holds the type that appears first in memory.
 * type->right holds the type that appears next in memory.
 */
#define TYPE_OVERLAP  0x1500
/* TYPE_OVERLAP is a basic building block when defining unions
 * type->left and type->right holds to types that overlap
 * each other in memory.
 */
#define TYPE_ARRAY    0x1800
/* TYPE_ARRAY is a basic building block when definitng arrays.
 * type->left holds the type we are an array of.
 * type->elements holds the number of elements.
 */
#define TYPE_TUPLE    0x1900
/* TYPE_TUPLE is a basic building block when defining 
 * positionally reference type conglomerations. (i.e. closures)
 * In essence it is a wrapper for TYPE_PRODUCT, like TYPE_STRUCT
 * except it has no field names.
 * type->left holds the liked list of TYPE_PRODUCT entries that
 * make up the closure type.
 * type->elements hold the number of elements in the closure.
 */
#define TYPE_JOIN     0x1a00
/* TYPE_JOIN is a basic building block when defining 
 * positionally reference type conglomerations. (i.e. closures)
 * In essence it is a wrapper for TYPE_OVERLAP, like TYPE_UNION
 * except it has no field names.
 * type->left holds the liked list of TYPE_OVERLAP entries that
 * make up the closure type.
 * type->elements hold the number of elements in the closure.
 */
#define TYPE_BITFIELD 0x1b00
/* TYPE_BITFIED is the type of a bitfield.
 * type->left holds the type basic type TYPE_BITFIELD is derived from.
 * type->elements holds the number of bits in the bitfield.
 */
#define TYPE_UNKNOWN  0x1c00
/* TYPE_UNKNOWN is the type of an unknown value.
 * Used on unknown consts and other places where I don't know the type.
 */

#define ATTRIB_SHIFT                 16
#define ATTRIB_MASK          0xffff0000
#define ATTRIB_NOINLINE      0x00010000
#define ATTRIB_ALWAYS_INLINE 0x00020000

#define ELEMENT_COUNT_UNSPECIFIED ULONG_T_MAX

struct type {
        unsigned int type;
        struct type *left, *right;
        ulong_t elements;
        struct hash_entry *field_ident;
        struct hash_entry *type_ident;
};

#define TEMPLATE_BITS      7
#define MAX_TEMPLATES      (1<<TEMPLATE_BITS)
#define MAX_REG_EQUIVS     16
#define MAX_REGC           14
#define MAX_REGISTERS      75
#define REGISTER_BITS      7
#define MAX_VIRT_REGISTERS (1<<REGISTER_BITS)
#define REG_ERROR          0
#define REG_UNSET          1
#define REG_UNNEEDED       2
#define REG_VIRT0          (MAX_REGISTERS + 0)
#define REG_VIRT1          (MAX_REGISTERS + 1)
#define REG_VIRT2          (MAX_REGISTERS + 2)
#define REG_VIRT3          (MAX_REGISTERS + 3)
#define REG_VIRT4          (MAX_REGISTERS + 4)
#define REG_VIRT5          (MAX_REGISTERS + 5)
#define REG_VIRT6          (MAX_REGISTERS + 6)
#define REG_VIRT7          (MAX_REGISTERS + 7)
#define REG_VIRT8          (MAX_REGISTERS + 8)
#define REG_VIRT9          (MAX_REGISTERS + 9)

#if (MAX_REGISTERS + 9) > MAX_VIRT_REGISTERS
#error "MAX_VIRT_REGISTERS to small"
#endif
#if (MAX_REGC + REGISTER_BITS) >= 26
#error "Too many id bits used"
#endif

/* Provision for 8 register classes */
#define REG_SHIFT  0
#define REGC_SHIFT REGISTER_BITS
#define REGC_MASK (((1 << MAX_REGC) - 1) << REGISTER_BITS)
#define REG_MASK (MAX_VIRT_REGISTERS -1)
#define ID_REG(ID)              ((ID) & REG_MASK)
#define SET_REG(ID, REG)        ((ID) = (((ID) & ~REG_MASK) | ((REG) & REG_MASK)))
#define ID_REGCM(ID)            (((ID) & REGC_MASK) >> REGC_SHIFT)
#define SET_REGCM(ID, REGCM)    ((ID) = (((ID) & ~REGC_MASK) | (((REGCM) << REGC_SHIFT) & REGC_MASK)))
#define SET_INFO(ID, INFO)      ((ID) = (((ID) & ~(REG_MASK | REGC_MASK)) | \
                (((INFO).reg) & REG_MASK) | ((((INFO).regcm) << REGC_SHIFT) & REGC_MASK)))

#define ARCH_INPUT_REGS 4
#define ARCH_OUTPUT_REGS 4

static const struct reg_info arch_input_regs[ARCH_INPUT_REGS];
static const struct reg_info arch_output_regs[ARCH_OUTPUT_REGS];
static unsigned arch_reg_regcm(struct compile_state *state, int reg);
static unsigned arch_regcm_normalize(struct compile_state *state, unsigned regcm);
static unsigned arch_regcm_reg_normalize(struct compile_state *state, unsigned regcm);
static void arch_reg_equivs(
        struct compile_state *state, unsigned *equiv, int reg);
static int arch_select_free_register(
        struct compile_state *state, char *used, int classes);
static unsigned arch_regc_size(struct compile_state *state, int class);
static int arch_regcm_intersect(unsigned regcm1, unsigned regcm2);
static unsigned arch_type_to_regcm(struct compile_state *state, struct type *type);
static const char *arch_reg_str(int reg);
static struct reg_info arch_reg_constraint(
        struct compile_state *state, struct type *type, const char *constraint);
static struct reg_info arch_reg_clobber(
        struct compile_state *state, const char *clobber);
static struct reg_info arch_reg_lhs(struct compile_state *state, 
        struct triple *ins, int index);
static struct reg_info arch_reg_rhs(struct compile_state *state, 
        struct triple *ins, int index);
static int arch_reg_size(int reg);
static struct triple *transform_to_arch_instruction(
        struct compile_state *state, struct triple *ins);
static struct triple *flatten(
        struct compile_state *state, struct triple *first, struct triple *ptr);
static void print_dominators(struct compile_state *state,
        FILE *fp, struct basic_blocks *bb);
static void print_dominance_frontiers(struct compile_state *state,
        FILE *fp, struct basic_blocks *bb);



#define DEBUG_ABORT_ON_ERROR    0x00000001
#define DEBUG_BASIC_BLOCKS      0x00000002
#define DEBUG_FDOMINATORS       0x00000004
#define DEBUG_RDOMINATORS       0x00000008
#define DEBUG_TRIPLES           0x00000010
#define DEBUG_INTERFERENCE      0x00000020
#define DEBUG_SCC_TRANSFORM     0x00000040
#define DEBUG_SCC_TRANSFORM2    0x00000080
#define DEBUG_REBUILD_SSA_FORM  0x00000100
#define DEBUG_INLINE            0x00000200
#define DEBUG_RANGE_CONFLICTS   0x00000400
#define DEBUG_RANGE_CONFLICTS2  0x00000800
#define DEBUG_COLOR_GRAPH       0x00001000
#define DEBUG_COLOR_GRAPH2      0x00002000
#define DEBUG_COALESCING        0x00004000
#define DEBUG_COALESCING2       0x00008000
#define DEBUG_VERIFICATION      0x00010000
#define DEBUG_CALLS             0x00020000
#define DEBUG_CALLS2            0x00040000
#define DEBUG_TOKENS            0x80000000

#define DEBUG_DEFAULT ( \
        DEBUG_ABORT_ON_ERROR | \
        DEBUG_BASIC_BLOCKS | \
        DEBUG_FDOMINATORS | \
        DEBUG_RDOMINATORS | \
        DEBUG_TRIPLES | \
        0 )

#define DEBUG_ALL ( \
        DEBUG_ABORT_ON_ERROR   | \
        DEBUG_BASIC_BLOCKS     | \
        DEBUG_FDOMINATORS      | \
        DEBUG_RDOMINATORS      | \
        DEBUG_TRIPLES          | \
        DEBUG_INTERFERENCE     | \
        DEBUG_SCC_TRANSFORM    | \
        DEBUG_SCC_TRANSFORM2   | \
        DEBUG_REBUILD_SSA_FORM | \
        DEBUG_INLINE           | \
        DEBUG_RANGE_CONFLICTS  | \
        DEBUG_RANGE_CONFLICTS2 | \
        DEBUG_COLOR_GRAPH      | \
        DEBUG_COLOR_GRAPH2     | \
        DEBUG_COALESCING       | \
        DEBUG_COALESCING2      | \
        DEBUG_VERIFICATION     | \
        DEBUG_CALLS            | \
        DEBUG_CALLS2           | \
        DEBUG_TOKENS           | \
        0 )

#define COMPILER_INLINE_MASK               0x00000007
#define COMPILER_INLINE_ALWAYS             0x00000000
#define COMPILER_INLINE_NEVER              0x00000001
#define COMPILER_INLINE_DEFAULTON          0x00000002
#define COMPILER_INLINE_DEFAULTOFF         0x00000003
#define COMPILER_INLINE_NOPENALTY          0x00000004
#define COMPILER_ELIMINATE_INEFECTUAL_CODE 0x00000008
#define COMPILER_SIMPLIFY                  0x00000010
#define COMPILER_SCC_TRANSFORM             0x00000020
#define COMPILER_SIMPLIFY_OP               0x00000040
#define COMPILER_SIMPLIFY_PHI              0x00000080
#define COMPILER_SIMPLIFY_LABEL            0x00000100
#define COMPILER_SIMPLIFY_BRANCH           0x00000200
#define COMPILER_SIMPLIFY_COPY             0x00000400
#define COMPILER_SIMPLIFY_ARITH            0x00000800
#define COMPILER_SIMPLIFY_SHIFT            0x00001000
#define COMPILER_SIMPLIFY_BITWISE          0x00002000
#define COMPILER_SIMPLIFY_LOGICAL          0x00004000
#define COMPILER_SIMPLIFY_BITFIELD         0x00008000

#define COMPILER_TRIGRAPHS                 0x40000000
#define COMPILER_PP_ONLY                   0x80000000

#define COMPILER_DEFAULT_FLAGS ( \
        COMPILER_TRIGRAPHS | \
        COMPILER_ELIMINATE_INEFECTUAL_CODE | \
        COMPILER_INLINE_DEFAULTON | \
        COMPILER_SIMPLIFY_OP | \
        COMPILER_SIMPLIFY_PHI | \
        COMPILER_SIMPLIFY_LABEL | \
        COMPILER_SIMPLIFY_BRANCH | \
        COMPILER_SIMPLIFY_COPY | \
        COMPILER_SIMPLIFY_ARITH | \
        COMPILER_SIMPLIFY_SHIFT | \
        COMPILER_SIMPLIFY_BITWISE | \
        COMPILER_SIMPLIFY_LOGICAL | \
        COMPILER_SIMPLIFY_BITFIELD | \
        0 )

#define GLOBAL_SCOPE_DEPTH   1
#define FUNCTION_SCOPE_DEPTH (GLOBAL_SCOPE_DEPTH + 1)

static void compile_file(struct compile_state *old_state, const char *filename, int local);



static void init_compiler_state(struct compiler_state *compiler)
{
        memset(compiler, 0, sizeof(*compiler));
        compiler->label_prefix = "";
        compiler->ofilename = "auto.inc";
        compiler->flags = COMPILER_DEFAULT_FLAGS;
        compiler->debug = 0;
        compiler->max_allocation_passes = MAX_ALLOCATION_PASSES;
        compiler->include_path_count = 1;
        compiler->include_paths      = xcmalloc(sizeof(char *), "include_paths");
        compiler->define_count       = 1;
        compiler->defines            = xcmalloc(sizeof(char *), "defines");
        compiler->undef_count        = 1;
        compiler->undefs             = xcmalloc(sizeof(char *), "undefs");
}

struct compiler_flag {
        const char *name;
        unsigned long flag;
};

struct compiler_arg {
        const char *name;
        unsigned long mask;
        struct compiler_flag flags[16];
};

static int set_flag(
        const struct compiler_flag *ptr, unsigned long *flags,
        int act, const char *flag)
{
        int result = -1;
        for(; ptr->name; ptr++) {
                if (strcmp(ptr->name, flag) == 0) {
                        break;
                }
        }
        if (ptr->name) {
                result = 0;
                *flags &= ~(ptr->flag);
                if (act) {
                        *flags |= ptr->flag;
                }
        }
        return result;
}

static int set_arg(
        const struct compiler_arg *ptr, unsigned long *flags, const char *arg)
{
        const char *val;
        int result = -1;
        int len;
        val = strchr(arg, '=');
        if (val) {
                len = val - arg;
                val++;
                for(; ptr->name; ptr++) {
                        if (strncmp(ptr->name, arg, len) == 0) {
                                break;
                        }
                }
                if (ptr->name) {
                        *flags &= ~ptr->mask;
                        result = set_flag(&ptr->flags[0], flags, 1, val);
                }
        }
        return result;
}
        

static void flag_usage(FILE *fp, const struct compiler_flag *ptr, 
        const char *prefix, const char *invert_prefix)
{
        for(;ptr->name; ptr++) {
                fprintf(fp, "%s%s\n", prefix, ptr->name);
                if (invert_prefix) {
                        fprintf(fp, "%s%s\n", invert_prefix, ptr->name);
                }
        }
}

static void arg_usage(FILE *fp, const struct compiler_arg *ptr,
        const char *prefix)
{
        for(;ptr->name; ptr++) {
                const struct compiler_flag *flag;
                for(flag = &ptr->flags[0]; flag->name; flag++) {
                        fprintf(fp, "%s%s=%s\n", 
                                prefix, ptr->name, flag->name);
                }
        }
}

static int append_string(size_t *max, const char ***vec, const char *str,
        const char *name)
{
        size_t count;
        count = ++(*max);
        *vec = xrealloc(*vec, sizeof(char *)*count, "name");
        (*vec)[count -1] = 0;
        (*vec)[count -2] = str; 
        return 0;
}

static void arg_error(char *fmt, ...);
static const char *identifier(const char *str, const char *end);

static int append_include_path(struct compiler_state *compiler, const char *str)
{
        int result;
        if (!exists(str, ".")) {
                arg_error("Nonexistent include path: `%s'\n",
                        str);
        }
        result = append_string(&compiler->include_path_count,
                &compiler->include_paths, str, "include_paths");
        return result;
}

static int append_define(struct compiler_state *compiler, const char *str)
{
        const char *end, *rest;
        int result;

        end = strchr(str, '=');
        if (!end) {
                end = str + strlen(str);
        }
        rest = identifier(str, end);
        if (rest != end) {
                int len = end - str - 1;
                arg_error("Invalid name cannot define macro: `%*.*s'\n", 
                        len, len, str);
        }
        result = append_string(&compiler->define_count,
                &compiler->defines, str, "defines");
        return result;
}

static int append_undef(struct compiler_state *compiler, const char *str)
{
        const char *end, *rest;
        int result;

        end = str + strlen(str);
        rest = identifier(str, end);
        if (rest != end) {
                int len = end - str - 1;
                arg_error("Invalid name cannot undefine macro: `%*.*s'\n", 
                        len, len, str);
        }
        result = append_string(&compiler->undef_count,
                &compiler->undefs, str, "undefs");
        return result;
}

static const struct compiler_flag romcc_flags[] = {
        { "trigraphs",                 COMPILER_TRIGRAPHS },
        { "pp-only",                   COMPILER_PP_ONLY },
        { "eliminate-inefectual-code", COMPILER_ELIMINATE_INEFECTUAL_CODE },
        { "simplify",                  COMPILER_SIMPLIFY },
        { "scc-transform",             COMPILER_SCC_TRANSFORM },
        { "simplify-op",               COMPILER_SIMPLIFY_OP },
        { "simplify-phi",              COMPILER_SIMPLIFY_PHI },
        { "simplify-label",            COMPILER_SIMPLIFY_LABEL },
        { "simplify-branch",           COMPILER_SIMPLIFY_BRANCH },
        { "simplify-copy",             COMPILER_SIMPLIFY_COPY },
        { "simplify-arith",            COMPILER_SIMPLIFY_ARITH },
        { "simplify-shift",            COMPILER_SIMPLIFY_SHIFT },
        { "simplify-bitwise",          COMPILER_SIMPLIFY_BITWISE },
        { "simplify-logical",          COMPILER_SIMPLIFY_LOGICAL },
        { "simplify-bitfield",         COMPILER_SIMPLIFY_BITFIELD },
        { 0, 0 },
};
static const struct compiler_arg romcc_args[] = {
        { "inline-policy",             COMPILER_INLINE_MASK,
                {
                        { "always",      COMPILER_INLINE_ALWAYS, },
                        { "never",       COMPILER_INLINE_NEVER, },
                        { "defaulton",   COMPILER_INLINE_DEFAULTON, },
                        { "defaultoff",  COMPILER_INLINE_DEFAULTOFF, },
                        { "nopenalty",   COMPILER_INLINE_NOPENALTY, },
                        { 0, 0 },
                },
        },
        { 0, 0 },
};
static const struct compiler_flag romcc_opt_flags[] = {
        { "-O",  COMPILER_SIMPLIFY },
        { "-O2", COMPILER_SIMPLIFY | COMPILER_SCC_TRANSFORM },
        { "-E",  COMPILER_PP_ONLY },
        { 0, 0, },
};
static const struct compiler_flag romcc_debug_flags[] = {
        { "all",                   DEBUG_ALL },
        { "abort-on-error",        DEBUG_ABORT_ON_ERROR },
        { "basic-blocks",          DEBUG_BASIC_BLOCKS },
        { "fdominators",           DEBUG_FDOMINATORS },
        { "rdominators",           DEBUG_RDOMINATORS },
        { "triples",               DEBUG_TRIPLES },
        { "interference",          DEBUG_INTERFERENCE },
        { "scc-transform",         DEBUG_SCC_TRANSFORM },
        { "scc-transform2",        DEBUG_SCC_TRANSFORM2 },
        { "rebuild-ssa-form",      DEBUG_REBUILD_SSA_FORM },
        { "inline",                DEBUG_INLINE },
        { "live-range-conflicts",  DEBUG_RANGE_CONFLICTS },
        { "live-range-conflicts2", DEBUG_RANGE_CONFLICTS2 },
        { "color-graph",           DEBUG_COLOR_GRAPH },
        { "color-graph2",          DEBUG_COLOR_GRAPH2 },
        { "coalescing",            DEBUG_COALESCING },
        { "coalescing2",           DEBUG_COALESCING2 },
        { "verification",          DEBUG_VERIFICATION },
        { "calls",                 DEBUG_CALLS },
        { "calls2",                DEBUG_CALLS2 },
        { "tokens",                DEBUG_TOKENS },
        { 0, 0 },
};

static int compiler_encode_flag(
        struct compiler_state *compiler, const char *flag)
{
        int act;
        int result;

        act = 1;
        result = -1;
        if (strncmp(flag, "no-", 3) == 0) {
                flag += 3;
                act = 0;
        }
        if (strncmp(flag, "-O", 2) == 0) {
                result = set_flag(romcc_opt_flags, &compiler->flags, act, flag);
        }
        else if (strncmp(flag, "-E", 2) == 0) {
                result = set_flag(romcc_opt_flags, &compiler->flags, act, flag);
        }
        else if (strncmp(flag, "-I", 2) == 0) {
                result = append_include_path(compiler, flag + 2);
        }
        else if (strncmp(flag, "-D", 2) == 0) {
                result = append_define(compiler, flag + 2);
        }
        else if (strncmp(flag, "-U", 2) == 0) {
                result = append_undef(compiler, flag + 2);
        }
        else if (act && strncmp(flag, "label-prefix=", 13) == 0) {
                result = 0;
                compiler->label_prefix = flag + 13;
        }
        else if (act && strncmp(flag, "max-allocation-passes=", 22) == 0) {
                unsigned long max_passes;
                char *end;
                max_passes = strtoul(flag + 22, &end, 10);
                if (end[0] == '\0') {
                        result = 0;
                        compiler->max_allocation_passes = max_passes;
                }
        }
        else if (act && strcmp(flag, "debug") == 0) {
                result = 0;
                compiler->debug |= DEBUG_DEFAULT;
        }
        else if (strncmp(flag, "debug-", 6) == 0) {
                flag += 6;
                result = set_flag(romcc_debug_flags, &compiler->debug, act, flag);
        }
        else {
                result = set_flag(romcc_flags, &compiler->flags, act, flag);
                if (result < 0) {
                        result = set_arg(romcc_args, &compiler->flags, flag);
                }
        }
        return result;
}

static void compiler_usage(FILE *fp)
{
        flag_usage(fp, romcc_opt_flags, "", 0);
        flag_usage(fp, romcc_flags, "-f", "-fno-");
        arg_usage(fp,  romcc_args, "-f");
        flag_usage(fp, romcc_debug_flags, "-fdebug-", "-fno-debug-");
        fprintf(fp, "-flabel-prefix=<prefix for assembly language labels>\n");
        fprintf(fp, "--label-prefix=<prefix for assembly language labels>\n");
        fprintf(fp, "-I<include path>\n");
        fprintf(fp, "-D<macro>[=defn]\n");
        fprintf(fp, "-U<macro>\n");
}

static void do_cleanup(struct compile_state *state)
{
        if (state->output) {
                fclose(state->output);
                unlink(state->compiler->ofilename);
                state->output = 0;
        }
        if (state->dbgout) {
                fflush(state->dbgout);
        }
        if (state->errout) {
                fflush(state->errout);
        }
}

static struct compile_state *exit_state;
static void exit_cleanup(void)
{
        if (exit_state) {
                do_cleanup(exit_state);
        }
}

static int get_col(struct file_state *file)
{
        int col;
        const char *ptr, *end;
        ptr = file->line_start;
        end = file->pos;
        for(col = 0; ptr < end; ptr++) {
                if (*ptr != '\t') {
                        col++;
                } 
                else {
                        col = (col & ~7) + 8;
                }
        }
        return col;
}

static void loc(FILE *fp, struct compile_state *state, struct triple *triple)
{
        int col;
        if (triple && triple->occurance) {
                struct occurance *spot;
                for(spot = triple->occurance; spot; spot = spot->parent) {
                        fprintf(fp, "%s:%d.%d: ", 
                                spot->filename, spot->line, spot->col);
                }
                return;
        }
        if (!state->file) {
                return;
        }
        col = get_col(state->file);
        fprintf(fp, "%s:%d.%d: ", 
                state->file->report_name, state->file->report_line, col);
}

static void internal_error(struct compile_state *state, struct triple *ptr, 
        const char *fmt, ...)
{
        FILE *fp = state->errout;
        va_list args;
        va_start(args, fmt);
        loc(fp, state, ptr);
        fputc('\n', fp);
        if (ptr) {
                fprintf(fp, "%p %-10s ", ptr, tops(ptr->op));
        }
        fprintf(fp, "Internal compiler error: ");
        vfprintf(fp, fmt, args);
        fprintf(fp, "\n");
        va_end(args);
        do_cleanup(state);
        abort();
}


static void internal_warning(struct compile_state *state, struct triple *ptr, 
        const char *fmt, ...)
{
        FILE *fp = state->errout;
        va_list args;
        va_start(args, fmt);
        loc(fp, state, ptr);
        if (ptr) {
                fprintf(fp, "%p %-10s ", ptr, tops(ptr->op));
        }
        fprintf(fp, "Internal compiler warning: ");
        vfprintf(fp, fmt, args);
        fprintf(fp, "\n");
        va_end(args);
}



static void error(struct compile_state *state, struct triple *ptr, 
        const char *fmt, ...)
{
        FILE *fp = state->errout;
        va_list args;
        va_start(args, fmt);
        loc(fp, state, ptr);
        fputc('\n', fp);
        if (ptr && (state->compiler->debug & DEBUG_ABORT_ON_ERROR)) {
                fprintf(fp, "%p %-10s ", ptr, tops(ptr->op));
        }
        vfprintf(fp, fmt, args);
        va_end(args);
        fprintf(fp, "\n");
        do_cleanup(state);
        if (state->compiler->debug & DEBUG_ABORT_ON_ERROR) {
                abort();
        }
        exit(1);
}

static void warning(struct compile_state *state, struct triple *ptr, 
        const char *fmt, ...)
{
        FILE *fp = state->errout;
        va_list args;
        va_start(args, fmt);
        loc(fp, state, ptr);
        fprintf(fp, "warning: "); 
        if (ptr && (state->compiler->debug & DEBUG_ABORT_ON_ERROR)) {
                fprintf(fp, "%p %-10s ", ptr, tops(ptr->op));
        }
        vfprintf(fp, fmt, args);
        fprintf(fp, "\n");
        va_end(args);
}

#define FINISHME() warning(state, 0, "FINISHME @ %s.%s:%d", __FILE__, __func__, __LINE__)

static void valid_op(struct compile_state *state, int op)
{
        char *fmt = "invalid op: %d";
        if (op >= OP_MAX) {
                internal_error(state, 0, fmt, op);
        }
        if (op < 0) {
                internal_error(state, 0, fmt, op);
        }
}

static void valid_ins(struct compile_state *state, struct triple *ptr)
{
        valid_op(state, ptr->op);
}

static void valid_param_count(struct compile_state *state, struct triple *ins)
{
        int lhs, rhs, misc, targ;
        valid_ins(state, ins);
        lhs  = table_ops[ins->op].lhs;
        rhs  = table_ops[ins->op].rhs;
        misc = table_ops[ins->op].misc;
        targ = table_ops[ins->op].targ;

        if ((lhs >= 0) && (ins->lhs != lhs)) {
                internal_error(state, ins, "Bad lhs count");
        }
        if ((rhs >= 0) && (ins->rhs != rhs)) {
                internal_error(state, ins, "Bad rhs count");
        }
        if ((misc >= 0) && (ins->misc != misc)) {
                internal_error(state, ins, "Bad misc count");
        }
        if ((targ >= 0) && (ins->targ != targ)) {
                internal_error(state, ins, "Bad targ count");
        }
}

static struct type void_type;
static struct type unknown_type;
static void use_triple(struct triple *used, struct triple *user)
{
        struct triple_set **ptr, *new;
        if (!used)
                return;
        if (!user)
                return;
        ptr = &used->use;
        while(*ptr) {
                if ((*ptr)->member == user) {
                        return;
                }
                ptr = &(*ptr)->next;
        }
        /* Append new to the head of the list, 
         * copy_func and rename_block_variables
         * depends on this.
         */
        new = xcmalloc(sizeof(*new), "triple_set");
        new->member = user;
        new->next   = used->use;
        used->use   = new;
}

static void unuse_triple(struct triple *used, struct triple *unuser)
{
        struct triple_set *use, **ptr;
        if (!used) {
                return;
        }
        ptr = &used->use;
        while(*ptr) {
                use = *ptr;
                if (use->member == unuser) {
                        *ptr = use->next;
                        xfree(use);
                }
                else {
                        ptr = &use->next;
                }
        }
}

static void put_occurance(struct occurance *occurance)
{
        if (occurance) {
                occurance->count -= 1;
                if (occurance->count <= 0) {
                        if (occurance->parent) {
                                put_occurance(occurance->parent);
                        }
                        xfree(occurance);
                }
        }
}

static void get_occurance(struct occurance *occurance)
{
        if (occurance) {
                occurance->count += 1;
        }
}


static struct occurance *new_occurance(struct compile_state *state)
{
        struct occurance *result, *last;
        const char *filename;
        const char *function;
        int line, col;

        function = "";
        filename = 0;
        line = 0;
        col  = 0;
        if (state->file) {
                filename = state->file->report_name;
                line     = state->file->report_line;
                col      = get_col(state->file);
        }
        if (state->function) {
                function = state->function;
        }
        last = state->last_occurance;
        if (last &&
                (last->col == col) &&
                (last->line == line) &&
                (last->function == function) &&
                ((last->filename == filename) ||
                        (strcmp(last->filename, filename) == 0))) 
        {
                get_occurance(last);
                return last;
        }
        if (last) {
                state->last_occurance = 0;
                put_occurance(last);
        }
        result = xmalloc(sizeof(*result), "occurance");
        result->count    = 2;
        result->filename = filename;
        result->function = function;
        result->line     = line;
        result->col      = col;
        result->parent   = 0;
        state->last_occurance = result;
        return result;
}

static struct occurance *inline_occurance(struct compile_state *state,
        struct occurance *base, struct occurance *top)
{
        struct occurance *result, *last;
        if (top->parent) {
                internal_error(state, 0, "inlining an already inlined function?");
        }
        /* If I have a null base treat it that way */
        if ((base->parent == 0) &&
                (base->col == 0) &&
                (base->line == 0) &&
                (base->function[0] == '\0') &&
                (base->filename[0] == '\0')) {
                base = 0;
        }
        /* See if I can reuse the last occurance I had */
        last = state->last_occurance;
        if (last &&
                (last->parent   == base) &&
                (last->col      == top->col) &&
                (last->line     == top->line) &&
                (last->function == top->function) &&
                (last->filename == top->filename)) {
                get_occurance(last);
                return last;
        }
        /* I can't reuse the last occurance so free it */
        if (last) {
                state->last_occurance = 0;
                put_occurance(last);
        }
        /* Generate a new occurance structure */
        get_occurance(base);
        result = xmalloc(sizeof(*result), "occurance");
        result->count    = 2;
        result->filename = top->filename;
        result->function = top->function;
        result->line     = top->line;
        result->col      = top->col;
        result->parent   = base;
        state->last_occurance = result;
        return result;
}

static struct occurance dummy_occurance = {
        .count    = 2,
        .filename = __FILE__,
        .function = "",
        .line     = __LINE__,
        .col      = 0,
        .parent   = 0,
};

/* The undef triple is used as a place holder when we are removing pointers
 * from a triple.  Having allows certain sanity checks to pass even
 * when the original triple that was pointed to is gone.
 */
static struct triple unknown_triple = {
        .next      = &unknown_triple,
        .prev      = &unknown_triple,
        .use       = 0,
        .op        = OP_UNKNOWNVAL,
        .lhs       = 0,
        .rhs       = 0,
        .misc      = 0,
        .targ      = 0,
        .type      = &unknown_type,
        .id        = -1, /* An invalid id */
        .u = { .cval = 0, },
        .occurance = &dummy_occurance,
        .param = { [0] = 0, [1] = 0, },
};


static size_t registers_of(struct compile_state *state, struct type *type);

static struct triple *alloc_triple(struct compile_state *state, 
        int op, struct type *type, int lhs_wanted, int rhs_wanted,
        struct occurance *occurance)
{
        size_t size, extra_count, min_count;
        int lhs, rhs, misc, targ;
        struct triple *ret, dummy;
        dummy.op = op;
        dummy.occurance = occurance;
        valid_op(state, op);
        lhs = table_ops[op].lhs;
        rhs = table_ops[op].rhs;
        misc = table_ops[op].misc;
        targ = table_ops[op].targ;

        switch(op) {
        case OP_FCALL:
                rhs = rhs_wanted;
                break;
        case OP_PHI:
                rhs = rhs_wanted;
                break;
        case OP_ADECL:
                lhs = registers_of(state, type);
                break;
        case OP_TUPLE:
                lhs = registers_of(state, type);
                break;
        case OP_ASM:
                rhs = rhs_wanted;
                lhs = lhs_wanted;
                break;
        }
        if ((rhs < 0) || (rhs > MAX_RHS)) {
                internal_error(state, &dummy, "bad rhs count %d", rhs);
        }
        if ((lhs < 0) || (lhs > MAX_LHS)) {
                internal_error(state, &dummy, "bad lhs count %d", lhs);
        }
        if ((misc < 0) || (misc > MAX_MISC)) {
                internal_error(state, &dummy, "bad misc count %d", misc);
        }
        if ((targ < 0) || (targ > MAX_TARG)) {
                internal_error(state, &dummy, "bad targs count %d", targ);
        }

        min_count = sizeof(ret->param)/sizeof(ret->param[0]);
        extra_count = lhs + rhs + misc + targ;
        extra_count = (extra_count < min_count)? 0 : extra_count - min_count;

        size = sizeof(*ret) + sizeof(ret->param[0]) * extra_count;
        ret = xcmalloc(size, "tripple");
        ret->op        = op;
        ret->lhs       = lhs;
        ret->rhs       = rhs;
        ret->misc      = misc;
        ret->targ      = targ;
        ret->type      = type;
        ret->next      = ret;
        ret->prev      = ret;
        ret->occurance = occurance;
        /* A simple sanity check */
        if ((ret->op != op) ||
                (ret->lhs != lhs) ||
                (ret->rhs != rhs) ||
                (ret->misc != misc) ||
                (ret->targ != targ) ||
                (ret->type != type) ||
                (ret->next != ret) ||
                (ret->prev != ret) ||
                (ret->occurance != occurance)) {
                internal_error(state, ret, "huh?");
        }
        return ret;
}

struct triple *dup_triple(struct compile_state *state, struct triple *src)
{
        struct triple *dup;
        int src_lhs, src_rhs, src_size;
        src_lhs = src->lhs;
        src_rhs = src->rhs;
        src_size = TRIPLE_SIZE(src);
        get_occurance(src->occurance);
        dup = alloc_triple(state, src->op, src->type, src_lhs, src_rhs,
                src->occurance);
        memcpy(dup, src, sizeof(*src));
        memcpy(dup->param, src->param, src_size * sizeof(src->param[0]));
        return dup;
}

static struct triple *copy_triple(struct compile_state *state, struct triple *src)
{
        struct triple *copy;
        copy = dup_triple(state, src);
        copy->use = 0;
        copy->next = copy->prev = copy;
        return copy;
}

static struct triple *new_triple(struct compile_state *state, 
        int op, struct type *type, int lhs, int rhs)
{
        struct triple *ret;
        struct occurance *occurance;
        occurance = new_occurance(state);
        ret = alloc_triple(state, op, type, lhs, rhs, occurance);
        return ret;
}

static struct triple *build_triple(struct compile_state *state, 
        int op, struct type *type, struct triple *left, struct triple *right,
        struct occurance *occurance)
{
        struct triple *ret;
        size_t count;
        ret = alloc_triple(state, op, type, -1, -1, occurance);
        count = TRIPLE_SIZE(ret);
        if (count > 0) {
                ret->param[0] = left;
        }
        if (count > 1) {
                ret->param[1] = right;
        }
        return ret;
}

static struct triple *triple(struct compile_state *state, 
        int op, struct type *type, struct triple *left, struct triple *right)
{
        struct triple *ret;
        size_t count;
        ret = new_triple(state, op, type, -1, -1);
        count = TRIPLE_SIZE(ret);
        if (count >= 1) {
                ret->param[0] = left;
        }
        if (count >= 2) {
                ret->param[1] = right;
        }
        return ret;
}

static struct triple *branch(struct compile_state *state, 
        struct triple *targ, struct triple *test)
{
        struct triple *ret;
        if (test) {
                ret = new_triple(state, OP_CBRANCH, &void_type, -1, 1);
                RHS(ret, 0) = test;
        } else {
                ret = new_triple(state, OP_BRANCH, &void_type, -1, 0);
        }
        TARG(ret, 0) = targ;
        /* record the branch target was used */
        if (!targ || (targ->op != OP_LABEL)) {
                internal_error(state, 0, "branch not to label");
        }
        return ret;
}

static int triple_is_label(struct compile_state *state, struct triple *ins);
static int triple_is_call(struct compile_state *state, struct triple *ins);
static int triple_is_cbranch(struct compile_state *state, struct triple *ins);
static void insert_triple(struct compile_state *state,
        struct triple *first, struct triple *ptr)
{
        if (ptr) {
                if ((ptr->id & TRIPLE_FLAG_FLATTENED) || (ptr->next != ptr)) {
                        internal_error(state, ptr, "expression already used");
                }
                ptr->next       = first;
                ptr->prev       = first->prev;
                ptr->prev->next = ptr;
                ptr->next->prev = ptr;

                if (triple_is_cbranch(state, ptr->prev) ||
                        triple_is_call(state, ptr->prev)) {
                        unuse_triple(first, ptr->prev);
                        use_triple(ptr, ptr->prev);
                }
        }
}

static int triple_stores_block(struct compile_state *state, struct triple *ins)
{
        /* This function is used to determine if u.block 
         * is utilized to store the current block number.
         */
        int stores_block;
        valid_ins(state, ins);
        stores_block = (table_ops[ins->op].flags & BLOCK) == BLOCK;
        return stores_block;
}

static int triple_is_branch(struct compile_state *state, struct triple *ins);
static struct block *block_of_triple(struct compile_state *state, 
        struct triple *ins)
{
        struct triple *first;
        if (!ins || ins == &unknown_triple) {
                return 0;
        }
        first = state->first;
        while(ins != first && !triple_is_branch(state, ins->prev) &&
                !triple_stores_block(state, ins)) 
        { 
                if (ins == ins->prev) {
                        internal_error(state, ins, "ins == ins->prev?");
                }
                ins = ins->prev;
        }
        return triple_stores_block(state, ins)? ins->u.block: 0;
}

static void generate_lhs_pieces(struct compile_state *state, struct triple *ins);
static struct triple *pre_triple(struct compile_state *state,
        struct triple *base,
        int op, struct type *type, struct triple *left, struct triple *right)
{
        struct block *block;
        struct triple *ret;
        int i;
        /* If I am an OP_PIECE jump to the real instruction */
        if (base->op == OP_PIECE) {
                base = MISC(base, 0);
        }
        block = block_of_triple(state, base);
        get_occurance(base->occurance);
        ret = build_triple(state, op, type, left, right, base->occurance);
        generate_lhs_pieces(state, ret);
        if (triple_stores_block(state, ret)) {
                ret->u.block = block;
        }
        insert_triple(state, base, ret);
        for(i = 0; i < ret->lhs; i++) {
                struct triple *piece;
                piece = LHS(ret, i);
                insert_triple(state, base, piece);
                use_triple(ret, piece);
                use_triple(piece, ret);
        }
        if (block && (block->first == base)) {
                block->first = ret;
        }
        return ret;
}

static struct triple *post_triple(struct compile_state *state,
        struct triple *base,
        int op, struct type *type, struct triple *left, struct triple *right)
{
        struct block *block;
        struct triple *ret, *next;
        int zlhs, i;
        /* If I am an OP_PIECE jump to the real instruction */
        if (base->op == OP_PIECE) {
                base = MISC(base, 0);
        }
        /* If I have a left hand side skip over it */
        zlhs = base->lhs;
        if (zlhs) {
                base = LHS(base, zlhs - 1);
        }

        block = block_of_triple(state, base);
        get_occurance(base->occurance);
        ret = build_triple(state, op, type, left, right, base->occurance);
        generate_lhs_pieces(state, ret);
        if (triple_stores_block(state, ret)) {
                ret->u.block = block;
        }
        next = base->next;
        insert_triple(state, next, ret);
        zlhs = ret->lhs;
        for(i = 0; i < zlhs; i++) {
                struct triple *piece;
                piece = LHS(ret, i);
                insert_triple(state, next, piece);
                use_triple(ret, piece);
                use_triple(piece, ret);
        }
        if (block && (block->last == base)) {
                block->last = ret;
                if (zlhs) {
                        block->last = LHS(ret, zlhs - 1);
                }
        }
        return ret;
}

static struct type *reg_type(
        struct compile_state *state, struct type *type, int reg);

static void generate_lhs_piece(
        struct compile_state *state, struct triple *ins, int index)
{
        struct type *piece_type;
        struct triple *piece;
        get_occurance(ins->occurance);
        piece_type = reg_type(state, ins->type, index * REG_SIZEOF_REG);

        if ((piece_type->type & TYPE_MASK) == TYPE_BITFIELD) {
                piece_type = piece_type->left;
        }
#if 0
{
        static void name_of(FILE *fp, struct type *type);
        FILE * fp = state->errout;
        fprintf(fp, "piece_type(%d): ", index);
        name_of(fp, piece_type);
        fprintf(fp, "\n");
}
#endif
        piece = alloc_triple(state, OP_PIECE, piece_type, -1, -1, ins->occurance);
        piece->u.cval  = index;
        LHS(ins, piece->u.cval) = piece;
        MISC(piece, 0) = ins;
}

static void generate_lhs_pieces(struct compile_state *state, struct triple *ins)
{
        int i, zlhs;
        zlhs = ins->lhs;
        for(i = 0; i < zlhs; i++) {
                generate_lhs_piece(state, ins, i);
        }
}

static struct triple *label(struct compile_state *state)
{
        /* Labels don't get a type */
        struct triple *result;
        result = triple(state, OP_LABEL, &void_type, 0, 0);
        return result;
}

static struct triple *mkprog(struct compile_state *state, ...)
{
        struct triple *prog, *head, *arg;
        va_list args;
        int i;

        head = label(state);
        prog = new_triple(state, OP_PROG, &void_type, -1, -1);
        RHS(prog, 0) = head;
        va_start(args, state);
        i = 0;
        while((arg = va_arg(args, struct triple *)) != 0) {
                if (++i >= 100) {
                        internal_error(state, 0, "too many arguments to mkprog");
                }
                flatten(state, head, arg);
        }
        va_end(args);
        prog->type = head->prev->type;
        return prog;
}
static void name_of(FILE *fp, struct type *type);
static void display_triple(FILE *fp, struct triple *ins)
{
        struct occurance *ptr;
        const char *reg;
        char pre, post, vol;
        pre = post = vol = ' ';
        if (ins) {
                if (ins->id & TRIPLE_FLAG_PRE_SPLIT) {
                        pre = '^';
                }
                if (ins->id & TRIPLE_FLAG_POST_SPLIT) {
                        post = ',';
                }
                if (ins->id & TRIPLE_FLAG_VOLATILE) {
                        vol = 'v';
                }
                reg = arch_reg_str(ID_REG(ins->id));
        }
        if (ins == 0) {
                fprintf(fp, "(%p) <nothing> ", ins);
        }
        else if (ins->op == OP_INTCONST) {
                fprintf(fp, "(%p) %c%c%c %-7s %-2d %-10s <0x%08lx>         ",
                        ins, pre, post, vol, reg, ins->template_id, tops(ins->op), 
                        (unsigned long)(ins->u.cval));
        }
        else if (ins->op == OP_ADDRCONST) {
                fprintf(fp, "(%p) %c%c%c %-7s %-2d %-10s %-10p <0x%08lx>",
                        ins, pre, post, vol, reg, ins->template_id, tops(ins->op), 
                        MISC(ins, 0), (unsigned long)(ins->u.cval));
        }
        else if (ins->op == OP_INDEX) {
                fprintf(fp, "(%p) %c%c%c %-7s %-2d %-10s %-10p <0x%08lx>",
                        ins, pre, post, vol, reg, ins->template_id, tops(ins->op), 
                        RHS(ins, 0), (unsigned long)(ins->u.cval));
        }
        else if (ins->op == OP_PIECE) {
                fprintf(fp, "(%p) %c%c%c %-7s %-2d %-10s %-10p <0x%08lx>",
                        ins, pre, post, vol, reg, ins->template_id, tops(ins->op), 
                        MISC(ins, 0), (unsigned long)(ins->u.cval));
        }
        else {
                int i, count;
                fprintf(fp, "(%p) %c%c%c %-7s %-2d %-10s", 
                        ins, pre, post, vol, reg, ins->template_id, tops(ins->op));
                if (table_ops[ins->op].flags & BITFIELD) {
                        fprintf(fp, " <%2d-%2d:%2d>", 
                                ins->u.bitfield.offset,
                                ins->u.bitfield.offset + ins->u.bitfield.size,
                                ins->u.bitfield.size);
                }
                count = TRIPLE_SIZE(ins);
                for(i = 0; i < count; i++) {
                        fprintf(fp, " %-10p", ins->param[i]);
                }
                for(; i < 2; i++) {
                        fprintf(fp, "           ");
                }
        }
        if (ins) {
                struct triple_set *user;
#if DEBUG_DISPLAY_TYPES
                fprintf(fp, " <");
                name_of(fp, ins->type);
                fprintf(fp, "> ");
#endif
#if DEBUG_DISPLAY_USES
                fprintf(fp, " [");
                for(user = ins->use; user; user = user->next) {
                        fprintf(fp, " %-10p", user->member);
                }
                fprintf(fp, " ]");
#endif
                fprintf(fp, " @");
                for(ptr = ins->occurance; ptr; ptr = ptr->parent) {
                        fprintf(fp, " %s,%s:%d.%d",
                                ptr->function, 
                                ptr->filename,
                                ptr->line, 
                                ptr->col);
                }
                if (ins->op == OP_ASM) {
                        fprintf(fp, "\n\t%s", ins->u.ainfo->str);
                }
        }
        fprintf(fp, "\n");
        fflush(fp);
}

static int equiv_types(struct type *left, struct type *right);
static void display_triple_changes(
        FILE *fp, const struct triple *new, const struct triple *orig)
{

        int new_count, orig_count;
        new_count = TRIPLE_SIZE(new);
        orig_count = TRIPLE_SIZE(orig);
        if ((new->op != orig->op) ||
                (new_count != orig_count) ||
                (memcmp(orig->param, new->param,        
                        orig_count * sizeof(orig->param[0])) != 0) ||
                (memcmp(&orig->u, &new->u, sizeof(orig->u)) != 0)) 
        {
                struct occurance *ptr;
                int i, min_count, indent;
                fprintf(fp, "(%p %p)", new, orig);
                if (orig->op == new->op) {
                        fprintf(fp, " %-11s", tops(orig->op));
                } else {
                        fprintf(fp, " [%-10s %-10s]", 
                                tops(new->op), tops(orig->op));
                }
                min_count = new_count;
                if (min_count > orig_count) {
                        min_count = orig_count;
                }
                for(indent = i = 0; i < min_count; i++) {
                        if (orig->param[i] == new->param[i]) {
                                fprintf(fp, " %-11p", 
                                        orig->param[i]);
                                indent += 12;
                        } else {
                                fprintf(fp, " [%-10p %-10p]",
                                        new->param[i], 
                                        orig->param[i]);
                                indent += 24;
                        }
                }
                for(; i < orig_count; i++) {
                        fprintf(fp, " [%-9p]", orig->param[i]);
                        indent += 12;
                }
                for(; i < new_count; i++) {
                        fprintf(fp, " [%-9p]", new->param[i]);
                        indent += 12;
                }
                if ((new->op == OP_INTCONST)||
                        (new->op == OP_ADDRCONST)) {
                        fprintf(fp, " <0x%08lx>", 
                                (unsigned long)(new->u.cval));
                        indent += 13;
                }
                for(;indent < 36; indent++) {
                        putc(' ', fp);
                }

#if DEBUG_DISPLAY_TYPES
                fprintf(fp, " <");
                name_of(fp, new->type);
                if (!equiv_types(new->type, orig->type)) {
                        fprintf(fp, " -- ");
                        name_of(fp, orig->type);
                }
                fprintf(fp, "> ");
#endif

                fprintf(fp, " @");
                for(ptr = orig->occurance; ptr; ptr = ptr->parent) {
                        fprintf(fp, " %s,%s:%d.%d",
                                ptr->function, 
                                ptr->filename,
                                ptr->line, 
                                ptr->col);
                        
                }
                fprintf(fp, "\n");
                fflush(fp);
        }
}

static int triple_is_pure(struct compile_state *state, struct triple *ins, unsigned id)
{
        /* Does the triple have no side effects.
         * I.e. Rexecuting the triple with the same arguments 
         * gives the same value.
         */
        unsigned pure;
        valid_ins(state, ins);
        pure = PURE_BITS(table_ops[ins->op].flags);
        if ((pure != PURE) && (pure != IMPURE)) {
                internal_error(state, 0, "Purity of %s not known",
                        tops(ins->op));
        }
        return (pure == PURE) && !(id & TRIPLE_FLAG_VOLATILE);
}

static int triple_is_branch_type(struct compile_state *state, 
        struct triple *ins, unsigned type)
{
        /* Is this one of the passed branch types? */
        valid_ins(state, ins);
        return (BRANCH_BITS(table_ops[ins->op].flags) == type);
}

static int triple_is_branch(struct compile_state *state, struct triple *ins)
{
        /* Is this triple a branch instruction? */
        valid_ins(state, ins);
        return (BRANCH_BITS(table_ops[ins->op].flags) != 0);
}

static int triple_is_cbranch(struct compile_state *state, struct triple *ins)
{
        /* Is this triple a conditional branch instruction? */
        return triple_is_branch_type(state, ins, CBRANCH);
}

static int triple_is_ubranch(struct compile_state *state, struct triple *ins)
{
        /* Is this triple a unconditional branch instruction? */
        unsigned type;
        valid_ins(state, ins);
        type = BRANCH_BITS(table_ops[ins->op].flags);
        return (type != 0) && (type != CBRANCH);
}

static int triple_is_call(struct compile_state *state, struct triple *ins)
{
        /* Is this triple a call instruction? */
        return triple_is_branch_type(state, ins, CALLBRANCH);
}

static int triple_is_ret(struct compile_state *state, struct triple *ins)
{
        /* Is this triple a return instruction? */
        return triple_is_branch_type(state, ins, RETBRANCH);
}

static int triple_is_simple_ubranch(struct compile_state *state, struct triple *ins)
{
        /* Is this triple an unconditional branch and not a call or a
         * return? */
        return triple_is_branch_type(state, ins, UBRANCH);
}

static int triple_is_end(struct compile_state *state, struct triple *ins)
{
        return triple_is_branch_type(state, ins, ENDBRANCH);
}

static int triple_is_label(struct compile_state *state, struct triple *ins)
{
        valid_ins(state, ins);
        return (ins->op == OP_LABEL);
}

static struct triple *triple_to_block_start(
        struct compile_state *state, struct triple *start)
{
        while(!triple_is_branch(state, start->prev) &&
                (!triple_is_label(state, start) || !start->use)) {
                start = start->prev;
        }
        return start;
}

static int triple_is_def(struct compile_state *state, struct triple *ins)
{
        /* This function is used to determine which triples need
         * a register.
         */
        int is_def;
        valid_ins(state, ins);
        is_def = (table_ops[ins->op].flags & DEF) == DEF;
        if (ins->lhs >= 1) {
                is_def = 0;
        }
        return is_def;
}

static int triple_is_structural(struct compile_state *state, struct triple *ins)
{
        int is_structural;
        valid_ins(state, ins);
        is_structural = (table_ops[ins->op].flags & STRUCTURAL) == STRUCTURAL;
        return is_structural;
}

static int triple_is_part(struct compile_state *state, struct triple *ins)
{
        int is_part;
        valid_ins(state, ins);
        is_part = (table_ops[ins->op].flags & PART) == PART;
        return is_part;
}

static int triple_is_auto_var(struct compile_state *state, struct triple *ins)
{
        return (ins->op == OP_PIECE) && (MISC(ins, 0)->op == OP_ADECL);
}

static struct triple **triple_iter(struct compile_state *state,
        size_t count, struct triple **vector,
        struct triple *ins, struct triple **last)
{
        struct triple **ret;
        ret = 0;
        if (count) {
                if (!last) {
                        ret = vector;
                }
                else if ((last >= vector) && (last < (vector + count - 1))) {
                        ret = last + 1;
                }
        }
        return ret;
        
}

static struct triple **triple_lhs(struct compile_state *state,
        struct triple *ins, struct triple **last)
{
        return triple_iter(state, ins->lhs, &LHS(ins,0), 
                ins, last);
}

static struct triple **triple_rhs(struct compile_state *state,
        struct triple *ins, struct triple **last)
{
        return triple_iter(state, ins->rhs, &RHS(ins,0), 
                ins, last);
}

static struct triple **triple_misc(struct compile_state *state,
        struct triple *ins, struct triple **last)
{
        return triple_iter(state, ins->misc, &MISC(ins,0), 
                ins, last);
}

static struct triple **do_triple_targ(struct compile_state *state,
        struct triple *ins, struct triple **last, int call_edges, int next_edges)
{
        size_t count;
        struct triple **ret, **vector;
        int next_is_targ;
        ret = 0;
        count = ins->targ;
        next_is_targ = 0;
        if (triple_is_cbranch(state, ins)) {
                next_is_targ = 1;
        }
        if (!call_edges && triple_is_call(state, ins)) {
                count = 0;
        }
        if (next_edges && triple_is_call(state, ins)) {
                next_is_targ = 1;
        }
        vector = &TARG(ins, 0);
        if (!ret && next_is_targ) {
                if (!last) {
                        ret = &ins->next;
                } else if (last == &ins->next) {
                        last = 0;
                }
        }
        if (!ret && count) {
                if (!last) {
                        ret = vector;
                }
                else if ((last >= vector) && (last < (vector + count - 1))) {
                        ret = last + 1;
                }
                else if (last == vector + count - 1) {
                        last = 0;
                }
        }
        if (!ret && triple_is_ret(state, ins) && call_edges) {
                struct triple_set *use;
                for(use = ins->use; use; use = use->next) {
                        if (!triple_is_call(state, use->member)) {
                                continue;
                        }
                        if (!last) {
                                ret = &use->member->next;
                                break;
                        }
                        else if (last == &use->member->next) {
                                last = 0;
                        }
                }
        }
        return ret;
}

static struct triple **triple_targ(struct compile_state *state,
        struct triple *ins, struct triple **last)
{
        return do_triple_targ(state, ins, last, 1, 1);
}

static struct triple **triple_edge_targ(struct compile_state *state,
        struct triple *ins, struct triple **last)
{
        return do_triple_targ(state, ins, last, 
                state->functions_joined, !state->functions_joined);
}

static struct triple *after_lhs(struct compile_state *state, struct triple *ins)
{
        struct triple *next;
        int lhs, i;
        lhs = ins->lhs;
        next = ins->next;
        for(i = 0; i < lhs; i++) {
                struct triple *piece;
                piece = LHS(ins, i);
                if (next != piece) {
                        internal_error(state, ins, "malformed lhs on %s",
                                tops(ins->op));
                }
                if (next->op != OP_PIECE) {
                        internal_error(state, ins, "bad lhs op %s at %d on %s",
                                tops(next->op), i, tops(ins->op));
                }
                if (next->u.cval != i) {
                        internal_error(state, ins, "bad u.cval of %d %d expected",
                                next->u.cval, i);
                }
                next = next->next;
        }
        return next;
}

/* Function piece accessor functions */
static struct triple *do_farg(struct compile_state *state, 
        struct triple *func, unsigned index)
{
        struct type *ftype;
        struct triple *first, *arg;
        unsigned i;

        ftype = func->type;
        if((index < 0) || (index >= (ftype->elements + 2))) {
                internal_error(state, func, "bad argument index: %d", index);
        }
        first = RHS(func, 0);
        arg = first->next;
        for(i = 0; i < index; i++, arg = after_lhs(state, arg)) {
                /* do nothing */
        }
        if (arg->op != OP_ADECL) {
                internal_error(state, 0, "arg not adecl?");
        }
        return arg;
}
static struct triple *fresult(struct compile_state *state, struct triple *func)
{
        return do_farg(state, func, 0);
}
static struct triple *fretaddr(struct compile_state *state, struct triple *func)
{
        return do_farg(state, func, 1);
}
static struct triple *farg(struct compile_state *state, 
        struct triple *func, unsigned index)
{
        return do_farg(state, func, index + 2);
}


static void display_func(struct compile_state *state, FILE *fp, struct triple *func)
{
        struct triple *first, *ins;
        fprintf(fp, "display_func %s\n", func->type->type_ident->name);
        first = ins = RHS(func, 0);
        do {
                if (triple_is_label(state, ins) && ins->use) {
                        fprintf(fp, "%p:\n", ins);
                }
                display_triple(fp, ins);

                if (triple_is_branch(state, ins)) {
                        fprintf(fp, "\n");
                }
                if (ins->next->prev != ins) {
                        internal_error(state, ins->next, "bad prev");
                }
                ins = ins->next;
        } while(ins != first);
}

static void verify_use(struct compile_state *state,
        struct triple *user, struct triple *used)
{
        int size, i;
        size = TRIPLE_SIZE(user);
        for(i = 0; i < size; i++) {
                if (user->param[i] == used) {
                        break;
                }
        }
        if (triple_is_branch(state, user)) {
                if (user->next == used) {
                        i = -1;
                }
        }
        if (i == size) {
                internal_error(state, user, "%s(%p) does not use %s(%p)",
                        tops(user->op), user, tops(used->op), used);
        }
}

static int find_rhs_use(struct compile_state *state, 
        struct triple *user, struct triple *used)
{
        struct triple **param;
        int size, i;
        verify_use(state, user, used);
#warning "AUDIT ME ->rhs"
        size = user->rhs;
        param = &RHS(user, 0);
        for(i = 0; i < size; i++) {
                if (param[i] == used) {
                        return i;
                }
        }
        return -1;
}

static void free_triple(struct compile_state *state, struct triple *ptr)
{
        size_t size;
        size = sizeof(*ptr) - sizeof(ptr->param) +
                (sizeof(ptr->param[0])*TRIPLE_SIZE(ptr));
        ptr->prev->next = ptr->next;
        ptr->next->prev = ptr->prev;
        if (ptr->use) {
                internal_error(state, ptr, "ptr->use != 0");
        }
        put_occurance(ptr->occurance);
        memset(ptr, -1, size);
        xfree(ptr);
}

static void release_triple(struct compile_state *state, struct triple *ptr)
{
        struct triple_set *set, *next;
        struct triple **expr;
        struct block *block;
        if (ptr == &unknown_triple) {
                return;
        }
        valid_ins(state, ptr);
        /* Make certain the we are not the first or last element of a block */
        block = block_of_triple(state, ptr);
        if (block) {
                if ((block->last == ptr) && (block->first == ptr)) {
                        block->last = block->first = 0;
                }
                else if (block->last == ptr) {
                        block->last = ptr->prev;
                }
                else if (block->first == ptr) {
                        block->first = ptr->next;
                }
        }
        /* Remove ptr from use chains where it is the user */
        expr = triple_rhs(state, ptr, 0);
        for(; expr; expr = triple_rhs(state, ptr, expr)) {
                if (*expr) {
                        unuse_triple(*expr, ptr);
                }
        }
        expr = triple_lhs(state, ptr, 0);
        for(; expr; expr = triple_lhs(state, ptr, expr)) {
                if (*expr) {
                        unuse_triple(*expr, ptr);
                }
        }
        expr = triple_misc(state, ptr, 0);
        for(; expr; expr = triple_misc(state, ptr, expr)) {
                if (*expr) {
                        unuse_triple(*expr, ptr);
                }
        }
        expr = triple_targ(state, ptr, 0);
        for(; expr; expr = triple_targ(state, ptr, expr)) {
                if (*expr){
                        unuse_triple(*expr, ptr);
                }
        }
        /* Reomve ptr from use chains where it is used */
        for(set = ptr->use; set; set = next) {
                next = set->next;
                valid_ins(state, set->member);
                expr = triple_rhs(state, set->member, 0);
                for(; expr; expr = triple_rhs(state, set->member, expr)) {
                        if (*expr == ptr) {
                                *expr = &unknown_triple;
                        }
                }
                expr = triple_lhs(state, set->member, 0);
                for(; expr; expr = triple_lhs(state, set->member, expr)) {
                        if (*expr == ptr) {
                                *expr = &unknown_triple;
                        }
                }
                expr = triple_misc(state, set->member, 0);
                for(; expr; expr = triple_misc(state, set->member, expr)) {
                        if (*expr == ptr) {
                                *expr = &unknown_triple;
                        }
                }
                expr = triple_targ(state, set->member, 0);
                for(; expr; expr = triple_targ(state, set->member, expr)) {
                        if (*expr == ptr) {
                                *expr = &unknown_triple;
                        }
                }
                unuse_triple(ptr, set->member);
        }
        free_triple(state, ptr);
}

static void print_triples(struct compile_state *state);
static void print_blocks(struct compile_state *state, const char *func, FILE *fp);

#define TOK_UNKNOWN       0
#define TOK_SPACE         1
#define TOK_SEMI          2
#define TOK_LBRACE        3
#define TOK_RBRACE        4
#define TOK_COMMA         5
#define TOK_EQ            6
#define TOK_COLON         7
#define TOK_LBRACKET      8
#define TOK_RBRACKET      9
#define TOK_LPAREN        10
#define TOK_RPAREN        11
#define TOK_STAR          12
#define TOK_DOTS          13
#define TOK_MORE          14
#define TOK_LESS          15
#define TOK_TIMESEQ       16
#define TOK_DIVEQ         17
#define TOK_MODEQ         18
#define TOK_PLUSEQ        19
#define TOK_MINUSEQ       20
#define TOK_SLEQ          21
#define TOK_SREQ          22
#define TOK_ANDEQ         23
#define TOK_XOREQ         24
#define TOK_OREQ          25
#define TOK_EQEQ          26
#define TOK_NOTEQ         27
#define TOK_QUEST         28
#define TOK_LOGOR         29
#define TOK_LOGAND        30
#define TOK_OR            31
#define TOK_AND           32
#define TOK_XOR           33
#define TOK_LESSEQ        34
#define TOK_MOREEQ        35
#define TOK_SL            36
#define TOK_SR            37
#define TOK_PLUS          38
#define TOK_MINUS         39
#define TOK_DIV           40
#define TOK_MOD           41
#define TOK_PLUSPLUS      42
#define TOK_MINUSMINUS    43
#define TOK_BANG          44
#define TOK_ARROW         45
#define TOK_DOT           46
#define TOK_TILDE         47
#define TOK_LIT_STRING    48
#define TOK_LIT_CHAR      49
#define TOK_LIT_INT       50
#define TOK_LIT_FLOAT     51
#define TOK_MACRO         52
#define TOK_CONCATENATE   53

#define TOK_IDENT         54
#define TOK_STRUCT_NAME   55
#define TOK_ENUM_CONST    56
#define TOK_TYPE_NAME     57

#define TOK_AUTO          58
#define TOK_BREAK         59
#define TOK_CASE          60
#define TOK_CHAR          61
#define TOK_CONST         62
#define TOK_CONTINUE      63
#define TOK_DEFAULT       64
#define TOK_DO            65
#define TOK_DOUBLE        66
#define TOK_ELSE          67
#define TOK_ENUM          68
#define TOK_EXTERN        69
#define TOK_FLOAT         70
#define TOK_FOR           71
#define TOK_GOTO          72
#define TOK_IF            73
#define TOK_INLINE        74
#define TOK_INT           75
#define TOK_LONG          76
#define TOK_REGISTER      77
#define TOK_RESTRICT      78
#define TOK_RETURN        79
#define TOK_SHORT         80
#define TOK_SIGNED        81
#define TOK_SIZEOF        82
#define TOK_STATIC        83
#define TOK_STRUCT        84
#define TOK_SWITCH        85
#define TOK_TYPEDEF       86
#define TOK_UNION         87
#define TOK_UNSIGNED      88
#define TOK_VOID          89
#define TOK_VOLATILE      90
#define TOK_WHILE         91
#define TOK_ASM           92
#define TOK_ATTRIBUTE     93
#define TOK_ALIGNOF       94
#define TOK_FIRST_KEYWORD TOK_AUTO
#define TOK_LAST_KEYWORD  TOK_ALIGNOF

#define TOK_MDEFINE       100
#define TOK_MDEFINED      101
#define TOK_MUNDEF        102
#define TOK_MINCLUDE      103
#define TOK_MLINE         104
#define TOK_MERROR        105
#define TOK_MWARNING      106
#define TOK_MPRAGMA       107
#define TOK_MIFDEF        108
#define TOK_MIFNDEF       109
#define TOK_MELIF         110
#define TOK_MENDIF        111

#define TOK_FIRST_MACRO   TOK_MDEFINE
#define TOK_LAST_MACRO    TOK_MENDIF
         
#define TOK_MIF           112
#define TOK_MELSE         113
#define TOK_MIDENT        114

#define TOK_EOL           115
#define TOK_EOF           116

static const char *tokens[] = {
[TOK_UNKNOWN     ] = ":unknown:",
[TOK_SPACE       ] = ":space:",
[TOK_SEMI        ] = ";",
[TOK_LBRACE      ] = "{",
[TOK_RBRACE      ] = "}",
[TOK_COMMA       ] = ",",
[TOK_EQ          ] = "=",
[TOK_COLON       ] = ":",
[TOK_LBRACKET    ] = "[",
[TOK_RBRACKET    ] = "]",
[TOK_LPAREN      ] = "(",
[TOK_RPAREN      ] = ")",
[TOK_STAR        ] = "*",
[TOK_DOTS        ] = "...",
[TOK_MORE        ] = ">",
[TOK_LESS        ] = "<",
[TOK_TIMESEQ     ] = "*=",
[TOK_DIVEQ       ] = "/=",
[TOK_MODEQ       ] = "%=",
[TOK_PLUSEQ      ] = "+=",
[TOK_MINUSEQ     ] = "-=",
[TOK_SLEQ        ] = "<<=",
[TOK_SREQ        ] = ">>=",
[TOK_ANDEQ       ] = "&=",
[TOK_XOREQ       ] = "^=",
[TOK_OREQ        ] = "|=",
[TOK_EQEQ        ] = "==",
[TOK_NOTEQ       ] = "!=",
[TOK_QUEST       ] = "?",
[TOK_LOGOR       ] = "||",
[TOK_LOGAND      ] = "&&",
[TOK_OR          ] = "|",
[TOK_AND         ] = "&",
[TOK_XOR         ] = "^",
[TOK_LESSEQ      ] = "<=",
[TOK_MOREEQ      ] = ">=",
[TOK_SL          ] = "<<",
[TOK_SR          ] = ">>",
[TOK_PLUS        ] = "+",
[TOK_MINUS       ] = "-",
[TOK_DIV         ] = "/",
[TOK_MOD         ] = "%",
[TOK_PLUSPLUS    ] = "++",
[TOK_MINUSMINUS  ] = "--",
[TOK_BANG        ] = "!",
[TOK_ARROW       ] = "->",
[TOK_DOT         ] = ".",
[TOK_TILDE       ] = "~",
[TOK_LIT_STRING  ] = ":string:",
[TOK_IDENT       ] = ":ident:",
[TOK_TYPE_NAME   ] = ":typename:",
[TOK_LIT_CHAR    ] = ":char:",
[TOK_LIT_INT     ] = ":integer:",
[TOK_LIT_FLOAT   ] = ":float:",
[TOK_MACRO       ] = "#",
[TOK_CONCATENATE ] = "##",

[TOK_AUTO        ] = "auto",
[TOK_BREAK       ] = "break",
[TOK_CASE        ] = "case",
[TOK_CHAR        ] = "char",
[TOK_CONST       ] = "const",
[TOK_CONTINUE    ] = "continue",
[TOK_DEFAULT     ] = "default",
[TOK_DO          ] = "do",
[TOK_DOUBLE      ] = "double",
[TOK_ELSE        ] = "else",
[TOK_ENUM        ] = "enum",
[TOK_EXTERN      ] = "extern",
[TOK_FLOAT       ] = "float",
[TOK_FOR         ] = "for",
[TOK_GOTO        ] = "goto",
[TOK_IF          ] = "if",
[TOK_INLINE      ] = "inline",
[TOK_INT         ] = "int",
[TOK_LONG        ] = "long",
[TOK_REGISTER    ] = "register",
[TOK_RESTRICT    ] = "restrict",
[TOK_RETURN      ] = "return",
[TOK_SHORT       ] = "short",
[TOK_SIGNED      ] = "signed",
[TOK_SIZEOF      ] = "sizeof",
[TOK_STATIC      ] = "static",
[TOK_STRUCT      ] = "struct",
[TOK_SWITCH      ] = "switch",
[TOK_TYPEDEF     ] = "typedef",
[TOK_UNION       ] = "union",
[TOK_UNSIGNED    ] = "unsigned",
[TOK_VOID        ] = "void",
[TOK_VOLATILE    ] = "volatile",
[TOK_WHILE       ] = "while",
[TOK_ASM         ] = "asm",
[TOK_ATTRIBUTE   ] = "__attribute__",
[TOK_ALIGNOF     ] = "__alignof__",

[TOK_MDEFINE     ] = "#define",
[TOK_MDEFINED    ] = "#defined",
[TOK_MUNDEF      ] = "#undef",
[TOK_MINCLUDE    ] = "#include",
[TOK_MLINE       ] = "#line",
[TOK_MERROR      ] = "#error",
[TOK_MWARNING    ] = "#warning",
[TOK_MPRAGMA     ] = "#pragma",
[TOK_MIFDEF      ] = "#ifdef",
[TOK_MIFNDEF     ] = "#ifndef",
[TOK_MELIF       ] = "#elif",
[TOK_MENDIF      ] = "#endif",

[TOK_MIF         ] = "#if",
[TOK_MELSE       ] = "#else",
[TOK_MIDENT      ] = "#:ident:",
[TOK_EOL         ] = "EOL", 
[TOK_EOF         ] = "EOF",
};

static unsigned int hash(const char *str, int str_len)
{
        unsigned int hash;
        const char *end;
        end = str + str_len;
        hash = 0;
        for(; str < end; str++) {
                hash = (hash *263) + *str;
        }
        hash = hash & (HASH_TABLE_SIZE -1);
        return hash;
}

static struct hash_entry *lookup(
        struct compile_state *state, const char *name, int name_len)
{
        struct hash_entry *entry;
        unsigned int index;
        index = hash(name, name_len);
        entry = state->hash_table[index];
        while(entry && 
                ((entry->name_len != name_len) ||
                        (memcmp(entry->name, name, name_len) != 0))) {
                entry = entry->next;
        }
        if (!entry) {
                char *new_name;
                /* Get a private copy of the name */
                new_name = xmalloc(name_len + 1, "hash_name");
                memcpy(new_name, name, name_len);
                new_name[name_len] = '\0';

                /* Create a new hash entry */
                entry = xcmalloc(sizeof(*entry), "hash_entry");
                entry->next = state->hash_table[index];
                entry->name = new_name;
                entry->name_len = name_len;

                /* Place the new entry in the hash table */
                state->hash_table[index] = entry;
        }
        return entry;
}

static void ident_to_keyword(struct compile_state *state, struct token *tk)
{
        struct hash_entry *entry;
        entry = tk->ident;
        if (entry && ((entry->tok == TOK_TYPE_NAME) ||
                (entry->tok == TOK_ENUM_CONST) ||
                ((entry->tok >= TOK_FIRST_KEYWORD) && 
                        (entry->tok <= TOK_LAST_KEYWORD)))) {
                tk->tok = entry->tok;
        }
}

static void ident_to_macro(struct compile_state *state, struct token *tk)
{
        struct hash_entry *entry;
        entry = tk->ident;
        if (!entry)
                return;
        if ((entry->tok >= TOK_FIRST_MACRO) && (entry->tok <= TOK_LAST_MACRO)) {
                tk->tok = entry->tok;
        }
        else if (entry->tok == TOK_IF) {
                tk->tok = TOK_MIF;
        }
        else if (entry->tok == TOK_ELSE) {
                tk->tok = TOK_MELSE;
        }
        else {
                tk->tok = TOK_MIDENT;
        }
}

static void hash_keyword(
        struct compile_state *state, const char *keyword, int tok)
{
        struct hash_entry *entry;
        entry = lookup(state, keyword, strlen(keyword));
        if (entry && entry->tok != TOK_UNKNOWN) {
                die("keyword %s already hashed", keyword);
        }
        entry->tok  = tok;
}

static void romcc_symbol(
        struct compile_state *state, struct hash_entry *ident,
        struct symbol **chain, struct triple *def, struct type *type, int depth)
{
        struct symbol *sym;
        if (*chain && ((*chain)->scope_depth >= depth)) {
                error(state, 0, "%s already defined", ident->name);
        }
        sym = xcmalloc(sizeof(*sym), "symbol");
        sym->ident = ident;
        sym->def   = def;
        sym->type  = type;
        sym->scope_depth = depth;
        sym->next = *chain;
        *chain    = sym;
}

static void symbol(
        struct compile_state *state, struct hash_entry *ident,
        struct symbol **chain, struct triple *def, struct type *type)
{
        romcc_symbol(state, ident, chain, def, type, state->scope_depth);
}

static void var_symbol(struct compile_state *state, 
        struct hash_entry *ident, struct triple *def)
{
        if ((def->type->type & TYPE_MASK) == TYPE_PRODUCT) {
                internal_error(state, 0, "bad var type");
        }
        symbol(state, ident, &ident->sym_ident, def, def->type);
}

static void label_symbol(struct compile_state *state, 
        struct hash_entry *ident, struct triple *label, int depth)
{
        romcc_symbol(state, ident, &ident->sym_label, label, &void_type, depth);
}

static void start_scope(struct compile_state *state)
{
        state->scope_depth++;
}

static void end_scope_syms(struct compile_state *state,
        struct symbol **chain, int depth)
{
        struct symbol *sym, *next;
        sym = *chain;
        while(sym && (sym->scope_depth == depth)) {
                next = sym->next;
                xfree(sym);
                sym = next;
        }
        *chain = sym;
}

static void end_scope(struct compile_state *state)
{
        int i;
        int depth;
        /* Walk through the hash table and remove all symbols
         * in the current scope. 
         */
        depth = state->scope_depth;
        for(i = 0; i < HASH_TABLE_SIZE; i++) {
                struct hash_entry *entry;
                entry = state->hash_table[i];
                while(entry) {
                        end_scope_syms(state, &entry->sym_label, depth);
                        end_scope_syms(state, &entry->sym_tag,   depth);
                        end_scope_syms(state, &entry->sym_ident, depth);
                        entry = entry->next;
                }
        }
        state->scope_depth = depth - 1;
}

static void register_keywords(struct compile_state *state)
{
        hash_keyword(state, "auto",          TOK_AUTO);
        hash_keyword(state, "break",         TOK_BREAK);
        hash_keyword(state, "case",          TOK_CASE);
        hash_keyword(state, "char",          TOK_CHAR);
        hash_keyword(state, "const",         TOK_CONST);
        hash_keyword(state, "continue",      TOK_CONTINUE);
        hash_keyword(state, "default",       TOK_DEFAULT);
        hash_keyword(state, "do",            TOK_DO);
        hash_keyword(state, "double",        TOK_DOUBLE);
        hash_keyword(state, "else",          TOK_ELSE);
        hash_keyword(state, "enum",          TOK_ENUM);
        hash_keyword(state, "extern",        TOK_EXTERN);
        hash_keyword(state, "float",         TOK_FLOAT);
        hash_keyword(state, "for",           TOK_FOR);
        hash_keyword(state, "goto",          TOK_GOTO);
        hash_keyword(state, "if",            TOK_IF);
        hash_keyword(state, "inline",        TOK_INLINE);
        hash_keyword(state, "int",           TOK_INT);
        hash_keyword(state, "long",          TOK_LONG);
        hash_keyword(state, "register",      TOK_REGISTER);
        hash_keyword(state, "restrict",      TOK_RESTRICT);
        hash_keyword(state, "return",        TOK_RETURN);
        hash_keyword(state, "short",         TOK_SHORT);
        hash_keyword(state, "signed",        TOK_SIGNED);
        hash_keyword(state, "sizeof",        TOK_SIZEOF);
        hash_keyword(state, "static",        TOK_STATIC);
        hash_keyword(state, "struct",        TOK_STRUCT);
        hash_keyword(state, "switch",        TOK_SWITCH);
        hash_keyword(state, "typedef",       TOK_TYPEDEF);
        hash_keyword(state, "union",         TOK_UNION);
        hash_keyword(state, "unsigned",      TOK_UNSIGNED);
        hash_keyword(state, "void",          TOK_VOID);
        hash_keyword(state, "volatile",      TOK_VOLATILE);
        hash_keyword(state, "__volatile__",  TOK_VOLATILE);
        hash_keyword(state, "while",         TOK_WHILE);
        hash_keyword(state, "asm",           TOK_ASM);
        hash_keyword(state, "__asm__",       TOK_ASM);
        hash_keyword(state, "__attribute__", TOK_ATTRIBUTE);
        hash_keyword(state, "__alignof__",   TOK_ALIGNOF);
}

static void register_macro_keywords(struct compile_state *state)
{
        hash_keyword(state, "define",        TOK_MDEFINE);
        hash_keyword(state, "defined",       TOK_MDEFINED);
        hash_keyword(state, "undef",         TOK_MUNDEF);
        hash_keyword(state, "include",       TOK_MINCLUDE);
        hash_keyword(state, "line",          TOK_MLINE);
        hash_keyword(state, "error",         TOK_MERROR);
        hash_keyword(state, "warning",       TOK_MWARNING);
        hash_keyword(state, "pragma",        TOK_MPRAGMA);
        hash_keyword(state, "ifdef",         TOK_MIFDEF);
        hash_keyword(state, "ifndef",        TOK_MIFNDEF);
        hash_keyword(state, "elif",          TOK_MELIF);
        hash_keyword(state, "endif",         TOK_MENDIF);
}


static void undef_macro(struct compile_state *state, struct hash_entry *ident)
{
        if (ident->sym_define != 0) {
                struct macro *macro;
                struct macro_arg *arg, *anext;
                macro = ident->sym_define;
                ident->sym_define = 0;
                
                /* Free the macro arguments... */
                anext = macro->args;
                while(anext) {
                        arg = anext;
                        anext = arg->next;
                        xfree(arg);
                }

                /* Free the macro buffer */
                xfree(macro->buf);

                /* Now free the macro itself */
                xfree(macro);
        }
}

static void do_define_macro(struct compile_state *state, 
        struct hash_entry *ident, const char *body, 
        int argc, struct macro_arg *args)
{
        struct macro *macro;
        struct macro_arg *arg;
        size_t body_len;

        /* Find the length of the body */
        body_len = strlen(body);
        macro = ident->sym_define;
        if (macro != 0) {
                int identical_bodies, identical_args;
                struct macro_arg *oarg;
                /* Explicitly allow identical redfinitions of the same macro */
                identical_bodies = 
                        (macro->buf_len == body_len) &&
                        (memcmp(macro->buf, body, body_len) == 0);
                identical_args = macro->argc == argc;
                oarg = macro->args;
                arg = args;
                while(identical_args && arg) {
                        identical_args = oarg->ident == arg->ident;
                        arg = arg->next;
                        oarg = oarg->next;
                }
                if (identical_bodies && identical_args) {
                        xfree(body);
                        return;
                }
                error(state, 0, "macro %s already defined\n", ident->name);
        }
#if 0
        fprintf(state->errout, "#define %s: `%*.*s'\n",
                ident->name, body_len, body_len, body);
#endif
        macro = xmalloc(sizeof(*macro), "macro");
        macro->ident   = ident;
        macro->buf     = body;
        macro->buf_len = body_len;
        macro->args    = args;
        macro->argc    = argc;

        ident->sym_define = macro;
}
        
static void define_macro(
        struct compile_state *state,
        struct hash_entry *ident,
        const char *body, int body_len,
        int argc, struct macro_arg *args)
{
        char *buf;
        buf = xmalloc(body_len + 1, "macro buf");
        memcpy(buf, body, body_len);
        buf[body_len] = '\0';
        do_define_macro(state, ident, buf, argc, args);
}

static void register_builtin_macro(struct compile_state *state,
        const char *name, const char *value)
{
        struct hash_entry *ident;

        if (value[0] == '(') {
                internal_error(state, 0, "Builtin macros with arguments not supported");
        }
        ident = lookup(state, name, strlen(name));
        define_macro(state, ident, value, strlen(value), -1, 0);
}

static void register_builtin_macros(struct compile_state *state)
{
        char buf[30];
        char scratch[30];
        time_t now;
        struct tm *tm;
        now = time(NULL);
        tm = localtime(&now);

        register_builtin_macro(state, "__ROMCC__", VERSION_MAJOR);
        register_builtin_macro(state, "__ROMCC_MINOR__", VERSION_MINOR);
        register_builtin_macro(state, "__FILE__", "\"This should be the filename\"");
        register_builtin_macro(state, "__LINE__", "54321");

        strftime(scratch, sizeof(scratch), "%b %e %Y", tm);
        sprintf(buf, "\"%s\"", scratch);
        register_builtin_macro(state, "__DATE__", buf);

        strftime(scratch, sizeof(scratch), "%H:%M:%S", tm);
        sprintf(buf, "\"%s\"", scratch);
        register_builtin_macro(state, "__TIME__", buf);

        /* I can't be a conforming implementation of C :( */
        register_builtin_macro(state, "__STDC__", "0");
        /* In particular I don't conform to C99 */
        register_builtin_macro(state, "__STDC_VERSION__", "199901L");
        
}

static void process_cmdline_macros(struct compile_state *state)
{
        const char **macro, *name;
        struct hash_entry *ident;
        for(macro = state->compiler->defines; (name = *macro); macro++) {
                const char *body;
                size_t name_len;

                name_len = strlen(name);
                body = strchr(name, '=');
                if (!body) {
                        body = "\0";
                } else {
                        name_len = body - name;
                        body++;
                }
                ident = lookup(state, name, name_len);
                define_macro(state, ident, body, strlen(body), -1, 0);
        }
        for(macro = state->compiler->undefs; (name = *macro); macro++) {
                ident = lookup(state, name, strlen(name));
                undef_macro(state, ident);
        }
}

static int spacep(int c)
{
        int ret = 0;
        switch(c) {
        case ' ':
        case '\t':
        case '\f':
        case '\v':
        case '\r':
                ret = 1;
                break;
        }
        return ret;
}

static int digitp(int c)
{
        int ret = 0;
        switch(c) {
        case '0': case '1': case '2': case '3': case '4': 
        case '5': case '6': case '7': case '8': case '9':
                ret = 1;
                break;
        }
        return ret;
}
static int digval(int c)
{
        int val = -1;
        if ((c >= '0') && (c <= '9')) {
                val = c - '0';
        }
        return val;
}

static int hexdigitp(int c)
{
        int ret = 0;
        switch(c) {
        case '0': case '1': case '2': case '3': case '4': 
        case '5': case '6': case '7': case '8': case '9':
        case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
        case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
                ret = 1;
                break;
        }
        return ret;
}
static int hexdigval(int c) 
{
        int val = -1;
        if ((c >= '0') && (c <= '9')) {
                val = c - '0';
        }
        else if ((c >= 'A') && (c <= 'F')) {
                val = 10 + (c - 'A');
        }
        else if ((c >= 'a') && (c <= 'f')) {
                val = 10 + (c - 'a');
        }
        return val;
}

static int octdigitp(int c)
{
        int ret = 0;
        switch(c) {
        case '0': case '1': case '2': case '3': 
        case '4': case '5': case '6': case '7':
                ret = 1;
                break;
        }
        return ret;
}
static int octdigval(int c)
{
        int val = -1;
        if ((c >= '0') && (c <= '7')) {
                val = c - '0';
        }
        return val;
}

static int letterp(int c)
{
        int ret = 0;
        switch(c) {
        case 'a': case 'b': case 'c': case 'd': case 'e':
        case 'f': case 'g': case 'h': case 'i': case 'j':
        case 'k': case 'l': case 'm': case 'n': case 'o':
        case 'p': case 'q': case 'r': case 's': case 't':
        case 'u': case 'v': case 'w': case 'x': case 'y':
        case 'z':
        case 'A': case 'B': case 'C': case 'D': case 'E':
        case 'F': case 'G': case 'H': case 'I': case 'J':
        case 'K': case 'L': case 'M': case 'N': case 'O':
        case 'P': case 'Q': case 'R': case 'S': case 'T':
        case 'U': case 'V': case 'W': case 'X': case 'Y':
        case 'Z':
        case '_':
                ret = 1;
                break;
        }
        return ret;
}

static const char *identifier(const char *str, const char *end)
{
        if (letterp(*str)) {
                for(; str < end; str++) {
                        int c;
                        c = *str;
                        if (!letterp(c) && !digitp(c)) {
                                break;
                        }
                }
        }
        return str;
}

static int char_value(struct compile_state *state,
        const signed char **strp, const signed char *end)
{
        const signed char *str;
        int c;
        str = *strp;
        c = *str++;
        if ((c == '\\') && (str < end)) {
                switch(*str) {
                case 'n':  c = '\n'; str++; break;
                case 't':  c = '\t'; str++; break;
                case 'v':  c = '\v'; str++; break;
                case 'b':  c = '\b'; str++; break;
                case 'r':  c = '\r'; str++; break;
                case 'f':  c = '\f'; str++; break;
                case 'a':  c = '\a'; str++; break;
                case '\\': c = '\\'; str++; break;
                case '?':  c = '?';  str++; break;
                case '\'': c = '\''; str++; break;
                case '"':  c = '"';  str++; break;
                case 'x': 
                        c = 0;
                        str++;
                        while((str < end) && hexdigitp(*str)) {
                                c <<= 4;
                                c += hexdigval(*str);
                                str++;
                        }
                        break;
                case '0': case '1': case '2': case '3': 
                case '4': case '5': case '6': case '7':
                        c = 0;
                        while((str < end) && octdigitp(*str)) {
                                c <<= 3;
                                c += octdigval(*str);
                                str++;
                        }
                        break;
                default:
                        error(state, 0, "Invalid character constant");
                        break;
                }
        }
        *strp = str;
        return c;
}

static const char *next_char(struct file_state *file, const char *pos, int index)
{
        const char *end = file->buf + file->size;
        while(pos < end) {
                /* Lookup the character */
                int size = 1;
                int c = *pos;
                /* Is this a trigraph? */
                if (file->trigraphs &&
                        (c == '?') && ((end - pos) >= 3) && (pos[1] == '?')) 
                {
                        switch(pos[2]) {
                        case '=': c = '#'; break;
                        case '/': c = '\\'; break;
                        case '\'': c = '^'; break;
                        case '(': c = '['; break;
                        case ')': c = ']'; break;
                        case '!': c = '!'; break;
                        case '<': c = '{'; break;
                        case '>': c = '}'; break;
                        case '-': c = '~'; break;
                        }
                        if (c != '?') {
                                size = 3;
                        }
                }
                /* Is this an escaped newline? */
                if (file->join_lines &&
                        (c == '\\') && (pos + size < end) && (pos[1] == '\n')) 
                {
                        /* At the start of a line just eat it */
                        if (pos == file->pos) {
                                file->line++;
                                file->report_line++;
                                file->line_start = pos + size + 1;
                        }
                        pos += size + 1;
                }
                /* Do I need to ga any farther? */
                else if (index == 0) {
                        break;
                }
                /* Process a normal character */
                else {
                        pos += size;
                        index -= 1;
                }
        }
        return pos;
}

static int get_char(struct file_state *file, const char *pos)
{
        const char *end = file->buf + file->size;
        int c;
        c = -1;
        pos = next_char(file, pos, 0);
        if (pos < end) {
                /* Lookup the character */
                c = *pos;
                /* If it is a trigraph get the trigraph value */
                if (file->trigraphs &&
                        (c == '?') && ((end - pos) >= 3) && (pos[1] == '?')) 
                {
                        switch(pos[2]) {
                        case '=': c = '#'; break;
                        case '/': c = '\\'; break;
                        case '\'': c = '^'; break;
                        case '(': c = '['; break;
                        case ')': c = ']'; break;
                        case '!': c = '!'; break;
                        case '<': c = '{'; break;
                        case '>': c = '}'; break;
                        case '-': c = '~'; break;
                        }
                }
        }
        return c;
}

static void eat_chars(struct file_state *file, const char *targ)
{
        const char *pos = file->pos;
        while(pos < targ) {
                /* Do we have a newline? */
                if (pos[0] == '\n') {
                        file->line++;
                        file->report_line++;
                        file->line_start = pos + 1;
                }
                pos++;
        }
        file->pos = pos;
}


static size_t char_strlen(struct file_state *file, const char *src, const char *end)
{
        size_t len;
        len = 0;
        while(src < end) {
                src = next_char(file, src, 1);
                len++;
        }
        return len;
}

static void char_strcpy(char *dest, 
        struct file_state *file, const char *src, const char *end)
{
        while(src < end) {
                int c;
                c = get_char(file, src);
                src = next_char(file, src, 1);
                *dest++ = c;
        }
}

static char *char_strdup(struct file_state *file, 
        const char *start, const char *end, const char *id)
{
        char *str;
        size_t str_len;
        str_len = char_strlen(file, start, end);
        str = xcmalloc(str_len + 1, id);
        char_strcpy(str, file, start, end);
        str[str_len] = '\0';
        return str;
}

static const char *after_digits(struct file_state *file, const char *ptr)
{
        while(digitp(get_char(file, ptr))) {
                ptr = next_char(file, ptr, 1);
        }
        return ptr;
}

static const char *after_octdigits(struct file_state *file, const char *ptr)
{
        while(octdigitp(get_char(file, ptr))) {
                ptr = next_char(file, ptr, 1);
        }
        return ptr;
}

static const char *after_hexdigits(struct file_state *file, const char *ptr)
{
        while(hexdigitp(get_char(file, ptr))) {
                ptr = next_char(file, ptr, 1);
        }
        return ptr;
}

static const char *after_alnums(struct file_state *file, const char *ptr)
{
        int c;
        c = get_char(file, ptr);
        while(letterp(c) || digitp(c)) {
                ptr = next_char(file, ptr, 1);
                c = get_char(file, ptr);
        }
        return ptr;
}

static void save_string(struct file_state *file,
        struct token *tk, const char *start, const char *end, const char *id)
{
        char *str;

        /* Create a private copy of the string */
        str = char_strdup(file, start, end, id);

        /* Store the copy in the token */
        tk->val.str = str;
        tk->str_len = strlen(str);
}

static void raw_next_token(struct compile_state *state, 
        struct file_state *file, struct token *tk)
{
        const char *token;
        int c, c1, c2, c3;
        const char *tokp;
        int eat;
        int tok;

        tk->str_len = 0;
        tk->ident = 0;
        token = tokp = next_char(file, file->pos, 0);
        tok = TOK_UNKNOWN;
        c  = get_char(file, tokp);
        tokp = next_char(file, tokp, 1);
        eat = 0;
        c1 = get_char(file, tokp);
        c2 = get_char(file, next_char(file, tokp, 1));
        c3 = get_char(file, next_char(file, tokp, 2));

        /* The end of the file */
        if (c == -1) {
                tok = TOK_EOF;
        }
        /* Whitespace */
        else if (spacep(c)) {
                tok = TOK_SPACE;
                while (spacep(get_char(file, tokp))) {
                        tokp = next_char(file, tokp, 1);
                }
        }
        /* EOL Comments */
        else if ((c == '/') && (c1 == '/')) {
                tok = TOK_SPACE;
                tokp = next_char(file, tokp, 1);
                while((c = get_char(file, tokp)) != -1) {
                        tokp = next_char(file, tokp, 1);
                        if (c == '\n') {
                                break;
                        }
                }
        }
        /* Comments */
        else if ((c == '/') && (c1 == '*')) {
                tokp = next_char(file, tokp, 2);
                c = c2;
                while((c1 = get_char(file, tokp)) != -1) {
                        tokp = next_char(file, tokp, 1);
                        if ((c == '*') && (c1 == '/')) {
                                tok = TOK_SPACE;
                                break;
                        }
                        c = c1;
                }
                if (tok == TOK_UNKNOWN) {
                        error(state, 0, "unterminated comment");
                }
        }
        /* string constants */
        else if ((c == '"') || ((c == 'L') && (c1 == '"'))) {
                int wchar, multiline;

                wchar = 0;
                multiline = 0;
                if (c == 'L') {
                        wchar = 1;
                        tokp = next_char(file, tokp, 1);
                }
                while((c = get_char(file, tokp)) != -1) {
                        tokp = next_char(file, tokp, 1);
                        if (c == '\n') {
                                multiline = 1;
                        }
                        else if (c == '\\') {
                                tokp = next_char(file, tokp, 1);
                        }
                        else if (c == '"') {
                                tok = TOK_LIT_STRING;
                                break;
                        }
                }
                if (tok == TOK_UNKNOWN) {
                        error(state, 0, "unterminated string constant");
                }
                if (multiline) {
                        warning(state, 0, "multiline string constant");
                }

                /* Save the string value */
                save_string(file, tk, token, tokp, "literal string");
        }
        /* character constants */
        else if ((c == '\'') || ((c == 'L') && (c1 == '\''))) {
                int wchar, multiline;

                wchar = 0;
                multiline = 0;
                if (c == 'L') {
                        wchar = 1;
                        tokp = next_char(file, tokp, 1);
                }
                while((c = get_char(file, tokp)) != -1) {
                        tokp = next_char(file, tokp, 1);
                        if (c == '\n') {
                                multiline = 1;
                        }
                        else if (c == '\\') {
                                tokp = next_char(file, tokp, 1);
                        }
                        else if (c == '\'') {
                                tok = TOK_LIT_CHAR;
                                break;
                        }
                }
                if (tok == TOK_UNKNOWN) {
                        error(state, 0, "unterminated character constant");
                }
                if (multiline) {
                        warning(state, 0, "multiline character constant");
                }

                /* Save the character value */
                save_string(file, tk, token, tokp, "literal character");
        }
        /* integer and floating constants 
         * Integer Constants
         * {digits}
         * 0[Xx]{hexdigits}
         * 0{octdigit}+
         * 
         * Floating constants
         * {digits}.{digits}[Ee][+-]?{digits}
         * {digits}.{digits}
         * {digits}[Ee][+-]?{digits}
         * .{digits}[Ee][+-]?{digits}
         * .{digits}
         */
        else if (digitp(c) || ((c == '.') && (digitp(c1)))) {
                const char *next;
                int is_float;
                int cn;
                is_float = 0;
                if (c != '.') {
                        next = after_digits(file, tokp);
                }
                else {
                        next = token;
                }
                cn = get_char(file, next);
                if (cn == '.') {
                        next = next_char(file, next, 1);
                        next = after_digits(file, next);
                        is_float = 1;
                }
                cn = get_char(file, next);
                if ((cn == 'e') || (cn == 'E')) {
                        const char *new;
                        next = next_char(file, next, 1);
                        cn = get_char(file, next);
                        if ((cn == '+') || (cn == '-')) {
                                next = next_char(file, next, 1);
                        }
                        new = after_digits(file, next);
                        is_float |= (new != next);
                        next = new;
                }
                if (is_float) {
                        tok = TOK_LIT_FLOAT;
                        cn = get_char(file, next);
                        if ((cn  == 'f') || (cn == 'F') || (cn == 'l') || (cn == 'L')) {
                                next = next_char(file, next, 1);
                        }
                }
                if (!is_float && digitp(c)) {
                        tok = TOK_LIT_INT;
                        if ((c == '0') && ((c1 == 'x') || (c1 == 'X'))) {
                                next = next_char(file, tokp, 1);
                                next = after_hexdigits(file, next);
                        }
                        else if (c == '0') {
                                next = after_octdigits(file, tokp);
                        }
                        else {
                                next = after_digits(file, tokp);
                        }
                        /* crazy integer suffixes */
                        cn = get_char(file, next);
                        if ((cn == 'u') || (cn == 'U')) {
                                next = next_char(file, next, 1);
                                cn = get_char(file, next);
                                if ((cn == 'l') || (cn == 'L')) {
                                        next = next_char(file, next, 1);
                                        cn = get_char(file, next);
                                }
                                if ((cn == 'l') || (cn == 'L')) {
                                        next = next_char(file, next, 1);
                                }
                        }
                        else if ((cn == 'l') || (cn == 'L')) {
                                next = next_char(file, next, 1);
                                cn = get_char(file, next);
                                if ((cn == 'l') || (cn == 'L')) {
                                        next = next_char(file, next, 1);
                                        cn = get_char(file, next);
                                }
                                if ((cn == 'u') || (cn == 'U')) {
                                        next = next_char(file, next, 1);
                                }
                        }
                }
                tokp = next;

                /* Save the integer/floating point value */
                save_string(file, tk, token, tokp, "literal number");
        }
        /* identifiers */
        else if (letterp(c)) {
                tok = TOK_IDENT;

                /* Find and save the identifier string */
                tokp = after_alnums(file, tokp);
                save_string(file, tk, token, tokp, "identifier");

                /* Look up to see which identifier it is */
                tk->ident = lookup(state, tk->val.str, tk->str_len);

                /* Free the identifier string */
                tk->str_len = 0;
                xfree(tk->val.str);

                /* See if this identifier can be macro expanded */
                tk->val.notmacro = 0;
                c = get_char(file, tokp);
                if (c == '$') {
                        tokp = next_char(file, tokp, 1);
                        tk->val.notmacro = 1;
                }
        }
        /* C99 alternate macro characters */
        else if ((c == '%') && (c1 == ':') && (c2 == '%') && (c3 == ':')) { 
                eat += 3;
                tok = TOK_CONCATENATE; 
        }
        else if ((c == '.') && (c1 == '.') && (c2 == '.')) { eat += 2; tok = TOK_DOTS; }
        else if ((c == '<') && (c1 == '<') && (c2 == '=')) { eat += 2; tok = TOK_SLEQ; }
        else if ((c == '>') && (c1 == '>') && (c2 == '=')) { eat += 2; tok = TOK_SREQ; }
        else if ((c == '*') && (c1 == '=')) { eat += 1; tok = TOK_TIMESEQ; }
        else if ((c == '/') && (c1 == '=')) { eat += 1; tok = TOK_DIVEQ; }
        else if ((c == '%') && (c1 == '=')) { eat += 1; tok = TOK_MODEQ; }
        else if ((c == '+') && (c1 == '=')) { eat += 1; tok = TOK_PLUSEQ; }
        else if ((c == '-') && (c1 == '=')) { eat += 1; tok = TOK_MINUSEQ; }
        else if ((c == '&') && (c1 == '=')) { eat += 1; tok = TOK_ANDEQ; }
        else if ((c == '^') && (c1 == '=')) { eat += 1; tok = TOK_XOREQ; }
        else if ((c == '|') && (c1 == '=')) { eat += 1; tok = TOK_OREQ; }
        else if ((c == '=') && (c1 == '=')) { eat += 1; tok = TOK_EQEQ; }
        else if ((c == '!') && (c1 == '=')) { eat += 1; tok = TOK_NOTEQ; }
        else if ((c == '|') && (c1 == '|')) { eat += 1; tok = TOK_LOGOR; }
        else if ((c == '&') && (c1 == '&')) { eat += 1; tok = TOK_LOGAND; }
        else if ((c == '<') && (c1 == '=')) { eat += 1; tok = TOK_LESSEQ; }
        else if ((c == '>') && (c1 == '=')) { eat += 1; tok = TOK_MOREEQ; }
        else if ((c == '<') && (c1 == '<')) { eat += 1; tok = TOK_SL; }
        else if ((c == '>') && (c1 == '>')) { eat += 1; tok = TOK_SR; }
        else if ((c == '+') && (c1 == '+')) { eat += 1; tok = TOK_PLUSPLUS; }
        else if ((c == '-') && (c1 == '-')) { eat += 1; tok = TOK_MINUSMINUS; }
        else if ((c == '-') && (c1 == '>')) { eat += 1; tok = TOK_ARROW; }
        else if ((c == '<') && (c1 == ':')) { eat += 1; tok = TOK_LBRACKET; }
        else if ((c == ':') && (c1 == '>')) { eat += 1; tok = TOK_RBRACKET; }
        else if ((c == '<') && (c1 == '%')) { eat += 1; tok = TOK_LBRACE; }
        else if ((c == '%') && (c1 == '>')) { eat += 1; tok = TOK_RBRACE; }
        else if ((c == '%') && (c1 == ':')) { eat += 1; tok = TOK_MACRO; }
        else if ((c == '#') && (c1 == '#')) { eat += 1; tok = TOK_CONCATENATE; }
        else if (c == ';') { tok = TOK_SEMI; }
        else if (c == '{') { tok = TOK_LBRACE; }
        else if (c == '}') { tok = TOK_RBRACE; }
        else if (c == ',') { tok = TOK_COMMA; }
        else if (c == '=') { tok = TOK_EQ; }
        else if (c == ':') { tok = TOK_COLON; }
        else if (c == '[') { tok = TOK_LBRACKET; }
        else if (c == ']') { tok = TOK_RBRACKET; }
        else if (c == '(') { tok = TOK_LPAREN; }
        else if (c == ')') { tok = TOK_RPAREN; }
        else if (c == '*') { tok = TOK_STAR; }
        else if (c == '>') { tok = TOK_MORE; }
        else if (c == '<') { tok = TOK_LESS; }
        else if (c == '?') { tok = TOK_QUEST; }
        else if (c == '|') { tok = TOK_OR; }
        else if (c == '&') { tok = TOK_AND; }
        else if (c == '^') { tok = TOK_XOR; }
        else if (c == '+') { tok = TOK_PLUS; }
        else if (c == '-') { tok = TOK_MINUS; }
        else if (c == '/') { tok = TOK_DIV; }
        else if (c == '%') { tok = TOK_MOD; }
        else if (c == '!') { tok = TOK_BANG; }
        else if (c == '.') { tok = TOK_DOT; }
        else if (c == '~') { tok = TOK_TILDE; }
        else if (c == '#') { tok = TOK_MACRO; }
        else if (c == '\n') { tok = TOK_EOL; }

        tokp = next_char(file, tokp, eat);
        eat_chars(file, tokp);
        tk->tok = tok;
        tk->pos = token;
}

static void check_tok(struct compile_state *state, struct token *tk, int tok)
{
        if (tk->tok != tok) {
                const char *name1, *name2;
                name1 = tokens[tk->tok];
                name2 = "";
                if ((tk->tok == TOK_IDENT) || (tk->tok == TOK_MIDENT)) {
                        name2 = tk->ident->name;
                }
                error(state, 0, "\tfound %s %s expected %s",
                        name1, name2, tokens[tok]);
        }
}

struct macro_arg_value {
        struct hash_entry *ident;
        unsigned char *value;
        size_t len;
};
static struct macro_arg_value *read_macro_args(
        struct compile_state *state, struct macro *macro, 
        struct file_state *file, struct token *tk)
{
        struct macro_arg_value *argv;
        struct macro_arg *arg;
        int paren_depth;
        int i;

        if (macro->argc == 0) {
                do {
                        raw_next_token(state, file, tk);
                } while(tk->tok == TOK_SPACE);
                return NULL;
        }
        argv = xcmalloc(sizeof(*argv) * macro->argc, "macro args");
        for(i = 0, arg = macro->args; arg; arg = arg->next, i++) {
                argv[i].value = 0;
                argv[i].len   = 0;
                argv[i].ident = arg->ident;
        }
        paren_depth = 0;
        i = 0;
        
        for(;;) {
                const char *start;
                size_t len;
                start = file->pos;
                raw_next_token(state, file, tk);
                
                if (!paren_depth && (tk->tok == TOK_COMMA) &&
                        (argv[i].ident != state->i___VA_ARGS__)) 
                {
                        i++;
                        if (i >= macro->argc) {
                                error(state, 0, "too many args to %s\n",
                                        macro->ident->name);
                        }
                        continue;
                }
                
                if (tk->tok == TOK_LPAREN) {
                        paren_depth++;
                }
                
                if (tk->tok == TOK_RPAREN) {
                        if (paren_depth == 0) {
                                break;
                        }
                        paren_depth--;
                }
                if (tk->tok == TOK_EOF) {
                        error(state, 0, "End of file encountered while parsing macro arguments");
                }

                len = char_strlen(file, start, file->pos);
                argv[i].value = xrealloc(
                        argv[i].value, argv[i].len + len, "macro args");
                char_strcpy(argv[i].value + argv[i].len, file, start, file->pos);
                argv[i].len += len;
        }
        if (i != macro->argc -1) {
                error(state, 0, "missing %s arg %d\n", 
                        macro->ident->name, i +2);
        }
        return argv;
}


static void free_macro_args(struct macro *macro, struct macro_arg_value *argv)
{
        int i;
        for(i = 0; i < macro->argc; i++) {
                xfree(argv[i].value);
        }
        xfree(argv);
}

struct macro_buf {
        char *str;
        size_t len, pos;
};

static void grow_macro_buf(struct compile_state *state,
        const char *id, struct macro_buf *buf,
        size_t grow)
{
        if ((buf->pos + grow) >= buf->len) {
                buf->str = xrealloc(buf->str, buf->len + grow, id);
                buf->len += grow;
        }
}

static void append_macro_text(struct compile_state *state,
        const char *id, struct macro_buf *buf,
        const char *fstart, size_t flen)
{
        grow_macro_buf(state, id, buf, flen);
        memcpy(buf->str + buf->pos, fstart, flen);
#if 0
        fprintf(state->errout, "append: `%*.*s' `%*.*s'\n",
                buf->pos, buf->pos, buf->str,
                flen, flen, buf->str + buf->pos);
#endif
        buf->pos += flen;
}


static void append_macro_chars(struct compile_state *state,
        const char *id, struct macro_buf *buf,
        struct file_state *file, const char *start, const char *end)
{
        size_t flen;
        flen = char_strlen(file, start, end);
        grow_macro_buf(state, id, buf, flen);
        char_strcpy(buf->str + buf->pos, file, start, end);
#if 0
        fprintf(state->errout, "append: `%*.*s' `%*.*s'\n",
                buf->pos, buf->pos, buf->str,
                flen, flen, buf->str + buf->pos);
#endif
        buf->pos += flen;
}

static int compile_macro(struct compile_state *state, 
        struct file_state **filep, struct token *tk);

static void macro_expand_args(struct compile_state *state, 
        struct macro *macro, struct macro_arg_value *argv, struct token *tk)
{
        int i;
        
        for(i = 0; i < macro->argc; i++) {
                struct file_state fmacro, *file;
                struct macro_buf buf;

                fmacro.prev        = 0;
                fmacro.basename    = argv[i].ident->name;
                fmacro.dirname     = "";
                fmacro.buf         = argv[i].value;
                fmacro.size        = argv[i].len;
                fmacro.pos         = fmacro.buf;
                fmacro.line        = 1;
                fmacro.line_start  = fmacro.buf;
                fmacro.report_line = 1;
                fmacro.report_name = fmacro.basename;
                fmacro.report_dir  = fmacro.dirname;
                fmacro.macro       = 1;
                fmacro.trigraphs   = 0;
                fmacro.join_lines  = 0;

                buf.len = argv[i].len;
                buf.str = xmalloc(buf.len, argv[i].ident->name);
                buf.pos = 0;

                file = &fmacro;
                for(;;) {
                        raw_next_token(state, file, tk);
                        
                        /* If we have recursed into another macro body
                         * get out of it.
                         */
                        if (tk->tok == TOK_EOF) {
                                struct file_state *old;
                                old = file;
                                file = file->prev;
                                if (!file) {
                                        break;
                                }
                                /* old->basename is used keep it */
                                xfree(old->dirname);
                                xfree(old->buf);
                                xfree(old);
                                continue;
                        }
                        else if (tk->ident && tk->ident->sym_define) {
                                if (compile_macro(state, &file, tk)) {
                                        continue;
                                }
                        }

                        append_macro_chars(state, macro->ident->name, &buf,
                                file, tk->pos, file->pos);
                }
                        
                xfree(argv[i].value);
                argv[i].value = buf.str;
                argv[i].len   = buf.pos;
        }
        return;
}

static void expand_macro(struct compile_state *state,
        struct macro *macro, struct macro_buf *buf,
        struct macro_arg_value *argv, struct token *tk)
{
        struct file_state fmacro;
        const char space[] = " ";
        const char *fstart;
        size_t flen;
        int i, j;

        /* Place the macro body in a dummy file */
        fmacro.prev        = 0;
        fmacro.basename    = macro->ident->name;
        fmacro.dirname     = "";
        fmacro.buf         = macro->buf;
        fmacro.size        = macro->buf_len;
        fmacro.pos         = fmacro.buf;
        fmacro.line        = 1;
        fmacro.line_start  = fmacro.buf;
        fmacro.report_line = 1;
        fmacro.report_name = fmacro.basename;
        fmacro.report_dir  = fmacro.dirname;
        fmacro.macro       = 1;
        fmacro.trigraphs   = 0;
        fmacro.join_lines  = 0;
        
        /* Allocate a buffer to hold the macro expansion */
        buf->len = macro->buf_len + 3;
        buf->str = xmalloc(buf->len, macro->ident->name);
        buf->pos = 0;
        
        fstart = fmacro.pos;
        raw_next_token(state, &fmacro, tk);
        while(tk->tok != TOK_EOF) {
                flen = fmacro.pos - fstart;
                switch(tk->tok) {
                case TOK_IDENT:
                        for(i = 0; i < macro->argc; i++) {
                                if (argv[i].ident == tk->ident) {
                                        break;
                                }
                        }
                        if (i >= macro->argc) {
                                break;
                        }
                        /* Substitute macro parameter */
                        fstart = argv[i].value;
                        flen   = argv[i].len;
                        break;
                case TOK_MACRO:
                        if (macro->argc < 0) {
                                break;
                        }
                        do {
                                raw_next_token(state, &fmacro, tk);
                        } while(tk->tok == TOK_SPACE);
                        check_tok(state, tk, TOK_IDENT);
                        for(i = 0; i < macro->argc; i++) {
                                if (argv[i].ident == tk->ident) {
                                        break;
                                }
                        }
                        if (i >= macro->argc) {
                                error(state, 0, "parameter `%s' not found",
                                        tk->ident->name);
                        }
                        /* Stringize token */
                        append_macro_text(state, macro->ident->name, buf, "\"", 1);
                        for(j = 0; j < argv[i].len; j++) {
                                char *str = argv[i].value + j;
                                size_t len = 1;
                                if (*str == '\\') {
                                        str = "\\";
                                        len = 2;
                                } 
                                else if (*str == '"') {
                                        str = "\\\"";
                                        len = 2;
                                }
                                append_macro_text(state, macro->ident->name, buf, str, len);
                        }
                        append_macro_text(state, macro->ident->name, buf, "\"", 1);
                        fstart = 0;
                        flen   = 0;
                        break;
                case TOK_CONCATENATE:
                        /* Concatenate tokens */
                        /* Delete the previous whitespace token */
                        if (buf->str[buf->pos - 1] == ' ') {
                                buf->pos -= 1;
                        }
                        /* Skip the next sequence of whitspace tokens */
                        do {
                                fstart = fmacro.pos;
                                raw_next_token(state, &fmacro, tk);
                        } while(tk->tok == TOK_SPACE);
                        /* Restart at the top of the loop.
                         * I need to process the non white space token.
                         */
                        continue;
                        break;
                case TOK_SPACE:
                        /* Collapse multiple spaces into one */
                        if (buf->str[buf->pos - 1] != ' ') {
                                fstart = space;
                                flen   = 1;
                        } else {
                                fstart = 0;
                                flen   = 0;
                        }
                        break;
                default:
                        break;
                }

                append_macro_text(state, macro->ident->name, buf, fstart, flen);
                
                fstart = fmacro.pos;
                raw_next_token(state, &fmacro, tk);
        }
}

static void tag_macro_name(struct compile_state *state,
        struct macro *macro, struct macro_buf *buf,
        struct token *tk)
{
        /* Guard all instances of the macro name in the replacement
         * text from further macro expansion.
         */
        struct file_state fmacro;
        const char *fstart;
        size_t flen;

        /* Put the old macro expansion buffer in a file */
        fmacro.prev        = 0;
        fmacro.basename    = macro->ident->name;
        fmacro.dirname     = "";
        fmacro.buf         = buf->str;
        fmacro.size        = buf->pos;
        fmacro.pos         = fmacro.buf;
        fmacro.line        = 1;
        fmacro.line_start  = fmacro.buf;
        fmacro.report_line = 1;
        fmacro.report_name = fmacro.basename;
        fmacro.report_dir  = fmacro.dirname;
        fmacro.macro       = 1;
        fmacro.trigraphs   = 0;
        fmacro.join_lines  = 0;
        
        /* Allocate a new macro expansion buffer */
        buf->len = macro->buf_len + 3;
        buf->str = xmalloc(buf->len, macro->ident->name);
        buf->pos = 0;
        
        fstart = fmacro.pos;
        raw_next_token(state, &fmacro, tk);
        while(tk->tok != TOK_EOF) {
                flen = fmacro.pos - fstart;
                if ((tk->tok == TOK_IDENT) &&
                        (tk->ident == macro->ident) &&
                        (tk->val.notmacro == 0)) 
                {
                        append_macro_text(state, macro->ident->name, buf, fstart, flen);
                        fstart = "$";
                        flen   = 1;
                }

                append_macro_text(state, macro->ident->name, buf, fstart, flen);
                
                fstart = fmacro.pos;
                raw_next_token(state, &fmacro, tk);
        }
        xfree(fmacro.buf);
}

static int compile_macro(struct compile_state *state, 
        struct file_state **filep, struct token *tk)
{
        struct file_state *file;
        struct hash_entry *ident;
        struct macro *macro;
        struct macro_arg_value *argv;
        struct macro_buf buf;

#if 0
        fprintf(state->errout, "macro: %s\n", tk->ident->name);
#endif
        ident = tk->ident;
        macro = ident->sym_define;

        /* If this token comes from a macro expansion ignore it */
        if (tk->val.notmacro) {
                return 0;
        }
        /* If I am a function like macro and the identifier is not followed
         * by a left parenthesis, do nothing.
         */
        if ((macro->argc >= 0) && (get_char(*filep, (*filep)->pos) != '(')) {
                return 0;
        }

        /* Read in the macro arguments */
        argv = 0;
        if (macro->argc >= 0) {
                raw_next_token(state, *filep, tk);
                check_tok(state, tk, TOK_LPAREN);

                argv = read_macro_args(state, macro, *filep, tk);

                check_tok(state, tk, TOK_RPAREN);
        }
        /* Macro expand the macro arguments */
        macro_expand_args(state, macro, argv, tk);

        buf.str = 0;
        buf.len = 0;
        buf.pos = 0;
        if (ident == state->i___FILE__) {
                buf.len = strlen(state->file->basename) + 1 + 2 + 3;
                buf.str = xmalloc(buf.len, ident->name);
                sprintf(buf.str, "\"%s\"", state->file->basename);
                buf.pos = strlen(buf.str);
        }
        else if (ident == state->i___LINE__) {
                buf.len = 30;
                buf.str = xmalloc(buf.len, ident->name);
                sprintf(buf.str, "%d", state->file->line);
                buf.pos = strlen(buf.str);
        }
        else {
                expand_macro(state, macro, &buf, argv, tk);
        }
        /* Tag the macro name with a $ so it will no longer
         * be regonized as a canidate for macro expansion.
         */
        tag_macro_name(state, macro, &buf, tk);

#if 0
        fprintf(state->errout, "%s: %d -> `%*.*s'\n",
                ident->name, buf.pos, buf.pos, (int)(buf.pos), buf.str);
#endif

        free_macro_args(macro, argv);

        file = xmalloc(sizeof(*file), "file_state");
        file->prev        = *filep;
        file->basename    = xstrdup(ident->name);
        file->dirname     = xstrdup("");
        file->buf         = buf.str;
        file->size        = buf.pos;
        file->pos         = file->buf;
        file->line        = 1;
        file->line_start  = file->pos;
        file->report_line = 1;
        file->report_name = file->basename;
        file->report_dir  = file->dirname;
        file->macro       = 1;
        file->trigraphs   = 0;
        file->join_lines  = 0;
        *filep = file;
        return 1;
}

static void eat_tokens(struct compile_state *state, int targ_tok)
{
        if (state->eat_depth > 0) {
                internal_error(state, 0, "Already eating...");
        }
        state->eat_depth = state->if_depth;
        state->eat_targ = targ_tok;
}
static int if_eat(struct compile_state *state)
{
        return state->eat_depth > 0;
}
static int if_value(struct compile_state *state)
{
        int index, offset;
        index = state->if_depth / CHAR_BIT;
        offset = state->if_depth % CHAR_BIT;
        return !!(state->if_bytes[index] & (1 << (offset)));
}
static void set_if_value(struct compile_state *state, int value) 
{
        int index, offset;
        index = state->if_depth / CHAR_BIT;
        offset = state->if_depth % CHAR_BIT;

        state->if_bytes[index] &= ~(1 << offset);
        if (value) {
                state->if_bytes[index] |= (1 << offset);
        }
}
static void in_if(struct compile_state *state, const char *name)
{
        if (state->if_depth <= 0) {
                error(state, 0, "%s without #if", name);
        }
}
static void enter_if(struct compile_state *state)
{
        state->if_depth += 1;
        if (state->if_depth > MAX_PP_IF_DEPTH) {
                error(state, 0, "#if depth too great");
        }
}
static void reenter_if(struct compile_state *state, const char *name)
{
        in_if(state, name);
        if ((state->eat_depth == state->if_depth) &&
                (state->eat_targ == TOK_MELSE)) {
                state->eat_depth = 0;
                state->eat_targ = 0;
        }
}
static void enter_else(struct compile_state *state, const char *name)
{
        in_if(state, name);
        if ((state->eat_depth == state->if_depth) &&
                (state->eat_targ == TOK_MELSE)) {
                state->eat_depth = 0;
                state->eat_targ = 0;
        }
}
static void exit_if(struct compile_state *state, const char *name)
{
        in_if(state, name);
        if (state->eat_depth == state->if_depth) {
                state->eat_depth = 0;
                state->eat_targ = 0;
        }
        state->if_depth -= 1;
}

static void raw_token(struct compile_state *state, struct token *tk)
{
        struct file_state *file;
        int rescan;

        file = state->file;
        raw_next_token(state, file, tk);
        do {
                rescan = 0;
                file = state->file;
                /* Exit out of an include directive or macro call */
                if ((tk->tok == TOK_EOF) && 
                        (file != state->macro_file) && file->prev) 
                {
                        state->file = file->prev;
                        /* file->basename is used keep it */
                        xfree(file->dirname);
                        xfree(file->buf);
                        xfree(file);
                        file = 0;
                        raw_next_token(state, state->file, tk);
                        rescan = 1;
                }
        } while(rescan);
}

static void pp_token(struct compile_state *state, struct token *tk)
{
        struct file_state *file;
        int rescan;

        raw_token(state, tk);
        do {
                rescan = 0;
                file = state->file;
                if (tk->tok == TOK_SPACE) {
                        raw_token(state, tk);
                        rescan = 1;
                }
                else if (tk->tok == TOK_IDENT) {
                        if (state->token_base == 0) {
                                ident_to_keyword(state, tk);
                        } else {
                                ident_to_macro(state, tk);
                        }
                }
        } while(rescan);
}

static void preprocess(struct compile_state *state, struct token *tk);

static void token(struct compile_state *state, struct token *tk)
{
        int rescan;
        pp_token(state, tk);
        do {
                rescan = 0;
                /* Process a macro directive */
                if (tk->tok == TOK_MACRO) {
                        /* Only match preprocessor directives at the start of a line */
                        const char *ptr;
                        ptr = state->file->line_start;
                        while((ptr < tk->pos)
                                && spacep(get_char(state->file, ptr)))
                        {
                                ptr = next_char(state->file, ptr, 1);
                        }
                        if (ptr == tk->pos) {
                                preprocess(state, tk);
                                rescan = 1;
                        }
                }
                /* Expand a macro call */
                else if (tk->ident && tk->ident->sym_define) {
                        rescan = compile_macro(state, &state->file, tk);
                        if (rescan) {
                                pp_token(state, tk);
                        }
                }
                /* Eat tokens disabled by the preprocessor 
                 * (Unless we are parsing a preprocessor directive 
                 */
                else if (if_eat(state) && (state->token_base == 0)) {
                        pp_token(state, tk);
                        rescan = 1;
                }
                /* Make certain EOL only shows up in preprocessor directives */
                else if ((tk->tok == TOK_EOL) && (state->token_base == 0)) {
                        pp_token(state, tk);
                        rescan = 1;
                }
                /* Error on unknown tokens */
                else if (tk->tok == TOK_UNKNOWN) {
                        error(state, 0, "unknown token");
                }
        } while(rescan);
}


static inline struct token *get_token(struct compile_state *state, int offset)
{
        int index;
        index = state->token_base + offset;
        if (index >= sizeof(state->token)/sizeof(state->token[0])) {
                internal_error(state, 0, "token array to small");
        }
        return &state->token[index];
}

static struct token *do_eat_token(struct compile_state *state, int tok)
{
        struct token *tk;
        int i;
        check_tok(state, get_token(state, 1), tok);
        
        /* Free the old token value */
        tk = get_token(state, 0);
        if (tk->str_len) {
                memset((void *)tk->val.str, -1, tk->str_len);
                xfree(tk->val.str);
        }
        /* Overwrite the old token with newer tokens */
        for(i = state->token_base; i < sizeof(state->token)/sizeof(state->token[0]) - 1; i++) {
                state->token[i] = state->token[i + 1];
        }
        /* Clear the last token */
        memset(&state->token[i], 0, sizeof(state->token[i]));
        state->token[i].tok = -1;

        /* Return the token */
        return tk;
}

static int raw_peek(struct compile_state *state)
{
        struct token *tk1;
        tk1 = get_token(state, 1);
        if (tk1->tok == -1) {
                raw_token(state, tk1);
        }
        return tk1->tok;
}

static struct token *raw_eat(struct compile_state *state, int tok)
{
        raw_peek(state);
        return do_eat_token(state, tok);
}

static int pp_peek(struct compile_state *state)
{
        struct token *tk1;
        tk1 = get_token(state, 1);
        if (tk1->tok == -1) {
                pp_token(state, tk1);
        }
        return tk1->tok;
}

static struct token *pp_eat(struct compile_state *state, int tok)
{
        pp_peek(state);
        return do_eat_token(state, tok);
}

static int peek(struct compile_state *state)
{
        struct token *tk1;
        tk1 = get_token(state, 1);
        if (tk1->tok == -1) {
                token(state, tk1);
        }
        return tk1->tok;
}

static int peek2(struct compile_state *state)
{
        struct token *tk1, *tk2;
        tk1 = get_token(state, 1);
        tk2 = get_token(state, 2);
        if (tk1->tok == -1) {
                token(state, tk1);
        }
        if (tk2->tok == -1) {
                token(state, tk2);
        }
        return tk2->tok;
}

static struct token *eat(struct compile_state *state, int tok)
{
        peek(state);
        return do_eat_token(state, tok);
}

static void compile_file(struct compile_state *state, const char *filename, int local)
{
        char cwd[MAX_CWD_SIZE];
        const char *subdir, *base;
        int subdir_len;
        struct file_state *file;
        char *basename;
        file = xmalloc(sizeof(*file), "file_state");

        base = strrchr(filename, '/');
        subdir = filename;
        if (base != 0) {
                subdir_len = base - filename;
                base++;
        }
        else {
                base = filename;
                subdir_len = 0;
        }
        basename = xmalloc(strlen(base) +1, "basename");
        strcpy(basename, base);
        file->basename = basename;

        if (getcwd(cwd, sizeof(cwd)) == 0) {
                die("cwd buffer to small");
        }
        if (subdir[0] == '/') {
                file->dirname = xmalloc(subdir_len + 1, "dirname");
                memcpy(file->dirname, subdir, subdir_len);
                file->dirname[subdir_len] = '\0';
        }
        else {
                const char *dir;
                int dirlen;
                const char **path;
                /* Find the appropriate directory... */
                dir = 0;
                if (!state->file && exists(cwd, filename)) {
                        dir = cwd;
                }
                if (local && state->file && exists(state->file->dirname, filename)) {
                        dir = state->file->dirname;
                }
                for(path = state->compiler->include_paths; !dir && *path; path++) {
                        if (exists(*path, filename)) {
                                dir = *path;
                        }
                }
                if (!dir) {
                        error(state, 0, "Cannot open `%s'\n", filename);
                }
                dirlen = strlen(dir);
                file->dirname = xmalloc(dirlen + 1 + subdir_len + 1, "dirname");
                memcpy(file->dirname, dir, dirlen);
                file->dirname[dirlen] = '/';
                memcpy(file->dirname + dirlen + 1, subdir, subdir_len);
                file->dirname[dirlen + 1 + subdir_len] = '\0';
        }
        file->buf = slurp_file(file->dirname, file->basename, &file->size);

        file->pos = file->buf;
        file->line_start = file->pos;
        file->line = 1;

        file->report_line = 1;
        file->report_name = file->basename;
        file->report_dir  = file->dirname;
        file->macro       = 0;
        file->trigraphs   = (state->compiler->flags & COMPILER_TRIGRAPHS)? 1: 0;
        file->join_lines  = 1;

        file->prev = state->file;
        state->file = file;
}

static struct triple *constant_expr(struct compile_state *state);
static void integral(struct compile_state *state, struct triple *def);

static int mcexpr(struct compile_state *state)
{
        struct triple *cvalue;
        cvalue = constant_expr(state);
        integral(state, cvalue);
        if (cvalue->op != OP_INTCONST) {
                error(state, 0, "integer constant expected");
        }
        return cvalue->u.cval != 0;
}

static void preprocess(struct compile_state *state, struct token *current_token)
{
        /* Doing much more with the preprocessor would require
         * a parser and a major restructuring.
         * Postpone that for later.
         */
        int old_token_base;
        int tok;
        
        state->macro_file = state->file;

        old_token_base = state->token_base;
        state->token_base = current_token - state->token;

        tok = pp_peek(state);
        switch(tok) {
        case TOK_LIT_INT:
        {
                struct token *tk;
                int override_line;
                tk = pp_eat(state, TOK_LIT_INT);
                override_line = strtoul(tk->val.str, 0, 10);
                /* I have a preprocessor  line marker parse it */
                if (pp_peek(state) == TOK_LIT_STRING) {
                        const char *token, *base;
                        char *name, *dir;
                        int name_len, dir_len;
                        tk = pp_eat(state, TOK_LIT_STRING);
                        name = xmalloc(tk->str_len, "report_name");
                        token = tk->val.str + 1;
                        base = strrchr(token, '/');
                        name_len = tk->str_len -2;
                        if (base != 0) {
                                dir_len = base - token;
                                base++;
                                name_len -= base - token;
                        } else {
                                dir_len = 0;
                                base = token;
                        }
                        memcpy(name, base, name_len);
                        name[name_len] = '\0';
                        dir = xmalloc(dir_len + 1, "report_dir");
                        memcpy(dir, token, dir_len);
                        dir[dir_len] = '\0';
                        state->file->report_line = override_line - 1;
                        state->file->report_name = name;
                        state->file->report_dir = dir;
                        state->file->macro      = 0;
                }
                break;
        }
        case TOK_MLINE:
        {
                struct token *tk;
                pp_eat(state, TOK_MLINE);
                tk = eat(state, TOK_LIT_INT);
                state->file->report_line = strtoul(tk->val.str, 0, 10) -1;
                if (pp_peek(state) == TOK_LIT_STRING) {
                        const char *token, *base;
                        char *name, *dir;
                        int name_len, dir_len;
                        tk = pp_eat(state, TOK_LIT_STRING);
                        name = xmalloc(tk->str_len, "report_name");
                        token = tk->val.str + 1;
                        base = strrchr(token, '/');
                        name_len = tk->str_len - 2;
                        if (base != 0) {
                                dir_len = base - token;
                                base++;
                                name_len -= base - token;
                        } else {
                                dir_len = 0;
                                base = token;
                        }
                        memcpy(name, base, name_len);
                        name[name_len] = '\0';
                        dir = xmalloc(dir_len + 1, "report_dir");
                        memcpy(dir, token, dir_len);
                        dir[dir_len] = '\0';
                        state->file->report_name = name;
                        state->file->report_dir = dir;
                        state->file->macro      = 0;
                }
                break;
        }
        case TOK_MUNDEF:
        {
                struct hash_entry *ident;
                pp_eat(state, TOK_MUNDEF);
                if (if_eat(state))  /* quit early when #if'd out */
                        break;
                
                ident = pp_eat(state, TOK_MIDENT)->ident;

                undef_macro(state, ident);
                break;
        }
        case TOK_MPRAGMA:
                pp_eat(state, TOK_MPRAGMA);
                if (if_eat(state))  /* quit early when #if'd out */
                        break;
                warning(state, 0, "Ignoring pragma"); 
                break;
        case TOK_MELIF:
                pp_eat(state, TOK_MELIF);
                reenter_if(state, "#elif");
                if (if_eat(state))   /* quit early when #if'd out */
                        break;
                /* If the #if was taken the #elif just disables the following code */
                if (if_value(state)) {
                        eat_tokens(state, TOK_MENDIF);
                }
                /* If the previous #if was not taken see if the #elif enables the 
                 * trailing code.
                 */
                else {
                        set_if_value(state, mcexpr(state));
                        if (!if_value(state)) {
                                eat_tokens(state, TOK_MELSE);
                        }
                }
                break;
        case TOK_MIF:
                pp_eat(state, TOK_MIF);
                enter_if(state);
                if (if_eat(state))  /* quit early when #if'd out */
                        break;
                set_if_value(state, mcexpr(state));
                if (!if_value(state)) {
                        eat_tokens(state, TOK_MELSE);
                }
                break;
        case TOK_MIFNDEF:
        {
                struct hash_entry *ident;

                pp_eat(state, TOK_MIFNDEF);
                enter_if(state);
                if (if_eat(state))  /* quit early when #if'd out */
                        break;
                ident = pp_eat(state, TOK_MIDENT)->ident;
                set_if_value(state, ident->sym_define == 0);
                if (!if_value(state)) {
                        eat_tokens(state, TOK_MELSE);
                }
                break;
        }
        case TOK_MIFDEF:
        {
                struct hash_entry *ident;
                pp_eat(state, TOK_MIFDEF);
                enter_if(state);
                if (if_eat(state))  /* quit early when #if'd out */
                        break;
                ident = pp_eat(state, TOK_MIDENT)->ident;
                set_if_value(state, ident->sym_define != 0);
                if (!if_value(state)) {
                        eat_tokens(state, TOK_MELSE);
                }
                break;
        }
        case TOK_MELSE:
                pp_eat(state, TOK_MELSE);
                enter_else(state, "#else");
                if (!if_eat(state) && if_value(state)) {
                        eat_tokens(state, TOK_MENDIF);
                }
                break;
        case TOK_MENDIF:
                pp_eat(state, TOK_MENDIF);
                exit_if(state, "#endif");
                break;
        case TOK_MDEFINE:
        {
                struct hash_entry *ident;
                struct macro_arg *args, **larg;
                const char *mstart, *mend;
                int argc;

                pp_eat(state, TOK_MDEFINE);
                if (if_eat(state))  /* quit early when #if'd out */
                        break;
                ident = pp_eat(state, TOK_MIDENT)->ident;
                argc = -1;
                args = 0;
                larg = &args;

                /* Parse macro parameters */
                if (raw_peek(state) == TOK_LPAREN) {
                        raw_eat(state, TOK_LPAREN);
                        argc += 1;

                        for(;;) {
                                struct macro_arg *narg, *arg;
                                struct hash_entry *aident;
                                int tok;

                                tok = pp_peek(state);
                                if (!args && (tok == TOK_RPAREN)) {
                                        break;
                                }
                                else if (tok == TOK_DOTS) {
                                        pp_eat(state, TOK_DOTS);
                                        aident = state->i___VA_ARGS__;
                                } 
                                else {
                                        aident = pp_eat(state, TOK_MIDENT)->ident;
                                }
                                
                                narg = xcmalloc(sizeof(*arg), "macro arg");
                                narg->ident = aident;

                                /* Verify I don't have a duplicate identifier */
                                for(arg = args; arg; arg = arg->next) {
                                        if (arg->ident == narg->ident) {
                                                error(state, 0, "Duplicate macro arg `%s'",
                                                        narg->ident->name);
                                        }
                                }
                                /* Add the new argument to the end of the list */
                                *larg = narg;
                                larg = &narg->next;
                                argc += 1;

                                if ((aident == state->i___VA_ARGS__) ||
                                        (pp_peek(state) != TOK_COMMA)) {
                                        break;
                                }
                                pp_eat(state, TOK_COMMA);
                        }
                        pp_eat(state, TOK_RPAREN);
                }
                /* Remove leading whitespace */
                while(raw_peek(state) == TOK_SPACE) {
                        raw_eat(state, TOK_SPACE);
                }

                /* Remember the start of the macro body */
                tok = raw_peek(state);
                mend = mstart = get_token(state, 1)->pos;

                /* Find the end of the macro */
                for(tok = raw_peek(state); tok != TOK_EOL; tok = raw_peek(state)) {
                        raw_eat(state, tok);
                        /* Remember the end of the last non space token */
                        raw_peek(state);
                        if (tok != TOK_SPACE) {
                                mend = get_token(state, 1)->pos;
                        }
                }
                
                /* Now that I have found the body defined the token */
                do_define_macro(state, ident,
                        char_strdup(state->file, mstart, mend, "macro buf"),
                        argc, args);
                break;
        }
        case TOK_MERROR:
        {
                const char *start, *end;
                int len;
                
                pp_eat(state, TOK_MERROR);
                /* Find the start of the line */
                raw_peek(state);
                start = get_token(state, 1)->pos;

                /* Find the end of the line */
                while((tok = raw_peek(state)) != TOK_EOL) {
                        raw_eat(state, tok);
                }
                end = get_token(state, 1)->pos;
                len = end - start;
                if (!if_eat(state)) {
                        error(state, 0, "%*.*s", len, len, start);
                }
                break;
        }
        case TOK_MWARNING:
        {
                const char *start, *end;
                int len;
                
                pp_eat(state, TOK_MWARNING);

                /* Find the start of the line */
                raw_peek(state);
                start = get_token(state, 1)->pos;
                 
                /* Find the end of the line */
                while((tok = raw_peek(state)) != TOK_EOL) {
                        raw_eat(state, tok);
                }
                end = get_token(state, 1)->pos;
                len = end - start;
                if (!if_eat(state)) {
                        warning(state, 0, "%*.*s", len, len, start);
                }
                break;
        }
        case TOK_MINCLUDE:
        {
                char *name;
                int local;
                local = 0;
                name = 0;

                pp_eat(state, TOK_MINCLUDE);
                tok = peek(state);
                if (tok == TOK_LIT_STRING) {
                        struct token *tk;
                        const char *token;
                        int name_len;
                        tk = eat(state, TOK_LIT_STRING);
                        name = xmalloc(tk->str_len, "include");
                        token = tk->val.str +1;
                        name_len = tk->str_len -2;
                        if (*token == '"') {
                                token++;
                                name_len--;
                        }
                        memcpy(name, token, name_len);
                        name[name_len] = '\0';
                        local = 1;
                }
                else if (tok == TOK_LESS) {
                        struct macro_buf buf;
                        eat(state, TOK_LESS);

                        buf.len = 40;
                        buf.str = xmalloc(buf.len, "include");
                        buf.pos = 0;

                        tok = peek(state);
                        while((tok != TOK_MORE) &&
                                (tok != TOK_EOL) && (tok != TOK_EOF))
                        {
                                struct token *tk;
                                tk = eat(state, tok);
                                append_macro_chars(state, "include", &buf,
                                        state->file, tk->pos, state->file->pos);
                                tok = peek(state);
                        }
                        append_macro_text(state, "include", &buf, "\0", 1);
                        if (peek(state) != TOK_MORE) {
                                error(state, 0, "Unterminated include directive");
                        }
                        eat(state, TOK_MORE);
                        local = 0;
                        name = buf.str;
                }
                else {
                        error(state, 0, "Invalid include directive");
                }
                /* Error if there are any tokens after the include */
                if (pp_peek(state) != TOK_EOL) {
                        error(state, 0, "garbage after include directive");
                }
                if (!if_eat(state)) {
                        compile_file(state, name, local);
                }
                xfree(name);
                break;
        }
        case TOK_EOL:
                /* Ignore # without a follwing ident */
                break;
        default:
        {
                const char *name1, *name2;
                name1 = tokens[tok];
                name2 = "";
                if (tok == TOK_MIDENT) {
                        name2 = get_token(state, 1)->ident->name;
                }
                error(state, 0, "Invalid preprocessor directive: %s %s", 
                        name1, name2);
                break;
        }
        }
        /* Consume the rest of the macro line */
        do {
                tok = pp_peek(state);
                pp_eat(state, tok);
        } while((tok != TOK_EOF) && (tok != TOK_EOL));
        state->token_base = old_token_base;
        state->macro_file = NULL;
        return;
}

/* Type helper functions */

static struct type *new_type(
        unsigned int type, struct type *left, struct type *right)
{
        struct type *result;
        result = xmalloc(sizeof(*result), "type");
        result->type = type;
        result->left = left;
        result->right = right;
        result->field_ident = 0;
        result->type_ident = 0;
        result->elements = 0;
        return result;
}

static struct type *clone_type(unsigned int specifiers, struct type *old)
{
        struct type *result;
        result = xmalloc(sizeof(*result), "type");
        memcpy(result, old, sizeof(*result));
        result->type &= TYPE_MASK;
        result->type |= specifiers;
        return result;
}

static struct type *dup_type(struct compile_state *state, struct type *orig)
{
        struct type *new;
        new = xcmalloc(sizeof(*new), "type");
        new->type = orig->type;
        new->field_ident = orig->field_ident;
        new->type_ident  = orig->type_ident;
        new->elements    = orig->elements;
        if (orig->left) {
                new->left = dup_type(state, orig->left);
        }
        if (orig->right) {
                new->right = dup_type(state, orig->right);
        }
        return new;
}


static struct type *invalid_type(struct compile_state *state, struct type *type)
{
        struct type *invalid, *member;
        invalid = 0;
        if (!type) {
                internal_error(state, 0, "type missing?");
        }
        switch(type->type & TYPE_MASK) {
        case TYPE_VOID:
        case TYPE_CHAR:         case TYPE_UCHAR:
        case TYPE_SHORT:        case TYPE_USHORT:
        case TYPE_INT:          case TYPE_UINT:
        case TYPE_LONG:         case TYPE_ULONG:
        case TYPE_LLONG:        case TYPE_ULLONG:
        case TYPE_POINTER:
        case TYPE_ENUM:
                break;
        case TYPE_BITFIELD:
                invalid = invalid_type(state, type->left);
                break;
        case TYPE_ARRAY:
                invalid = invalid_type(state, type->left);
                break;
        case TYPE_STRUCT:
        case TYPE_TUPLE:
                member = type->left;
                while(member && (invalid == 0) && 
                        ((member->type & TYPE_MASK) == TYPE_PRODUCT)) {
                        invalid = invalid_type(state, member->left);
                        member = member->right;
                }
                if (!invalid) {
                        invalid = invalid_type(state, member);
                }
                break;
        case TYPE_UNION:
        case TYPE_JOIN:
                member = type->left;
                while(member && (invalid == 0) &&
                        ((member->type & TYPE_MASK) == TYPE_OVERLAP)) {
                        invalid = invalid_type(state, member->left);
                        member = member->right;
                }
                if (!invalid) {
                        invalid = invalid_type(state, member);
                }
                break;
        default:
                invalid = type;
                break;
        }
        return invalid;
        
}

#define MASK_UCHAR(X)    ((X) & ((ulong_t)0xff))
#define MASK_USHORT(X)   ((X) & (((ulong_t)1 << (SIZEOF_SHORT)) - 1))
static inline ulong_t mask_uint(ulong_t x)
{
        if (SIZEOF_INT < SIZEOF_LONG) {
                ulong_t mask = (((ulong_t)1) << ((ulong_t)(SIZEOF_INT))) -1;
                x &= mask;
        }
        return x;
}
#define MASK_UINT(X)      (mask_uint(X))
#define MASK_ULONG(X)    (X)

static struct type void_type    = { .type  = TYPE_VOID };
static struct type char_type    = { .type  = TYPE_CHAR };
static struct type uchar_type   = { .type  = TYPE_UCHAR };
static struct type short_type   = { .type  = TYPE_SHORT };
static struct type ushort_type  = { .type  = TYPE_USHORT };
static struct type int_type     = { .type  = TYPE_INT };
static struct type uint_type    = { .type  = TYPE_UINT };
static struct type long_type    = { .type  = TYPE_LONG };
static struct type ulong_type   = { .type  = TYPE_ULONG };
static struct type unknown_type = { .type  = TYPE_UNKNOWN };

static struct type void_ptr_type  = {
        .type = TYPE_POINTER,
        .left = &void_type,
};

static struct type void_func_type = { 
        .type  = TYPE_FUNCTION,
        .left  = &void_type,
        .right = &void_type,
};

static size_t bits_to_bytes(size_t size)
{
        return (size + SIZEOF_CHAR - 1)/SIZEOF_CHAR;
}

static struct triple *variable(struct compile_state *state, struct type *type)
{
        struct triple *result;
        if ((type->type & STOR_MASK) != STOR_PERM) {
                result = triple(state, OP_ADECL, type, 0, 0);
                generate_lhs_pieces(state, result);
        }
        else {
                result = triple(state, OP_SDECL, type, 0, 0);
        }
        return result;
}

static void stor_of(FILE *fp, struct type *type)
{
        switch(type->type & STOR_MASK) {
        case STOR_AUTO:
                fprintf(fp, "auto ");
                break;
        case STOR_STATIC:
                fprintf(fp, "static ");
                break;
        case STOR_LOCAL:
                fprintf(fp, "local ");
                break;
        case STOR_EXTERN:
                fprintf(fp, "extern ");
                break;
        case STOR_REGISTER:
                fprintf(fp, "register ");
                break;
        case STOR_TYPEDEF:
                fprintf(fp, "typedef ");
                break;
        case STOR_INLINE | STOR_LOCAL:
                fprintf(fp, "inline ");
                break;
        case STOR_INLINE | STOR_STATIC:
                fprintf(fp, "static inline");
                break;
        case STOR_INLINE | STOR_EXTERN:
                fprintf(fp, "extern inline");
                break;
        default:
                fprintf(fp, "stor:%x", type->type & STOR_MASK);
                break;
        }
}
static void qual_of(FILE *fp, struct type *type)
{
        if (type->type & QUAL_CONST) {
                fprintf(fp, " const");
        }
        if (type->type & QUAL_VOLATILE) {
                fprintf(fp, " volatile");
        }
        if (type->type & QUAL_RESTRICT) {
                fprintf(fp, " restrict");
        }
}

static void name_of(FILE *fp, struct type *type)
{
        unsigned int base_type;
        base_type = type->type & TYPE_MASK;
        if ((base_type != TYPE_PRODUCT) && (base_type != TYPE_OVERLAP)) {
                stor_of(fp, type);
        }
        switch(base_type) {
        case TYPE_VOID:
                fprintf(fp, "void");
                qual_of(fp, type);
                break;
        case TYPE_CHAR:
                fprintf(fp, "signed char");
                qual_of(fp, type);
                break;
        case TYPE_UCHAR:
                fprintf(fp, "unsigned char");
                qual_of(fp, type);
                break;
        case TYPE_SHORT:
                fprintf(fp, "signed short");
                qual_of(fp, type);
                break;
        case TYPE_USHORT:
                fprintf(fp, "unsigned short");
                qual_of(fp, type);
                break;
        case TYPE_INT:
                fprintf(fp, "signed int");
                qual_of(fp, type);
                break;
        case TYPE_UINT:
                fprintf(fp, "unsigned int");
                qual_of(fp, type);
                break;
        case TYPE_LONG:
                fprintf(fp, "signed long");
                qual_of(fp, type);
                break;
        case TYPE_ULONG:
                fprintf(fp, "unsigned long");
                qual_of(fp, type);
                break;
        case TYPE_POINTER:
                name_of(fp, type->left);
                fprintf(fp, " * ");
                qual_of(fp, type);
                break;
        case TYPE_PRODUCT:
                name_of(fp, type->left);
                fprintf(fp, ", ");
                name_of(fp, type->right);
                break;
        case TYPE_OVERLAP:
                name_of(fp, type->left);
                fprintf(fp, ",| ");
                name_of(fp, type->right);
                break;
        case TYPE_ENUM:
                fprintf(fp, "enum %s", 
                        (type->type_ident)? type->type_ident->name : "");
                qual_of(fp, type);
                break;
        case TYPE_STRUCT:
                fprintf(fp, "struct %s { ", 
                        (type->type_ident)? type->type_ident->name : "");
                name_of(fp, type->left);
                fprintf(fp, " } ");
                qual_of(fp, type);
                break;
        case TYPE_UNION:
                fprintf(fp, "union %s { ", 
                        (type->type_ident)? type->type_ident->name : "");
                name_of(fp, type->left);
                fprintf(fp, " } ");
                qual_of(fp, type);
                break;
        case TYPE_FUNCTION:
                name_of(fp, type->left);
                fprintf(fp, " (*)(");
                name_of(fp, type->right);
                fprintf(fp, ")");
                break;
        case TYPE_ARRAY:
                name_of(fp, type->left);
                fprintf(fp, " [%ld]", (long)(type->elements));
                break;
        case TYPE_TUPLE:
                fprintf(fp, "tuple { "); 
                name_of(fp, type->left);
                fprintf(fp, " } ");
                qual_of(fp, type);
                break;
        case TYPE_JOIN:
                fprintf(fp, "join { ");
                name_of(fp, type->left);
                fprintf(fp, " } ");
                qual_of(fp, type);
                break;
        case TYPE_BITFIELD:
                name_of(fp, type->left);
                fprintf(fp, " : %d ", type->elements);
                qual_of(fp, type);
                break;
        case TYPE_UNKNOWN:
                fprintf(fp, "unknown_t");
                break;
        default:
                fprintf(fp, "????: %x", base_type);
                break;
        }
        if (type->field_ident && type->field_ident->name) {
                fprintf(fp, " .%s", type->field_ident->name);
        }
}

static size_t align_of(struct compile_state *state, struct type *type)
{
        size_t align;
        align = 0;
        switch(type->type & TYPE_MASK) {
        case TYPE_VOID:
                align = 1;
                break;
        case TYPE_BITFIELD:
                align = 1;
                break;
        case TYPE_CHAR:
        case TYPE_UCHAR:
                align = ALIGNOF_CHAR;
                break;
        case TYPE_SHORT:
        case TYPE_USHORT:
                align = ALIGNOF_SHORT;
                break;
        case TYPE_INT:
        case TYPE_UINT:
        case TYPE_ENUM:
                align = ALIGNOF_INT;
                break;
        case TYPE_LONG:
        case TYPE_ULONG:
                align = ALIGNOF_LONG;
                break;
        case TYPE_POINTER:
                align = ALIGNOF_POINTER;
                break;
        case TYPE_PRODUCT:
        case TYPE_OVERLAP:
        {
                size_t left_align, right_align;
                left_align  = align_of(state, type->left);
                right_align = align_of(state, type->right);
                align = (left_align >= right_align) ? left_align : right_align;
                break;
        }
        case TYPE_ARRAY:
                align = align_of(state, type->left);
                break;
        case TYPE_STRUCT:
        case TYPE_TUPLE:
        case TYPE_UNION:
        case TYPE_JOIN:
                align = align_of(state, type->left);
                break;
        default:
                error(state, 0, "alignof not yet defined for type\n");
                break;
        }
        return align;
}

static size_t reg_align_of(struct compile_state *state, struct type *type)
{
        size_t align;
        align = 0;
        switch(type->type & TYPE_MASK) {
        case TYPE_VOID:
                align = 1;
                break;
        case TYPE_BITFIELD:
                align = 1;
                break;
        case TYPE_CHAR:
        case TYPE_UCHAR:
                align = REG_ALIGNOF_CHAR;
                break;
        case TYPE_SHORT:
        case TYPE_USHORT:
                align = REG_ALIGNOF_SHORT;
                break;
        case TYPE_INT:
        case TYPE_UINT:
        case TYPE_ENUM:
                align = REG_ALIGNOF_INT;
                break;
        case TYPE_LONG:
        case TYPE_ULONG:
                align = REG_ALIGNOF_LONG;
                break;
        case TYPE_POINTER:
                align = REG_ALIGNOF_POINTER;
                break;
        case TYPE_PRODUCT:
        case TYPE_OVERLAP:
        {
                size_t left_align, right_align;
                left_align  = reg_align_of(state, type->left);
                right_align = reg_align_of(state, type->right);
                align = (left_align >= right_align) ? left_align : right_align;
                break;
        }
        case TYPE_ARRAY:
                align = reg_align_of(state, type->left);
                break;
        case TYPE_STRUCT:
        case TYPE_UNION:
        case TYPE_TUPLE:
        case TYPE_JOIN:
                align = reg_align_of(state, type->left);
                break;
        default:
                error(state, 0, "alignof not yet defined for type\n");
                break;
        }
        return align;
}

static size_t align_of_in_bytes(struct compile_state *state, struct type *type)
{
        return bits_to_bytes(align_of(state, type));
}
static size_t size_of(struct compile_state *state, struct type *type);
static size_t reg_size_of(struct compile_state *state, struct type *type);

static size_t needed_padding(struct compile_state *state, 
        struct type *type, size_t offset)
{
        size_t padding, align;
        align = align_of(state, type);
        /* Align to the next machine word if the bitfield does completely
         * fit into the current word.
         */
        if ((type->type & TYPE_MASK) == TYPE_BITFIELD) {
                size_t size;
                size = size_of(state, type);
                if ((offset + type->elements)/size != offset/size) {
                        align = size;
                }
        }
        padding = 0;
        if (offset % align) {
                padding = align - (offset % align);
        }
        return padding;
}

static size_t reg_needed_padding(struct compile_state *state, 
        struct type *type, size_t offset)
{
        size_t padding, align;
        align = reg_align_of(state, type);
        /* Align to the next register word if the bitfield does completely
         * fit into the current register.
         */
        if (((type->type & TYPE_MASK) == TYPE_BITFIELD) &&
                (((offset + type->elements)/REG_SIZEOF_REG) != (offset/REG_SIZEOF_REG))) 
        {
                align = REG_SIZEOF_REG;
        }
        padding = 0;
        if (offset % align) {
                padding = align - (offset % align);
        }
        return padding;
}

static size_t size_of(struct compile_state *state, struct type *type)
{
        size_t size;
        size = 0;
        switch(type->type & TYPE_MASK) {
        case TYPE_VOID:
                size = 0;
                break;
        case TYPE_BITFIELD:
                size = type->elements;
                break;
        case TYPE_CHAR:
        case TYPE_UCHAR:
                size = SIZEOF_CHAR;
                break;
        case TYPE_SHORT:
        case TYPE_USHORT:
                size = SIZEOF_SHORT;
                break;
        case TYPE_INT:
        case TYPE_UINT:
        case TYPE_ENUM:
                size = SIZEOF_INT;
                break;
        case TYPE_LONG:
        case TYPE_ULONG:
                size = SIZEOF_LONG;
                break;
        case TYPE_POINTER:
                size = SIZEOF_POINTER;
                break;
        case TYPE_PRODUCT:
        {
                size_t pad;
                size = 0;
                while((type->type & TYPE_MASK) == TYPE_PRODUCT) {
                        pad = needed_padding(state, type->left, size);
                        size = size + pad + size_of(state, type->left);
                        type = type->right;
                }
                pad = needed_padding(state, type, size);
                size = size + pad + size_of(state, type);
                break;
        }
        case TYPE_OVERLAP:
        {
                size_t size_left, size_right;
                size_left = size_of(state, type->left);
                size_right = size_of(state, type->right);
                size = (size_left >= size_right)? size_left : size_right;
                break;
        }
        case TYPE_ARRAY:
                if (type->elements == ELEMENT_COUNT_UNSPECIFIED) {
                        internal_error(state, 0, "Invalid array type");
                } else {
                        size = size_of(state, type->left) * type->elements;
                }
                break;
        case TYPE_STRUCT:
        case TYPE_TUPLE:
        {
                size_t pad;
                size = size_of(state, type->left);
                /* Pad structures so their size is a multiples of their alignment */
                pad = needed_padding(state, type, size);
                size = size + pad;
                break;
        }
        case TYPE_UNION:
        case TYPE_JOIN:
        {
                size_t pad;
                size = size_of(state, type->left);
                /* Pad unions so their size is a multiple of their alignment */
                pad = needed_padding(state, type, size);
                size = size + pad;
                break;
        }
        default:
                internal_error(state, 0, "sizeof not yet defined for type");
                break;
        }
        return size;
}

static size_t reg_size_of(struct compile_state *state, struct type *type)
{
        size_t size;
        size = 0;
        switch(type->type & TYPE_MASK) {
        case TYPE_VOID:
                size = 0;
                break;
        case TYPE_BITFIELD:
                size = type->elements;
                break;
        case TYPE_CHAR:
        case TYPE_UCHAR:
                size = REG_SIZEOF_CHAR;
                break;
        case TYPE_SHORT:
        case TYPE_USHORT:
                size = REG_SIZEOF_SHORT;
                break;
        case TYPE_INT:
        case TYPE_UINT:
        case TYPE_ENUM:
                size = REG_SIZEOF_INT;
                break;
        case TYPE_LONG:
        case TYPE_ULONG:
                size = REG_SIZEOF_LONG;
                break;
        case TYPE_POINTER:
                size = REG_SIZEOF_POINTER;
                break;
        case TYPE_PRODUCT:
        {
                size_t pad;
                size = 0;
                while((type->type & TYPE_MASK) == TYPE_PRODUCT) {
                        pad = reg_needed_padding(state, type->left, size);
                        size = size + pad + reg_size_of(state, type->left);
                        type = type->right;
                }
                pad = reg_needed_padding(state, type, size);
                size = size + pad + reg_size_of(state, type);
                break;
        }
        case TYPE_OVERLAP:
        {
                size_t size_left, size_right;
                size_left  = reg_size_of(state, type->left);
                size_right = reg_size_of(state, type->right);
                size = (size_left >= size_right)? size_left : size_right;
                break;
        }
        case TYPE_ARRAY:
                if (type->elements == ELEMENT_COUNT_UNSPECIFIED) {
                        internal_error(state, 0, "Invalid array type");
                } else {
                        size = reg_size_of(state, type->left) * type->elements;
                }
                break;
        case TYPE_STRUCT:
        case TYPE_TUPLE:
        {
                size_t pad;
                size = reg_size_of(state, type->left);
                /* Pad structures so their size is a multiples of their alignment */
                pad = reg_needed_padding(state, type, size);
                size = size + pad;
                break;
        }
        case TYPE_UNION:
        case TYPE_JOIN:
        {
                size_t pad;
                size = reg_size_of(state, type->left);
                /* Pad unions so their size is a multiple of their alignment */
                pad = reg_needed_padding(state, type, size);
                size = size + pad;
                break;
        }
        default:
                internal_error(state, 0, "sizeof not yet defined for type");
                break;
        }
        return size;
}

static size_t registers_of(struct compile_state *state, struct type *type)
{
        size_t registers;
        registers = reg_size_of(state, type);
        registers += REG_SIZEOF_REG - 1;
        registers /= REG_SIZEOF_REG;
        return registers;
}

static size_t size_of_in_bytes(struct compile_state *state, struct type *type)
{
        return bits_to_bytes(size_of(state, type));
}

static size_t field_offset(struct compile_state *state, 
        struct type *type, struct hash_entry *field)
{
        struct type *member;
        size_t size;

        size = 0;
        member = 0;
        if ((type->type & TYPE_MASK) == TYPE_STRUCT) {
                member = type->left;
                while(member && ((member->type & TYPE_MASK) == TYPE_PRODUCT)) {
                        size += needed_padding(state, member->left, size);
                        if (member->left->field_ident == field) {
                                member = member->left;
                                break;
                        }
                        size += size_of(state, member->left);
                        member = member->right;
                }
                size += needed_padding(state, member, size);
        }
        else if ((type->type & TYPE_MASK) == TYPE_UNION) {
                member = type->left;
                while(member && ((member->type & TYPE_MASK) == TYPE_OVERLAP)) {
                        if (member->left->field_ident == field) {
                                member = member->left;
                                break;
                        }
                        member = member->right;
                }
        }
        else {
                internal_error(state, 0, "field_offset only works on structures and unions");
        }

        if (!member || (member->field_ident != field)) {
                error(state, 0, "member %s not present", field->name);
        }
        return size;
}

static size_t field_reg_offset(struct compile_state *state, 
        struct type *type, struct hash_entry *field)
{
        struct type *member;
        size_t size;

        size = 0;
        member = 0;
        if ((type->type & TYPE_MASK) == TYPE_STRUCT) {
                member = type->left;
                while(member && ((member->type & TYPE_MASK) == TYPE_PRODUCT)) {
                        size += reg_needed_padding(state, member->left, size);
                        if (member->left->field_ident == field) {
                                member = member->left;
                                break;
                        }
                        size += reg_size_of(state, member->left);
                        member = member->right;
                }
        }
        else if ((type->type & TYPE_MASK) == TYPE_UNION) {
                member = type->left;
                while(member && ((member->type & TYPE_MASK) == TYPE_OVERLAP)) {
                        if (member->left->field_ident == field) {
                                member = member->left;
                                break;
                        }
                        member = member->right;
                }
        }
        else {
                internal_error(state, 0, "field_reg_offset only works on structures and unions");
        }

        size += reg_needed_padding(state, member, size);
        if (!member || (member->field_ident != field)) {
                error(state, 0, "member %s not present", field->name);
        }
        return size;
}

static struct type *field_type(struct compile_state *state, 
        struct type *type, struct hash_entry *field)
{
        struct type *member;

        member = 0;
        if ((type->type & TYPE_MASK) == TYPE_STRUCT) {
                member = type->left;
                while(member && ((member->type & TYPE_MASK) == TYPE_PRODUCT)) {
                        if (member->left->field_ident == field) {
                                member = member->left;
                                break;
                        }
                        member = member->right;
                }
        }
        else if ((type->type & TYPE_MASK) == TYPE_UNION) {
                member = type->left;
                while(member && ((member->type & TYPE_MASK) == TYPE_OVERLAP)) {
                        if (member->left->field_ident == field) {
                                member = member->left;
                                break;
                        }
                        member = member->right;
                }
        }
        else {
                internal_error(state, 0, "field_type only works on structures and unions");
        }
        
        if (!member || (member->field_ident != field)) {
                error(state, 0, "member %s not present", field->name);
        }
        return member;
}

static size_t index_offset(struct compile_state *state, 
        struct type *type, ulong_t index)
{
        struct type *member;
        size_t size;
        size = 0;
        if ((type->type & TYPE_MASK) == TYPE_ARRAY) {
                size = size_of(state, type->left) * index;
        }
        else if ((type->type & TYPE_MASK) == TYPE_TUPLE) {
                ulong_t i;
                member = type->left;
                i = 0;
                while(member && ((member->type & TYPE_MASK) == TYPE_PRODUCT)) {
                        size += needed_padding(state, member->left, size);
                        if (i == index) {
                                member = member->left;
                                break;
                        }
                        size += size_of(state, member->left);
                        i++;
                        member = member->right;
                }
                size += needed_padding(state, member, size);
                if (i != index) {
                        internal_error(state, 0, "Missing member index: %u", index);
                }
        }
        else if ((type->type & TYPE_MASK) == TYPE_JOIN) {
                ulong_t i;
                size = 0;
                member = type->left;
                i = 0;
                while(member && ((member->type & TYPE_MASK) == TYPE_OVERLAP)) {
                        if (i == index) {
                                member = member->left;
                                break;
                        }
                        i++;
                        member = member->right;
                }
                if (i != index) {
                        internal_error(state, 0, "Missing member index: %u", index);
                }
        }
        else {
                internal_error(state, 0, 
                        "request for index %u in something not an array, tuple or join",
                        index);
        }
        return size;
}

static size_t index_reg_offset(struct compile_state *state, 
        struct type *type, ulong_t index)
{
        struct type *member;
        size_t size;
        size = 0;
        if ((type->type & TYPE_MASK) == TYPE_ARRAY) {
                size = reg_size_of(state, type->left) * index;
        }
        else if ((type->type & TYPE_MASK) == TYPE_TUPLE) {
                ulong_t i;
                member = type->left;
                i = 0;
                while(member && ((member->type & TYPE_MASK) == TYPE_PRODUCT)) {
                        size += reg_needed_padding(state, member->left, size);
                        if (i == index) {
                                member = member->left;
                                break;
                        }
                        size += reg_size_of(state, member->left);
                        i++;
                        member = member->right;
                }
                size += reg_needed_padding(state, member, size);
                if (i != index) {
                        internal_error(state, 0, "Missing member index: %u", index);
                }
                
        }
        else if ((type->type & TYPE_MASK) == TYPE_JOIN) {
                ulong_t i;
                size = 0;
                member = type->left;
                i = 0;
                while(member && ((member->type & TYPE_MASK) == TYPE_OVERLAP)) {
                        if (i == index) {
                                member = member->left;
                                break;
                        }
                        i++;
                        member = member->right;
                }
                if (i != index) {
                        internal_error(state, 0, "Missing member index: %u", index);
                }
        }
        else {
                internal_error(state, 0, 
                        "request for index %u in something not an array, tuple or join",
                        index);
        }
        return size;
}

static struct type *index_type(struct compile_state *state,
        struct type *type, ulong_t index)
{
        struct type *member;
        if (index >= type->elements) {
                internal_error(state, 0, "Invalid element %u requested", index);
        }
        if ((type->type & TYPE_MASK) == TYPE_ARRAY) {
                member = type->left;
        }
        else if ((type->type & TYPE_MASK) == TYPE_TUPLE) {
                ulong_t i;
                member = type->left;
                i = 0;
                while(member && ((member->type & TYPE_MASK) == TYPE_PRODUCT)) {
                        if (i == index) {
                                member = member->left;
                                break;
                        }
                        i++;
                        member = member->right;
                }
                if (i != index) {
                        internal_error(state, 0, "Missing member index: %u", index);
                }
        }
        else if ((type->type & TYPE_MASK) == TYPE_JOIN) {
                ulong_t i;
                member = type->left;
                i = 0;
                while(member && ((member->type & TYPE_MASK) == TYPE_OVERLAP)) {
                        if (i == index) {
                                member = member->left;
                                break;
                        }
                        i++;
                        member = member->right;
                }
                if (i != index) {
                        internal_error(state, 0, "Missing member index: %u", index);
                }
        }
        else {
                member = 0;
                internal_error(state, 0, 
                        "request for index %u in something not an array, tuple or join",
                        index);
        }
        return member;
}

static struct type *unpack_type(struct compile_state *state, struct type *type)
{
        /* If I have a single register compound type not a bit-field
         * find the real type.
         */
        struct type *start_type;
        size_t size;
        /* Get out early if I need multiple registers for this type */
        size = reg_size_of(state, type);
        if (size > REG_SIZEOF_REG) {
                return type;
        }
        /* Get out early if I don't need any registers for this type */
        if (size == 0) {
                return &void_type;
        }
        /* Loop until I have no more layers I can remove */
        do {
                start_type = type;
                switch(type->type & TYPE_MASK) {
                case TYPE_ARRAY:
                        /* If I have a single element the unpacked type
                         * is that element.
                         */
                        if (type->elements == 1) {
                                type = type->left;
                        }
                        break;
                case TYPE_STRUCT:
                case TYPE_TUPLE:
                        /* If I have a single element the unpacked type
                         * is that element.
                         */
                        if (type->elements == 1) {
                                type = type->left;
                        }
                        /* If I have multiple elements the unpacked
                         * type is the non-void element.
                         */
                        else {
                                struct type *next, *member;
                                struct type *sub_type;
                                sub_type = 0;
                                next = type->left;
                                while(next) {
                                        member = next;
                                        next = 0;
                                        if ((member->type & TYPE_MASK) == TYPE_PRODUCT) {
                                                next = member->right;
                                                member = member->left;
                                        }
                                        if (reg_size_of(state, member) > 0) {
                                                if (sub_type) {
                                                        internal_error(state, 0, "true compound type in a register");
                                                }
                                                sub_type = member;
                                        }
                                }
                                if (sub_type) {
                                        type = sub_type;
                                }
                        }
                        break;

                case TYPE_UNION:
                case TYPE_JOIN:
                        /* If I have a single element the unpacked type
                         * is that element.
                         */
                        if (type->elements == 1) {
                                type = type->left;
                        }
                        /* I can't in general unpack union types */
                        break;
                default:
                        /* If I'm not a compound type I can't unpack it */
                        break;
                }
        } while(start_type != type);
        switch(type->type & TYPE_MASK) {
        case TYPE_STRUCT:
        case TYPE_ARRAY:
        case TYPE_TUPLE:
                internal_error(state, 0, "irredicible type?");
                break;
        }
        return type;
}

static int equiv_types(struct type *left, struct type *right);
static int is_compound_type(struct type *type);

static struct type *reg_type(
        struct compile_state *state, struct type *type, int reg_offset)
{
        struct type *member;
        size_t size;
#if 1
        struct type *invalid;
        invalid = invalid_type(state, type);
        if (invalid) {
                fprintf(state->errout, "type: ");
                name_of(state->errout, type);
                fprintf(state->errout, "\n");
                fprintf(state->errout, "invalid: ");
                name_of(state->errout, invalid);
                fprintf(state->errout, "\n");
                internal_error(state, 0, "bad input type?");
        }
#endif

        size = reg_size_of(state, type);
        if (reg_offset > size) {
                member = 0;
                fprintf(state->errout, "type: ");
                name_of(state->errout, type);
                fprintf(state->errout, "\n");
                internal_error(state, 0, "offset outside of type");
        }
        else {
                switch(type->type & TYPE_MASK) {
                        /* Don't do anything with the basic types */
                case TYPE_VOID:
                case TYPE_CHAR:         case TYPE_UCHAR:
                case TYPE_SHORT:        case TYPE_USHORT:
                case TYPE_INT:          case TYPE_UINT:
                case TYPE_LONG:         case TYPE_ULONG:
                case TYPE_LLONG:        case TYPE_ULLONG:
                case TYPE_FLOAT:        case TYPE_DOUBLE:
                case TYPE_LDOUBLE:
                case TYPE_POINTER:
                case TYPE_ENUM:
                case TYPE_BITFIELD:
                        member = type;
                        break;
                case TYPE_ARRAY:
                        member = type->left;
                        size = reg_size_of(state, member);
                        if (size > REG_SIZEOF_REG) {
                                member = reg_type(state, member, reg_offset % size);
                        }
                        break;
                case TYPE_STRUCT:
                case TYPE_TUPLE:
                {
                        size_t offset;
                        offset = 0;
                        member = type->left;
                        while(member && ((member->type & TYPE_MASK) == TYPE_PRODUCT)) {
                                size = reg_size_of(state, member->left);
                                offset += reg_needed_padding(state, member->left, offset);
                                if ((offset + size) > reg_offset) {
                                        member = member->left;
                                        break;
                                }
                                offset += size;
                                member = member->right;
                        }
                        offset += reg_needed_padding(state, member, offset);
                        member = reg_type(state, member, reg_offset - offset);
                        break;
                }
                case TYPE_UNION:
                case TYPE_JOIN:
                {
                        struct type *join, **jnext, *mnext;
                        join = new_type(TYPE_JOIN, 0, 0);
                        jnext = &join->left;
                        mnext = type->left;
                        while(mnext) {
                                size_t size;
                                member = mnext;
                                mnext = 0;
                                if ((member->type & TYPE_MASK) == TYPE_OVERLAP) {
                                        mnext = member->right;
                                        member = member->left;
                                }
                                size = reg_size_of(state, member);
                                if (size > reg_offset) {
                                        struct type *part, *hunt;
                                        part = reg_type(state, member, reg_offset);
                                        /* See if this type is already in the union */
                                        hunt = join->left;
                                        while(hunt) {
                                                struct type *test = hunt;
                                                hunt = 0;
                                                if ((test->type & TYPE_MASK) == TYPE_OVERLAP) {
                                                        hunt = test->right;
                                                        test = test->left;
                                                }
                                                if (equiv_types(part, test)) {
                                                        goto next;
                                                }
                                        }
                                        /* Nope add it */
                                        if (!*jnext) {
                                                *jnext = part;
                                        } else {
                                                *jnext = new_type(TYPE_OVERLAP, *jnext, part);
                                                jnext = &(*jnext)->right;
                                        }
                                        join->elements++;
                                }
                        next:
                                ;
                        }
                        if (join->elements == 0) {
                                internal_error(state, 0, "No elements?");
                        }
                        member = join;
                        break;
                }
                default:
                        member = 0;
                        fprintf(state->errout, "type: ");
                        name_of(state->errout, type);
                        fprintf(state->errout, "\n");
                        internal_error(state, 0, "reg_type not yet defined for type");
                        
                }
        }
        /* If I have a single register compound type not a bit-field
         * find the real type.
         */
        member = unpack_type(state, member);
                ;
        size  = reg_size_of(state, member);
        if (size > REG_SIZEOF_REG) {
                internal_error(state, 0, "Cannot find type of single register");
        }
#if 1
        invalid = invalid_type(state, member);
        if (invalid) {
                fprintf(state->errout, "type: ");
                name_of(state->errout, member);
                fprintf(state->errout, "\n");
                fprintf(state->errout, "invalid: ");
                name_of(state->errout, invalid);
                fprintf(state->errout, "\n");
                internal_error(state, 0, "returning bad type?");
        }
#endif
        return member;
}

static struct type *next_field(struct compile_state *state,
        struct type *type, struct type *prev_member) 
{
        struct type *member;
        if ((type->type & TYPE_MASK) != TYPE_STRUCT) {
                internal_error(state, 0, "next_field only works on structures");
        }
        member = type->left;
        while((member->type & TYPE_MASK) == TYPE_PRODUCT) {
                if (!prev_member) {
                        member = member->left;
                        break;
                }
                if (member->left == prev_member) {
                        prev_member = 0;
                }
                member = member->right;
        }
        if (member == prev_member) {
                prev_member = 0;
        }
        if (prev_member) {
                internal_error(state, 0, "prev_member %s not present", 
                        prev_member->field_ident->name);
        }
        return member;
}

typedef void (*walk_type_fields_cb_t)(struct compile_state *state, struct type *type, 
        size_t ret_offset, size_t mem_offset, void *arg);

static void walk_type_fields(struct compile_state *state,
        struct type *type, size_t reg_offset, size_t mem_offset,
        walk_type_fields_cb_t cb, void *arg);

static void walk_struct_fields(struct compile_state *state,
        struct type *type, size_t reg_offset, size_t mem_offset,
        walk_type_fields_cb_t cb, void *arg)
{
        struct type *tptr;
        ulong_t i;
        if ((type->type & TYPE_MASK) != TYPE_STRUCT) {
                internal_error(state, 0, "walk_struct_fields only works on structures");
        }
        tptr = type->left;
        for(i = 0; i < type->elements; i++) {
                struct type *mtype;
                mtype = tptr;
                if ((mtype->type & TYPE_MASK) == TYPE_PRODUCT) {
                        mtype = mtype->left;
                }
                walk_type_fields(state, mtype, 
                        reg_offset + 
                        field_reg_offset(state, type, mtype->field_ident),
                        mem_offset + 
                        field_offset(state, type, mtype->field_ident),
                        cb, arg);
                tptr = tptr->right;
        }
        
}

static void walk_type_fields(struct compile_state *state,
        struct type *type, size_t reg_offset, size_t mem_offset,
        walk_type_fields_cb_t cb, void *arg)
{
        switch(type->type & TYPE_MASK) {
        case TYPE_STRUCT:
                walk_struct_fields(state, type, reg_offset, mem_offset, cb, arg);
                break;
        case TYPE_CHAR:
        case TYPE_UCHAR:
        case TYPE_SHORT:
        case TYPE_USHORT:
        case TYPE_INT:
        case TYPE_UINT:
        case TYPE_LONG:
        case TYPE_ULONG:
                cb(state, type, reg_offset, mem_offset, arg);
                break;
        case TYPE_VOID:
                break;
        default:
                internal_error(state, 0, "walk_type_fields not yet implemented for type");
        }
}

static void arrays_complete(struct compile_state *state, struct type *type)
{
        if ((type->type & TYPE_MASK) == TYPE_ARRAY) {
                if (type->elements == ELEMENT_COUNT_UNSPECIFIED) {
                        error(state, 0, "array size not specified");
                }
                arrays_complete(state, type->left);
        }
}

static unsigned int get_basic_type(struct type *type)
{
        unsigned int basic;
        basic = type->type & TYPE_MASK;
        /* Convert enums to ints */
        if (basic == TYPE_ENUM) {
                basic = TYPE_INT;
        }
        /* Convert bitfields to standard types */
        else if (basic == TYPE_BITFIELD) {
                if (type->elements <= SIZEOF_CHAR) {
                        basic = TYPE_CHAR;
                }
                else if (type->elements <= SIZEOF_SHORT) {
                        basic = TYPE_SHORT;
                }
                else if (type->elements <= SIZEOF_INT) {
                        basic = TYPE_INT;
                }
                else if (type->elements <= SIZEOF_LONG) {
                        basic = TYPE_LONG;
                }
                if (!TYPE_SIGNED(type->left->type)) {
                        basic += 1;
                }
        }
        return basic;
}

static unsigned int do_integral_promotion(unsigned int type)
{
        if (TYPE_INTEGER(type) && (TYPE_RANK(type) < TYPE_RANK(TYPE_INT))) {
                type = TYPE_INT;
        }
        return type;
}

static unsigned int do_arithmetic_conversion(
        unsigned int left, unsigned int right)
{
        if ((left == TYPE_LDOUBLE) || (right == TYPE_LDOUBLE)) {
                return TYPE_LDOUBLE;
        }
        else if ((left == TYPE_DOUBLE) || (right == TYPE_DOUBLE)) {
                return TYPE_DOUBLE;
        }
        else if ((left == TYPE_FLOAT) || (right == TYPE_FLOAT)) {
                return TYPE_FLOAT;
        }
        left = do_integral_promotion(left);
        right = do_integral_promotion(right);
        /* If both operands have the same size done */
        if (left == right) {
                return left;
        }
        /* If both operands have the same signedness pick the larger */
        else if (!!TYPE_UNSIGNED(left) == !!TYPE_UNSIGNED(right)) {
                return (TYPE_RANK(left) >= TYPE_RANK(right)) ? left : right;
        }
        /* If the signed type can hold everything use it */
        else if (TYPE_SIGNED(left) && (TYPE_RANK(left) > TYPE_RANK(right))) {
                return left;
        }
        else if (TYPE_SIGNED(right) && (TYPE_RANK(right) > TYPE_RANK(left))) {
                return right;
        }
        /* Convert to the unsigned type with the same rank as the signed type */
        else if (TYPE_SIGNED(left)) {
                return TYPE_MKUNSIGNED(left);
        }
        else {
                return TYPE_MKUNSIGNED(right);
        }
}

/* see if two types are the same except for qualifiers */
static int equiv_types(struct type *left, struct type *right)
{
        unsigned int type;
        /* Error if the basic types do not match */
        if ((left->type & TYPE_MASK) != (right->type & TYPE_MASK)) {
                return 0;
        }
        type = left->type & TYPE_MASK;
        /* If the basic types match and it is a void type we are done */
        if (type == TYPE_VOID) {
                return 1;
        }
        /* For bitfields we need to compare the sizes */
        else if (type == TYPE_BITFIELD) {
                return (left->elements == right->elements) &&
                        (TYPE_SIGNED(left->left->type) == TYPE_SIGNED(right->left->type));
        }
        /* if the basic types match and it is an arithmetic type we are done */
        else if (TYPE_ARITHMETIC(type)) {
                return 1;
        }
        /* If it is a pointer type recurse and keep testing */
        else if (type == TYPE_POINTER) {
                return equiv_types(left->left, right->left);
        }
        else if (type == TYPE_ARRAY) {
                return (left->elements == right->elements) &&
                        equiv_types(left->left, right->left);
        }
        /* test for struct equality */
        else if (type == TYPE_STRUCT) {
                return left->type_ident == right->type_ident;
        }
        /* test for union equality */
        else if (type == TYPE_UNION) {
                return left->type_ident == right->type_ident;
        }
        /* Test for equivalent functions */
        else if (type == TYPE_FUNCTION) {
                return equiv_types(left->left, right->left) &&
                        equiv_types(left->right, right->right);
        }
        /* We only see TYPE_PRODUCT as part of function equivalence matching */
        /* We also see TYPE_PRODUCT as part of of tuple equivalence matchin */
        else if (type == TYPE_PRODUCT) {
                return equiv_types(left->left, right->left) &&
                        equiv_types(left->right, right->right);
        }
        /* We should see TYPE_OVERLAP when comparing joins */
        else if (type == TYPE_OVERLAP) {
                return equiv_types(left->left, right->left) &&
                        equiv_types(left->right, right->right);
        }
        /* Test for equivalence of tuples */
        else if (type == TYPE_TUPLE) {
                return (left->elements == right->elements) &&
                        equiv_types(left->left, right->left);
        }
        /* Test for equivalence of joins */
        else if (type == TYPE_JOIN) {
                return (left->elements == right->elements) &&
                        equiv_types(left->left, right->left);
        }
        else {
                return 0;
        }
}

static int equiv_ptrs(struct type *left, struct type *right)
{
        if (((left->type & TYPE_MASK) != TYPE_POINTER) ||
                ((right->type & TYPE_MASK) != TYPE_POINTER)) {
                return 0;
        }
        return equiv_types(left->left, right->left);
}

static struct type *compatible_types(struct type *left, struct type *right)
{
        struct type *result;
        unsigned int type, qual_type;
        /* Error if the basic types do not match */
        if ((left->type & TYPE_MASK) != (right->type & TYPE_MASK)) {
                return 0;
        }
        type = left->type & TYPE_MASK;
        qual_type = (left->type & ~STOR_MASK) | (right->type & ~STOR_MASK);
        result = 0;
        /* if the basic types match and it is an arithmetic type we are done */
        if (TYPE_ARITHMETIC(type)) {
                result = new_type(qual_type, 0, 0);
        }
        /* If it is a pointer type recurse and keep testing */
        else if (type == TYPE_POINTER) {
                result = compatible_types(left->left, right->left);
                if (result) {
                        result = new_type(qual_type, result, 0);
                }
        }
        /* test for struct equality */
        else if (type == TYPE_STRUCT) {
                if (left->type_ident == right->type_ident) {
                        result = left;
                }
        }
        /* test for union equality */
        else if (type == TYPE_UNION) {
                if (left->type_ident == right->type_ident) {
                        result = left;
                }
        }
        /* Test for equivalent functions */
        else if (type == TYPE_FUNCTION) {
                struct type *lf, *rf;
                lf = compatible_types(left->left, right->left);
                rf = compatible_types(left->right, right->right);
                if (lf && rf) {
                        result = new_type(qual_type, lf, rf);
                }
        }
        /* We only see TYPE_PRODUCT as part of function equivalence matching */
        else if (type == TYPE_PRODUCT) {
                struct type *lf, *rf;
                lf = compatible_types(left->left, right->left);
                rf = compatible_types(left->right, right->right);
                if (lf && rf) {
                        result = new_type(qual_type, lf, rf);
                }
        }
        else {
                /* Nothing else is compatible */
        }
        return result;
}

/* See if left is a equivalent to right or right is a union member of left */
static int is_subset_type(struct type *left, struct type *right)
{
        if (equiv_types(left, right)) {
                return 1;
        }
        if ((left->type & TYPE_MASK) == TYPE_JOIN) {
                struct type *member, *mnext;
                mnext = left->left;
                while(mnext) {
                        member = mnext;
                        mnext = 0;
                        if ((member->type & TYPE_MASK) == TYPE_OVERLAP) {
                                mnext = member->right;
                                member = member->left;
                        }
                        if (is_subset_type( member, right)) {
                                return 1;
                        }
                }
        }
        return 0;
}

static struct type *compatible_ptrs(struct type *left, struct type *right)
{
        struct type *result;
        if (((left->type & TYPE_MASK) != TYPE_POINTER) ||
                ((right->type & TYPE_MASK) != TYPE_POINTER)) {
                return 0;
        }
        result = compatible_types(left->left, right->left);
        if (result) {
                unsigned int qual_type;
                qual_type = (left->type & ~STOR_MASK) | (right->type & ~STOR_MASK);
                result = new_type(qual_type, result, 0);
        }
        return result;
        
}
static struct triple *integral_promotion(
        struct compile_state *state, struct triple *def)
{
        struct type *type;
        type = def->type;
        /* As all operations are carried out in registers
         * the values are converted on load I just convert
         * logical type of the operand.
         */
        if (TYPE_INTEGER(type->type)) {
                unsigned int int_type;
                int_type = type->type & ~TYPE_MASK;
                int_type |= do_integral_promotion(get_basic_type(type));
                if (int_type != type->type) {
                        if (def->op != OP_LOAD) {
                                def->type = new_type(int_type, 0, 0);
                        }
                        else {
                                def = triple(state, OP_CONVERT, 
                                        new_type(int_type, 0, 0), def, 0);
                        }
                }
        }
        return def;
}


static void arithmetic(struct compile_state *state, struct triple *def)
{
        if (!TYPE_ARITHMETIC(def->type->type)) {
                error(state, 0, "arithmetic type expexted");
        }
}

static void ptr_arithmetic(struct compile_state *state, struct triple *def)
{
        if (!TYPE_PTR(def->type->type) && !TYPE_ARITHMETIC(def->type->type)) {
                error(state, def, "pointer or arithmetic type expected");
        }
}

static int is_integral(struct triple *ins)
{
        return TYPE_INTEGER(ins->type->type);
}

static void integral(struct compile_state *state, struct triple *def)
{
        if (!is_integral(def)) {
                error(state, 0, "integral type expected");
        }
}


static void bool(struct compile_state *state, struct triple *def)
{
        if (!TYPE_ARITHMETIC(def->type->type) &&
                ((def->type->type & TYPE_MASK) != TYPE_POINTER)) {
                error(state, 0, "arithmetic or pointer type expected");
        }
}

static int is_signed(struct type *type)
{
        if ((type->type & TYPE_MASK) == TYPE_BITFIELD) {
                type = type->left;
        }
        return !!TYPE_SIGNED(type->type);
}
static int is_compound_type(struct type *type)
{
        int is_compound;
        switch((type->type & TYPE_MASK)) {
        case TYPE_ARRAY:
        case TYPE_STRUCT:
        case TYPE_TUPLE:
        case TYPE_UNION:
        case TYPE_JOIN: 
                is_compound = 1;
                break;
        default:
                is_compound = 0;
                break;
        }
        return is_compound;
}

/* Is this value located in a register otherwise it must be in memory */
static int is_in_reg(struct compile_state *state, struct triple *def)
{
        int in_reg;
        if (def->op == OP_ADECL) {
                in_reg = 1;
        }
        else if ((def->op == OP_SDECL) || (def->op == OP_DEREF)) {
                in_reg = 0;
        }
        else if (triple_is_part(state, def)) {
                in_reg = is_in_reg(state, MISC(def, 0));
        }
        else {
                internal_error(state, def, "unknown expr storage location");
                in_reg = -1;
        }
        return in_reg;
}

/* Is this an auto or static variable location? Something that can
 * be assigned to.  Otherwise it must must be a pure value, a temporary.
 */
static int is_lvalue(struct compile_state *state, struct triple *def)
{
        int ret;
        ret = 0;
        if (!def) {
                return 0;
        }
        if ((def->op == OP_ADECL) || 
                (def->op == OP_SDECL) || 
                (def->op == OP_DEREF) ||
                (def->op == OP_BLOBCONST) ||
                (def->op == OP_LIST)) {
                ret = 1;
        }
        else if (triple_is_part(state, def)) {
                ret = is_lvalue(state, MISC(def, 0));
        }
        return ret;
}

static void clvalue(struct compile_state *state, struct triple *def)
{
        if (!def) {
                internal_error(state, def, "nothing where lvalue expected?");
        }
        if (!is_lvalue(state, def)) { 
                error(state, def, "lvalue expected");
        }
}
static void lvalue(struct compile_state *state, struct triple *def)
{
        clvalue(state, def);
        if (def->type->type & QUAL_CONST) {
                error(state, def, "modifable lvalue expected");
        }
}

static int is_pointer(struct triple *def)
{
        return (def->type->type & TYPE_MASK) == TYPE_POINTER;
}

static void pointer(struct compile_state *state, struct triple *def)
{
        if (!is_pointer(def)) {
                error(state, def, "pointer expected");
        }
}

static struct triple *int_const(
        struct compile_state *state, struct type *type, ulong_t value)
{
        struct triple *result;
        switch(type->type & TYPE_MASK) {
        case TYPE_CHAR:
        case TYPE_INT:   case TYPE_UINT:
        case TYPE_LONG:  case TYPE_ULONG:
                break;
        default:
                internal_error(state, 0, "constant for unknown type");
        }
        result = triple(state, OP_INTCONST, type, 0, 0);
        result->u.cval = value;
        return result;
}


static struct triple *read_expr(struct compile_state *state, struct triple *def);

static struct triple *do_mk_addr_expr(struct compile_state *state, 
        struct triple *expr, struct type *type, ulong_t offset)
{
        struct triple *result;
        struct type *ptr_type;
        clvalue(state, expr);

        ptr_type = new_type(TYPE_POINTER | (type->type & QUAL_MASK), type, 0);

        
        result = 0;
        if (expr->op == OP_ADECL) {
                error(state, expr, "address of auto variables not supported");
        }
        else if (expr->op == OP_SDECL) {
                result = triple(state, OP_ADDRCONST, ptr_type, 0, 0);
                MISC(result, 0) = expr;
                result->u.cval = offset;
        }
        else if (expr->op == OP_DEREF) {
                result = triple(state, OP_ADD, ptr_type,
                        RHS(expr, 0),
                        int_const(state, &ulong_type, offset));
        }
        else if (expr->op == OP_BLOBCONST) {
                FINISHME();
                internal_error(state, expr, "not yet implemented");
        }
        else if (expr->op == OP_LIST) {
                error(state, 0, "Function addresses not supported");
        }
        else if (triple_is_part(state, expr)) {
                struct triple *part;
                part = expr;
                expr = MISC(expr, 0);
                if (part->op == OP_DOT) {
                        offset += bits_to_bytes(
                                field_offset(state, expr->type, part->u.field));
                }
                else if (part->op == OP_INDEX) {
                        offset += bits_to_bytes(
                                index_offset(state, expr->type, part->u.cval));
                }
                else {
                        internal_error(state, part, "unhandled part type");
                }
                result = do_mk_addr_expr(state, expr, type, offset);
        }
        if (!result) {
                internal_error(state, expr, "cannot take address of expression");
        }
        return result;
}

static struct triple *mk_addr_expr(
        struct compile_state *state, struct triple *expr, ulong_t offset)
{
        return do_mk_addr_expr(state, expr, expr->type, offset);
}

static struct triple *mk_deref_expr(
        struct compile_state *state, struct triple *expr)
{
        struct type *base_type;
        pointer(state, expr);
        base_type = expr->type->left;
        return triple(state, OP_DEREF, base_type, expr, 0);
}

/* lvalue conversions always apply except when certain operators
 * are applied.  So I apply apply it when I know no more
 * operators will be applied.
 */
static struct triple *lvalue_conversion(struct compile_state *state, struct triple *def)
{
        /* Tranform an array to a pointer to the first element */
        if ((def->type->type & TYPE_MASK) == TYPE_ARRAY) {
                struct type *type;
                type = new_type(
                        TYPE_POINTER | (def->type->type & QUAL_MASK),
                        def->type->left, 0);
                if ((def->op == OP_SDECL) || IS_CONST_OP(def->op)) {
                        struct triple *addrconst;
                        if ((def->op != OP_SDECL) && (def->op != OP_BLOBCONST)) {
                                internal_error(state, def, "bad array constant");
                        }
                        addrconst = triple(state, OP_ADDRCONST, type, 0, 0);
                        MISC(addrconst, 0) = def;
                        def = addrconst;
                }
                else {
                        def = triple(state, OP_CONVERT, type, def, 0);
                }
        }
        /* Transform a function to a pointer to it */
        else if ((def->type->type & TYPE_MASK) == TYPE_FUNCTION) {
                def = mk_addr_expr(state, def, 0);
        }
        return def;
}

static struct triple *deref_field(
        struct compile_state *state, struct triple *expr, struct hash_entry *field)
{
        struct triple *result;
        struct type *type, *member;
        ulong_t offset;
        if (!field) {
                internal_error(state, 0, "No field passed to deref_field");
        }
        result = 0;
        type = expr->type;
        if (((type->type & TYPE_MASK) != TYPE_STRUCT) &&
                ((type->type & TYPE_MASK) != TYPE_UNION)) {
                error(state, 0, "request for member %s in something not a struct or union",
                        field->name);
        }
        member = field_type(state, type, field);
        if ((type->type & STOR_MASK) == STOR_PERM) {
                /* Do the pointer arithmetic to get a deref the field */
                offset = bits_to_bytes(field_offset(state, type, field));
                result = do_mk_addr_expr(state, expr, member, offset);
                result = mk_deref_expr(state, result);
        }
        else {
                /* Find the variable for the field I want. */
                result = triple(state, OP_DOT, member, expr, 0);
                result->u.field = field;
        }
        return result;
}

static struct triple *deref_index(
        struct compile_state *state, struct triple *expr, size_t index)
{
        struct triple *result;
        struct type *type, *member;
        ulong_t offset;

        result = 0;
        type = expr->type;
        member = index_type(state, type, index);

        if ((type->type & STOR_MASK) == STOR_PERM) {
                offset = bits_to_bytes(index_offset(state, type, index));
                result = do_mk_addr_expr(state, expr, member, offset);
                result = mk_deref_expr(state, result);
        }
        else {
                result = triple(state, OP_INDEX, member, expr, 0);
                result->u.cval = index;
        }
        return result;
}

static struct triple *read_expr(struct compile_state *state, struct triple *def)
{
        int op;
        if  (!def) {
                return 0;
        }
#warning "CHECK_ME is this the only place I need to do lvalue conversions?"
        /* Transform lvalues into something we can read */
        def = lvalue_conversion(state, def);
        if (!is_lvalue(state, def)) {
                return def;
        }
        if (is_in_reg(state, def)) {
                op = OP_READ;
        } else {
                if (def->op == OP_SDECL) {
                        def = mk_addr_expr(state, def, 0);
                        def = mk_deref_expr(state, def);
                }
                op = OP_LOAD;
        }
        def = triple(state, op, def->type, def, 0);
        if (def->type->type & QUAL_VOLATILE) {
                def->id |= TRIPLE_FLAG_VOLATILE;
        }
        return def;
}

int is_write_compatible(struct compile_state *state, 
        struct type *dest, struct type *rval)
{
        int compatible = 0;
        /* Both operands have arithmetic type */
        if (TYPE_ARITHMETIC(dest->type) && TYPE_ARITHMETIC(rval->type)) {
                compatible = 1;
        }
        /* One operand is a pointer and the other is a pointer to void */
        else if (((dest->type & TYPE_MASK) == TYPE_POINTER) &&
                ((rval->type & TYPE_MASK) == TYPE_POINTER) &&
                (((dest->left->type & TYPE_MASK) == TYPE_VOID) ||
                        ((rval->left->type & TYPE_MASK) == TYPE_VOID))) {
                compatible = 1;
        }
        /* If both types are the same without qualifiers we are good */
        else if (equiv_ptrs(dest, rval)) {
                compatible = 1;
        }
        /* test for struct/union equality  */
        else if (equiv_types(dest, rval)) {
                compatible = 1;
        }
        return compatible;
}

static void write_compatible(struct compile_state *state,
        struct type *dest, struct type *rval)
{
        if (!is_write_compatible(state, dest, rval)) {
                FILE *fp = state->errout;
                fprintf(fp, "dest: ");
                name_of(fp, dest);
                fprintf(fp,"\nrval: ");
                name_of(fp, rval);
                fprintf(fp, "\n");
                error(state, 0, "Incompatible types in assignment");
        }
}

static int is_init_compatible(struct compile_state *state,
        struct type *dest, struct type *rval)
{
        int compatible = 0;
        if (is_write_compatible(state, dest, rval)) {
                compatible = 1;
        }
        else if (equiv_types(dest, rval)) {
                compatible = 1;
        }
        return compatible;
}

static struct triple *write_expr(
        struct compile_state *state, struct triple *dest, struct triple *rval)
{
        struct triple *def;
        int op;

        def = 0;
        if (!rval) {
                internal_error(state, 0, "missing rval");
        }

        if (rval->op == OP_LIST) {
                internal_error(state, 0, "expression of type OP_LIST?");
        }
        if (!is_lvalue(state, dest)) {
                internal_error(state, 0, "writing to a non lvalue?");
        }
        if (dest->type->type & QUAL_CONST) {
                internal_error(state, 0, "modifable lvalue expexted");
        }

        write_compatible(state, dest->type, rval->type);
        if (!equiv_types(dest->type, rval->type)) {
                rval = triple(state, OP_CONVERT, dest->type, rval, 0);
        }

        /* Now figure out which assignment operator to use */
        op = -1;
        if (is_in_reg(state, dest)) {
                def = triple(state, OP_WRITE, dest->type, rval, dest);
                if (MISC(def, 0) != dest) {
                        internal_error(state, def, "huh?");
                }
                if (RHS(def, 0) != rval) {
                        internal_error(state, def, "huh?");
                }
        } else {
                def = triple(state, OP_STORE, dest->type, dest, rval);
        }
        if (def->type->type & QUAL_VOLATILE) {
                def->id |= TRIPLE_FLAG_VOLATILE;
        }
        return def;
}

static struct triple *init_expr(
        struct compile_state *state, struct triple *dest, struct triple *rval)
{
        struct triple *def;

        def = 0;
        if (!rval) {
                internal_error(state, 0, "missing rval");
        }
        if ((dest->type->type & STOR_MASK) != STOR_PERM) {
                rval = read_expr(state, rval);
                def = write_expr(state, dest, rval);
        }
        else {
                /* Fill in the array size if necessary */
                if (((dest->type->type & TYPE_MASK) == TYPE_ARRAY) &&
                        ((rval->type->type & TYPE_MASK) == TYPE_ARRAY)) {
                        if (dest->type->elements == ELEMENT_COUNT_UNSPECIFIED) {
                                dest->type->elements = rval->type->elements;
                        }
                }
                if (!equiv_types(dest->type, rval->type)) {
                        error(state, 0, "Incompatible types in inializer");
                }
                MISC(dest, 0) = rval;
                insert_triple(state, dest, rval);
                rval->id |= TRIPLE_FLAG_FLATTENED;
                use_triple(MISC(dest, 0), dest);
        }
        return def;
}

struct type *arithmetic_result(
        struct compile_state *state, struct triple *left, struct triple *right)
{
        struct type *type;
        /* Sanity checks to ensure I am working with arithmetic types */
        arithmetic(state, left);
        arithmetic(state, right);
        type = new_type(
                do_arithmetic_conversion(
                        get_basic_type(left->type),
                        get_basic_type(right->type)),
                0, 0);
        return type;
}

struct type *ptr_arithmetic_result(
        struct compile_state *state, struct triple *left, struct triple *right)
{
        struct type *type;
        /* Sanity checks to ensure I am working with the proper types */
        ptr_arithmetic(state, left);
        arithmetic(state, right);
        if (TYPE_ARITHMETIC(left->type->type) && 
                TYPE_ARITHMETIC(right->type->type)) {
                type = arithmetic_result(state, left, right);
        }
        else if (TYPE_PTR(left->type->type)) {
                type = left->type;
        }
        else {
                internal_error(state, 0, "huh?");
                type = 0;
        }
        return type;
}

/* boolean helper function */

static struct triple *ltrue_expr(struct compile_state *state, 
        struct triple *expr)
{
        switch(expr->op) {
        case OP_LTRUE:   case OP_LFALSE:  case OP_EQ:      case OP_NOTEQ:
        case OP_SLESS:   case OP_ULESS:   case OP_SMORE:   case OP_UMORE:
        case OP_SLESSEQ: case OP_ULESSEQ: case OP_SMOREEQ: case OP_UMOREEQ:
                /* If the expression is already boolean do nothing */
                break;
        default:
                expr = triple(state, OP_LTRUE, &int_type, expr, 0);
                break;
        }
        return expr;
}

static struct triple *lfalse_expr(struct compile_state *state, 
        struct triple *expr)
{
        return triple(state, OP_LFALSE, &int_type, expr, 0);
}

static struct triple *mkland_expr(
        struct compile_state *state,
        struct triple *left, struct triple *right)
{
        struct triple *def, *val, *var, *jmp, *mid, *end;
        struct triple *lstore, *rstore;

        /* Generate some intermediate triples */
        end = label(state);
        var = variable(state, &int_type);
        
        /* Store the left hand side value */
        lstore = write_expr(state, var, left);

        /* Jump if the value is false */
        jmp =  branch(state, end, 
                lfalse_expr(state, read_expr(state, var)));
        mid = label(state);
        
        /* Store the right hand side value */
        rstore = write_expr(state, var, right);

        /* An expression for the computed value */
        val = read_expr(state, var);

        /* Generate the prog for a logical and */
        def = mkprog(state, var, lstore, jmp, mid, rstore, end, val, 0);
        
        return def;
}

static struct triple *mklor_expr(
        struct compile_state *state,
        struct triple *left, struct triple *right)
{
        struct triple *def, *val, *var, *jmp, *mid, *end;

        /* Generate some intermediate triples */
        end = label(state);
        var = variable(state, &int_type);
        
        /* Store the left hand side value */
        left = write_expr(state, var, left);
        
        /* Jump if the value is true */
        jmp = branch(state, end, read_expr(state, var));
        mid = label(state);
        
        /* Store the right hand side value */
        right = write_expr(state, var, right);
                
        /* An expression for the computed value*/
        val = read_expr(state, var);

        /* Generate the prog for a logical or */
        def = mkprog(state, var, left, jmp, mid, right, end, val, 0);

        return def;
}

static struct triple *mkcond_expr(
        struct compile_state *state, 
        struct triple *test, struct triple *left, struct triple *right)
{
        struct triple *def, *val, *var, *jmp1, *jmp2, *top, *mid, *end;
        struct type *result_type;
        unsigned int left_type, right_type;
        bool(state, test);
        left_type = left->type->type;
        right_type = right->type->type;
        result_type = 0;
        /* Both operands have arithmetic type */
        if (TYPE_ARITHMETIC(left_type) && TYPE_ARITHMETIC(right_type)) {
                result_type = arithmetic_result(state, left, right);
        }
        /* Both operands have void type */
        else if (((left_type & TYPE_MASK) == TYPE_VOID) &&
                ((right_type & TYPE_MASK) == TYPE_VOID)) {
                result_type = &void_type;
        }
        /* pointers to the same type... */
        else if ((result_type = compatible_ptrs(left->type, right->type))) {
                ;
        }
        /* Both operands are pointers and left is a pointer to void */
        else if (((left_type & TYPE_MASK) == TYPE_POINTER) &&
                ((right_type & TYPE_MASK) == TYPE_POINTER) &&
                ((left->type->left->type & TYPE_MASK) == TYPE_VOID)) {
                result_type = right->type;
        }
        /* Both operands are pointers and right is a pointer to void */
        else if (((left_type & TYPE_MASK) == TYPE_POINTER) &&
                ((right_type & TYPE_MASK) == TYPE_POINTER) &&
                ((right->type->left->type & TYPE_MASK) == TYPE_VOID)) {
                result_type = left->type;
        }
        if (!result_type) {
                error(state, 0, "Incompatible types in conditional expression");
        }
        /* Generate some intermediate triples */
        mid = label(state);
        end = label(state);
        var = variable(state, result_type);

        /* Branch if the test is false */
        jmp1 = branch(state, mid, lfalse_expr(state, read_expr(state, test)));
        top = label(state);

        /* Store the left hand side value */
        left = write_expr(state, var, left);

        /* Branch to the end */
        jmp2 = branch(state, end, 0);

        /* Store the right hand side value */
        right = write_expr(state, var, right);
        
        /* An expression for the computed value */
        val = read_expr(state, var);

        /* Generate the prog for a conditional expression */
        def = mkprog(state, var, jmp1, top, left, jmp2, mid, right, end, val, 0);

        return def;
}


static int expr_depth(struct compile_state *state, struct triple *ins)
{
#warning "FIXME move optimal ordering of subexpressions into the optimizer"
        int count;
        count = 0;
        if (!ins || (ins->id & TRIPLE_FLAG_FLATTENED)) {
                count = 0;
        }
        else if (ins->op == OP_DEREF) {
                count = expr_depth(state, RHS(ins, 0)) - 1;
        }
        else if (ins->op == OP_VAL) {
                count = expr_depth(state, RHS(ins, 0)) - 1;
        }
        else if (ins->op == OP_FCALL) {
                /* Don't figure the depth of a call just guess it is huge */
                count = 1000;
        }
        else {
                struct triple **expr;
                expr = triple_rhs(state, ins, 0);
                for(;expr; expr = triple_rhs(state, ins, expr)) {
                        if (*expr) {
                                int depth;
                                depth = expr_depth(state, *expr);
                                if (depth > count) {
                                        count = depth;
                                }
                        }
                }
        }
        return count + 1;
}

static struct triple *flatten_generic(
        struct compile_state *state, struct triple *first, struct triple *ptr,
        int ignored)
{
        struct rhs_vector {
                int depth;
                struct triple **ins;
        } vector[MAX_RHS];
        int i, rhs, lhs;
        /* Only operations with just a rhs and a lhs should come here */
        rhs = ptr->rhs;
        lhs = ptr->lhs;
        if (TRIPLE_SIZE(ptr) != lhs + rhs + ignored) {
                internal_error(state, ptr, "unexpected args for: %d %s",
                        ptr->op, tops(ptr->op));
        }
        /* Find the depth of the rhs elements */
        for(i = 0; i < rhs; i++) {
                vector[i].ins = &RHS(ptr, i);
                vector[i].depth = expr_depth(state, *vector[i].ins);
        }
        /* Selection sort the rhs */
        for(i = 0; i < rhs; i++) {
                int j, max = i;
                for(j = i + 1; j < rhs; j++ ) {
                        if (vector[j].depth > vector[max].depth) {
                                max = j;
                        }
                }
                if (max != i) {
                        struct rhs_vector tmp;
                        tmp = vector[i];
                        vector[i] = vector[max];
                        vector[max] = tmp;
                }
        }
        /* Now flatten the rhs elements */
        for(i = 0; i < rhs; i++) {
                *vector[i].ins = flatten(state, first, *vector[i].ins);
                use_triple(*vector[i].ins, ptr);
        }
        if (lhs) {
                insert_triple(state, first, ptr);
                ptr->id |= TRIPLE_FLAG_FLATTENED;
                ptr->id &= ~TRIPLE_FLAG_LOCAL;
                
                /* Now flatten the lhs elements */
                for(i = 0; i < lhs; i++) {
                        struct triple **ins = &LHS(ptr, i);
                        *ins = flatten(state, first, *ins);
                        use_triple(*ins, ptr);
                }
        }
        return ptr;
}

static struct triple *flatten_prog(
        struct compile_state *state, struct triple *first, struct triple *ptr)
{
        struct triple *head, *body, *val;
        head = RHS(ptr, 0);
        RHS(ptr, 0) = 0;
        val  = head->prev;
        body = head->next;
        release_triple(state, head);
        release_triple(state, ptr);
        val->next        = first;
        body->prev       = first->prev;
        body->prev->next = body;
        val->next->prev  = val;

        if (triple_is_cbranch(state, body->prev) ||
                triple_is_call(state, body->prev)) {
                unuse_triple(first, body->prev);
                use_triple(body, body->prev);
        }
        
        if (!(val->id & TRIPLE_FLAG_FLATTENED)) {
                internal_error(state, val, "val not flattened?");
        }

        return val;
}


static struct triple *flatten_part(
        struct compile_state *state, struct triple *first, struct triple *ptr)
{
        if (!triple_is_part(state, ptr)) {
                internal_error(state, ptr,  "not a part");
        }
        if (ptr->rhs || ptr->lhs || ptr->targ || (ptr->misc != 1)) {
                internal_error(state, ptr, "unexpected args for: %d %s",
                        ptr->op, tops(ptr->op));
        }
        MISC(ptr, 0) = flatten(state, first, MISC(ptr, 0));
        use_triple(MISC(ptr, 0), ptr);
        return flatten_generic(state, first, ptr, 1);
}

static struct triple *flatten(
        struct compile_state *state, struct triple *first, struct triple *ptr)
{
        struct triple *orig_ptr;
        if (!ptr)
                return 0;
        do {
                orig_ptr = ptr;
                /* Only flatten triples once */
                if (ptr->id & TRIPLE_FLAG_FLATTENED) {
                        return ptr;
                }
                switch(ptr->op) {
                case OP_VAL:
                        RHS(ptr, 0) = flatten(state, first, RHS(ptr, 0));
                        return MISC(ptr, 0);
                        break;
                case OP_PROG:
                        ptr = flatten_prog(state, first, ptr);
                        break;
                case OP_FCALL:
                        ptr = flatten_generic(state, first, ptr, 1);
                        insert_triple(state, first, ptr);
                        ptr->id |= TRIPLE_FLAG_FLATTENED;
                        ptr->id &= ~TRIPLE_FLAG_LOCAL;
                        if (ptr->next != ptr) {
                                use_triple(ptr->next, ptr);
                        }
                        break;
                case OP_READ:
                case OP_LOAD:
                        RHS(ptr, 0) = flatten(state, first, RHS(ptr, 0));
                        use_triple(RHS(ptr, 0), ptr);
                        break;
                case OP_WRITE:
                        ptr = flatten_generic(state, first, ptr, 1);
                        MISC(ptr, 0) = flatten(state, first, MISC(ptr, 0));
                        use_triple(MISC(ptr, 0), ptr);
                        break;
                case OP_BRANCH:
                        use_triple(TARG(ptr, 0), ptr);
                        break;
                case OP_CBRANCH:
                        RHS(ptr, 0) = flatten(state, first, RHS(ptr, 0));
                        use_triple(RHS(ptr, 0), ptr);
                        use_triple(TARG(ptr, 0), ptr);
                        insert_triple(state, first, ptr);
                        ptr->id |= TRIPLE_FLAG_FLATTENED;
                        ptr->id &= ~TRIPLE_FLAG_LOCAL;
                        if (ptr->next != ptr) {
                                use_triple(ptr->next, ptr);
                        }
                        break;
                case OP_CALL:
                        MISC(ptr, 0) = flatten(state, first, MISC(ptr, 0));
                        use_triple(MISC(ptr, 0), ptr);
                        use_triple(TARG(ptr, 0), ptr);
                        insert_triple(state, first, ptr);
                        ptr->id |= TRIPLE_FLAG_FLATTENED;
                        ptr->id &= ~TRIPLE_FLAG_LOCAL;
                        if (ptr->next != ptr) {
                                use_triple(ptr->next, ptr);
                        }
                        break;
                case OP_RET:
                        RHS(ptr, 0) = flatten(state, first, RHS(ptr, 0));
                        use_triple(RHS(ptr, 0), ptr);
                        break;
                case OP_BLOBCONST:
                        insert_triple(state, state->global_pool, ptr);
                        ptr->id |= TRIPLE_FLAG_FLATTENED;
                        ptr->id &= ~TRIPLE_FLAG_LOCAL;
                        ptr = triple(state, OP_SDECL, ptr->type, ptr, 0);
                        use_triple(MISC(ptr, 0), ptr);
                        break;
                case OP_DEREF:
                        /* Since OP_DEREF is just a marker delete it when I flatten it */
                        ptr = RHS(ptr, 0);
                        RHS(orig_ptr, 0) = 0;
                        free_triple(state, orig_ptr);
                        break;
                case OP_DOT:
                        if (RHS(ptr, 0)->op == OP_DEREF) {
                                struct triple *base, *left;
                                ulong_t offset;
                                base = MISC(ptr, 0);
                                offset = bits_to_bytes(field_offset(state, base->type, ptr->u.field));
                                left = RHS(base, 0);
                                ptr = triple(state, OP_ADD, left->type, 
                                        read_expr(state, left),
                                        int_const(state, &ulong_type, offset));
                                free_triple(state, base);
                        }
                        else {
                                ptr = flatten_part(state, first, ptr);
                        }
                        break;
                case OP_INDEX:
                        if (RHS(ptr, 0)->op == OP_DEREF) {
                                struct triple *base, *left;
                                ulong_t offset;
                                base = MISC(ptr, 0);
                                offset = bits_to_bytes(index_offset(state, base->type, ptr->u.cval));
                                left = RHS(base, 0);
                                ptr = triple(state, OP_ADD, left->type,
                                        read_expr(state, left),
                                        int_const(state, &long_type, offset));
                                free_triple(state, base);
                        }
                        else {
                                ptr = flatten_part(state, first, ptr);
                        }
                        break;
                case OP_PIECE:
                        ptr = flatten_part(state, first, ptr);
                        use_triple(ptr, MISC(ptr, 0));
                        break;
                case OP_ADDRCONST:
                        MISC(ptr, 0) = flatten(state, first, MISC(ptr, 0));
                        use_triple(MISC(ptr, 0), ptr);
                        break;
                case OP_SDECL:
                        first = state->global_pool;
                        MISC(ptr, 0) = flatten(state, first, MISC(ptr, 0));
                        use_triple(MISC(ptr, 0), ptr);
                        insert_triple(state, first, ptr);
                        ptr->id |= TRIPLE_FLAG_FLATTENED;
                        ptr->id &= ~TRIPLE_FLAG_LOCAL;
                        return ptr;
                case OP_ADECL:
                        ptr = flatten_generic(state, first, ptr, 0);
                        break;
                default:
                        /* Flatten the easy cases we don't override */
                        ptr = flatten_generic(state, first, ptr, 0);
                        break;
                }
        } while(ptr && (ptr != orig_ptr));
        if (ptr && !(ptr->id & TRIPLE_FLAG_FLATTENED)) {
                insert_triple(state, first, ptr);
                ptr->id |= TRIPLE_FLAG_FLATTENED;
                ptr->id &= ~TRIPLE_FLAG_LOCAL;
        }
        return ptr;
}

static void release_expr(struct compile_state *state, struct triple *expr)
{
        struct triple *head;
        head = label(state);
        flatten(state, head, expr);
        while(head->next != head) {
                release_triple(state, head->next);
        }
        free_triple(state, head);
}

static int replace_rhs_use(struct compile_state *state,
        struct triple *orig, struct triple *new, struct triple *use)
{
        struct triple **expr;
        int found;
        found = 0;
        expr = triple_rhs(state, use, 0);
        for(;expr; expr = triple_rhs(state, use, expr)) {
                if (*expr == orig) {
                        *expr = new;
                        found = 1;
                }
        }
        if (found) {
                unuse_triple(orig, use);
                use_triple(new, use);
        }
        return found;
}

static int replace_lhs_use(struct compile_state *state,
        struct triple *orig, struct triple *new, struct triple *use)
{
        struct triple **expr;
        int found;
        found = 0;
        expr = triple_lhs(state, use, 0);
        for(;expr; expr = triple_lhs(state, use, expr)) {
                if (*expr == orig) {
                        *expr = new;
                        found = 1;
                }
        }
        if (found) {
                unuse_triple(orig, use);
                use_triple(new, use);
        }
        return found;
}

static int replace_misc_use(struct compile_state *state,
        struct triple *orig, struct triple *new, struct triple *use)
{
        struct triple **expr;
        int found;
        found = 0;
        expr = triple_misc(state, use, 0);
        for(;expr; expr = triple_misc(state, use, expr)) {
                if (*expr == orig) {
                        *expr = new;
                        found = 1;
                }
        }
        if (found) {
                unuse_triple(orig, use);
                use_triple(new, use);
        }
        return found;
}

static int replace_targ_use(struct compile_state *state,
        struct triple *orig, struct triple *new, struct triple *use)
{
        struct triple **expr;
        int found;
        found = 0;
        expr = triple_targ(state, use, 0);
        for(;expr; expr = triple_targ(state, use, expr)) {
                if (*expr == orig) {
                        *expr = new;
                        found = 1;
                }
        }
        if (found) {
                unuse_triple(orig, use);
                use_triple(new, use);
        }
        return found;
}

static void replace_use(struct compile_state *state,
        struct triple *orig, struct triple *new, struct triple *use)
{
        int found;
        found = 0;
        found |= replace_rhs_use(state, orig, new, use);
        found |= replace_lhs_use(state, orig, new, use);
        found |= replace_misc_use(state, orig, new, use);
        found |= replace_targ_use(state, orig, new, use);
        if (!found) {
                internal_error(state, use, "use without use");
        }
}

static void propogate_use(struct compile_state *state,
        struct triple *orig, struct triple *new)
{
        struct triple_set *user, *next;
        for(user = orig->use; user; user = next) {
                /* Careful replace_use modifies the use chain and
                 * removes use.  So we must get a copy of the next
                 * entry early.
                 */
                next = user->next;
                replace_use(state, orig, new, user->member);
        }
        if (orig->use) {
                internal_error(state, orig, "used after propogate_use");
        }
}

/*
 * Code generators
 * ===========================
 */

static struct triple *mk_cast_expr(
        struct compile_state *state, struct type *type, struct triple *expr)
{
        struct triple *def;
        def = read_expr(state, expr);
        def = triple(state, OP_CONVERT, type, def, 0);
        return def;
}

static struct triple *mk_add_expr(
        struct compile_state *state, struct triple *left, struct triple *right)
{
        struct type *result_type;
        /* Put pointer operands on the left */
        if (is_pointer(right)) {
                struct triple *tmp;
                tmp = left;
                left = right;
                right = tmp;
        }
        left  = read_expr(state, left);
        right = read_expr(state, right);
        result_type = ptr_arithmetic_result(state, left, right);
        if (is_pointer(left)) {
                struct type *ptr_math;
                int op;
                if (is_signed(right->type)) {
                        ptr_math = &long_type;
                        op = OP_SMUL;
                } else {
                        ptr_math = &ulong_type;
                        op = OP_UMUL;
                }
                if (!equiv_types(right->type, ptr_math)) {
                        right = mk_cast_expr(state, ptr_math, right);
                }
                right = triple(state, op, ptr_math, right, 
                        int_const(state, ptr_math, 
                                size_of_in_bytes(state, left->type->left)));
        }
        return triple(state, OP_ADD, result_type, left, right);
}

static struct triple *mk_sub_expr(
        struct compile_state *state, struct triple *left, struct triple *right)
{
        struct type *result_type;
        result_type = ptr_arithmetic_result(state, left, right);
        left  = read_expr(state, left);
        right = read_expr(state, right);
        if (is_pointer(left)) {
                struct type *ptr_math;
                int op;
                if (is_signed(right->type)) {
                        ptr_math = &long_type;
                        op = OP_SMUL;
                } else {
                        ptr_math = &ulong_type;
                        op = OP_UMUL;
                }
                if (!equiv_types(right->type, ptr_math)) {
                        right = mk_cast_expr(state, ptr_math, right);
                }
                right = triple(state, op, ptr_math, right, 
                        int_const(state, ptr_math, 
                                size_of_in_bytes(state, left->type->left)));
        }
        return triple(state, OP_SUB, result_type, left, right);
}

static struct triple *mk_pre_inc_expr(
        struct compile_state *state, struct triple *def)
{
        struct triple *val;
        lvalue(state, def);
        val = mk_add_expr(state, def, int_const(state, &int_type, 1));
        return triple(state, OP_VAL, def->type,
                write_expr(state, def, val),
                val);
}

static struct triple *mk_pre_dec_expr(
        struct compile_state *state, struct triple *def)
{
        struct triple *val;
        lvalue(state, def);
        val = mk_sub_expr(state, def, int_const(state, &int_type, 1));
        return triple(state, OP_VAL, def->type,
                write_expr(state, def, val),
                val);
}

static struct triple *mk_post_inc_expr(
        struct compile_state *state, struct triple *def)
{
        struct triple *val;
        lvalue(state, def);
        val = read_expr(state, def);
        return triple(state, OP_VAL, def->type,
                write_expr(state, def,
                        mk_add_expr(state, val, int_const(state, &int_type, 1)))
                , val);
}

static struct triple *mk_post_dec_expr(
        struct compile_state *state, struct triple *def)
{
        struct triple *val;
        lvalue(state, def);
        val = read_expr(state, def);
        return triple(state, OP_VAL, def->type, 
                write_expr(state, def,
                        mk_sub_expr(state, val, int_const(state, &int_type, 1)))
                , val);
}

static struct triple *mk_subscript_expr(
        struct compile_state *state, struct triple *left, struct triple *right)
{
        left  = read_expr(state, left);
        right = read_expr(state, right);
        if (!is_pointer(left) && !is_pointer(right)) {
                error(state, left, "subscripted value is not a pointer");
        }
        return mk_deref_expr(state, mk_add_expr(state, left, right));
}


/*
 * Compile time evaluation
 * ===========================
 */
static int is_const(struct triple *ins)
{
        return IS_CONST_OP(ins->op);
}

static int is_simple_const(struct triple *ins)
{
        /* Is this a constant that u.cval has the value.
         * Or equivalently is this a constant that read_const
         * works on.
         * So far only OP_INTCONST qualifies.  
         */
        return (ins->op == OP_INTCONST);
}

static int constants_equal(struct compile_state *state, 
        struct triple *left, struct triple *right)
{
        int equal;
        if ((left->op == OP_UNKNOWNVAL) || (right->op == OP_UNKNOWNVAL)) {
                equal = 0;
        }
        else if (!is_const(left) || !is_const(right)) {
                equal = 0;
        }
        else if (left->op != right->op) {
                equal = 0;
        }
        else if (!equiv_types(left->type, right->type)) {
                equal = 0;
        }
        else {
                equal = 0;
                switch(left->op) {
                case OP_INTCONST:
                        if (left->u.cval == right->u.cval) {
                                equal = 1;
                        }
                        break;
                case OP_BLOBCONST:
                {
                        size_t lsize, rsize, bytes;
                        lsize = size_of(state, left->type);
                        rsize = size_of(state, right->type);
                        if (lsize != rsize) {
                                break;
                        }
                        bytes = bits_to_bytes(lsize);
                        if (memcmp(left->u.blob, right->u.blob, bytes) == 0) {
                                equal = 1;
                        }
                        break;
                }
                case OP_ADDRCONST:
                        if ((MISC(left, 0) == MISC(right, 0)) &&
                                (left->u.cval == right->u.cval)) {
                                equal = 1;
                        }
                        break;
                default:
                        internal_error(state, left, "uknown constant type");
                        break;
                }
        }
        return equal;
}

static int is_zero(struct triple *ins)
{
        return is_simple_const(ins) && (ins->u.cval == 0);
}

static int is_one(struct triple *ins)
{
        return is_simple_const(ins) && (ins->u.cval == 1);
}

static long_t bit_count(ulong_t value)
{
        int count;
        int i;
        count = 0;
        for(i = (sizeof(ulong_t)*8) -1; i >= 0; i--) {
                ulong_t mask;
                mask = 1;
                mask <<= i;
                if (value & mask) {
                        count++;
                }
        }
        return count;
        
}
static long_t bsr(ulong_t value)
{
        int i;
        for(i = (sizeof(ulong_t)*8) -1; i >= 0; i--) {
                ulong_t mask;
                mask = 1;
                mask <<= i;
                if (value & mask) {
                        return i;
                }
        }
        return -1;
}

static long_t bsf(ulong_t value)
{
        int i;
        for(i = 0; i < (sizeof(ulong_t)*8); i++) {
                ulong_t mask;
                mask = 1;
                mask <<= 1;
                if (value & mask) {
                        return i;
                }
        }
        return -1;
}

static long_t ilog2(ulong_t value)
{
        return bsr(value);
}

static long_t tlog2(struct triple *ins)
{
        return ilog2(ins->u.cval);
}

static int is_pow2(struct triple *ins)
{
        ulong_t value, mask;
        long_t log;
        if (!is_const(ins)) {
                return 0;
        }
        value = ins->u.cval;
        log = ilog2(value);
        if (log == -1) {
                return 0;
        }
        mask = 1;
        mask <<= log;
        return  ((value & mask) == value);
}

static ulong_t read_const(struct compile_state *state,
        struct triple *ins, struct triple *rhs)
{
        switch(rhs->type->type &TYPE_MASK) {
        case TYPE_CHAR:   
        case TYPE_SHORT:
        case TYPE_INT:
        case TYPE_LONG:
        case TYPE_UCHAR:   
        case TYPE_USHORT:  
        case TYPE_UINT:
        case TYPE_ULONG:
        case TYPE_POINTER:
        case TYPE_BITFIELD:
                break;
        default:
                fprintf(state->errout, "type: ");
                name_of(state->errout, rhs->type);
                fprintf(state->errout, "\n");
                internal_warning(state, rhs, "bad type to read_const");
                break;
        }
        if (!is_simple_const(rhs)) {
                internal_error(state, rhs, "bad op to read_const");
        }
        return rhs->u.cval;
}

static long_t read_sconst(struct compile_state *state,
        struct triple *ins, struct triple *rhs)
{
        return (long_t)(rhs->u.cval);
}

int const_ltrue(struct compile_state *state, struct triple *ins, struct triple *rhs)
{
        if (!is_const(rhs)) {
                internal_error(state, 0, "non const passed to const_true");
        }
        return !is_zero(rhs);
}

int const_eq(struct compile_state *state, struct triple *ins,
        struct triple *left, struct triple *right)
{
        int result;
        if (!is_const(left) || !is_const(right)) {
                internal_warning(state, ins, "non const passed to const_eq");
                result = -1;
        }
        else if (left == right) {
                result = 1;
        }
        else if (is_simple_const(left) && is_simple_const(right)) {
                ulong_t lval, rval;
                lval = read_const(state, ins, left);
                rval = read_const(state, ins, right);
                result = (lval == rval);
        }
        else if ((left->op == OP_ADDRCONST) && 
                (right->op == OP_ADDRCONST)) {
                result = (MISC(left, 0) == MISC(right, 0)) &&
                        (left->u.cval == right->u.cval);
        }
        else {
                internal_warning(state, ins, "incomparable constants passed to const_eq");
                result = -1;
        }
        return result;
        
}

int const_ucmp(struct compile_state *state, struct triple *ins,
        struct triple *left, struct triple *right)
{
        int result;
        if (!is_const(left) || !is_const(right)) {
                internal_warning(state, ins, "non const past to const_ucmp");
                result = -2;
        }
        else if (left == right) {
                result = 0;
        }
        else if (is_simple_const(left) && is_simple_const(right)) {
                ulong_t lval, rval;
                lval = read_const(state, ins, left);
                rval = read_const(state, ins, right);
                result = 0;
                if (lval > rval) {
                        result = 1;
                } else if (rval > lval) {
                        result = -1;
                }
        }
        else if ((left->op == OP_ADDRCONST) && 
                (right->op == OP_ADDRCONST) &&
                (MISC(left, 0) == MISC(right, 0))) {
                result = 0;
                if (left->u.cval > right->u.cval) {
                        result = 1;
                } else if (left->u.cval < right->u.cval) {
                        result = -1;
                }
        }
        else {
                internal_warning(state, ins, "incomparable constants passed to const_ucmp");
                result = -2;
        }
        return result;
}

int const_scmp(struct compile_state *state, struct triple *ins,
        struct triple *left, struct triple *right)
{
        int result;
        if (!is_const(left) || !is_const(right)) {
                internal_warning(state, ins, "non const past to ucmp_const");
                result = -2;
        }
        else if (left == right) {
                result = 0;
        }
        else if (is_simple_const(left) && is_simple_const(right)) {
                long_t lval, rval;
                lval = read_sconst(state, ins, left);
                rval = read_sconst(state, ins, right);
                result = 0;
                if (lval > rval) {
                        result = 1;
                } else if (rval > lval) {
                        result = -1;
                }
        }
        else {
                internal_warning(state, ins, "incomparable constants passed to const_scmp");
                result = -2;
        }
        return result;
}

static void unuse_rhs(struct compile_state *state, struct triple *ins)
{
        struct triple **expr;
        expr = triple_rhs(state, ins, 0);
        for(;expr;expr = triple_rhs(state, ins, expr)) {
                if (*expr) {
                        unuse_triple(*expr, ins);
                        *expr = 0;
                }
        }
}

static void unuse_lhs(struct compile_state *state, struct triple *ins)
{
        struct triple **expr;
        expr = triple_lhs(state, ins, 0);
        for(;expr;expr = triple_lhs(state, ins, expr)) {
                unuse_triple(*expr, ins);
                *expr = 0;
        }
}

static void unuse_misc(struct compile_state *state, struct triple *ins)
{
        struct triple **expr;
        expr = triple_misc(state, ins, 0);
        for(;expr;expr = triple_misc(state, ins, expr)) {
                unuse_triple(*expr, ins);
                *expr = 0;
        }
}

static void unuse_targ(struct compile_state *state, struct triple *ins)
{
        int i;
        struct triple **slot;
        slot = &TARG(ins, 0);
        for(i = 0; i < ins->targ; i++) {
                unuse_triple(slot[i], ins);
                slot[i] = 0;
        }
}

static void check_lhs(struct compile_state *state, struct triple *ins)
{
        struct triple **expr;
        expr = triple_lhs(state, ins, 0);
        for(;expr;expr = triple_lhs(state, ins, expr)) {
                internal_error(state, ins, "unexpected lhs");
        }
        
}

static void check_misc(struct compile_state *state, struct triple *ins)
{
        struct triple **expr;
        expr = triple_misc(state, ins, 0);
        for(;expr;expr = triple_misc(state, ins, expr)) {
                if (*expr) {
                        internal_error(state, ins, "unexpected misc");
                }
        }
}

static void check_targ(struct compile_state *state, struct triple *ins)
{
        struct triple **expr;
        expr = triple_targ(state, ins, 0);
        for(;expr;expr = triple_targ(state, ins, expr)) {
                internal_error(state, ins, "unexpected targ");
        }
}

static void wipe_ins(struct compile_state *state, struct triple *ins)
{
        /* Becareful which instructions you replace the wiped
         * instruction with, as there are not enough slots
         * in all instructions to hold all others.
         */
        check_targ(state, ins);
        check_misc(state, ins);
        unuse_rhs(state, ins);
        unuse_lhs(state, ins);
        ins->lhs  = 0;
        ins->rhs  = 0;
        ins->misc = 0;
        ins->targ = 0;
}

static void wipe_branch(struct compile_state *state, struct triple *ins)
{
        /* Becareful which instructions you replace the wiped
         * instruction with, as there are not enough slots
         * in all instructions to hold all others.
         */
        unuse_rhs(state, ins);
        unuse_lhs(state, ins);
        unuse_misc(state, ins);
        unuse_targ(state, ins);
        ins->lhs  = 0;
        ins->rhs  = 0;
        ins->misc = 0;
        ins->targ = 0;
}

static void mkcopy(struct compile_state *state, 
        struct triple *ins, struct triple *rhs)
{
        struct block *block;
        if (!equiv_types(ins->type, rhs->type)) {
                FILE *fp = state->errout;
                fprintf(fp, "src type: ");
                name_of(fp, rhs->type);
                fprintf(fp, "\ndst type: ");
                name_of(fp, ins->type);
                fprintf(fp, "\n");
                internal_error(state, ins, "mkcopy type mismatch");
        }
        block = block_of_triple(state, ins);
        wipe_ins(state, ins);
        ins->op = OP_COPY;
        ins->rhs  = 1;
        ins->u.block = block;
        RHS(ins, 0) = rhs;
        use_triple(RHS(ins, 0), ins);
}

static void mkconst(struct compile_state *state, 
        struct triple *ins, ulong_t value)
{
        if (!is_integral(ins) && !is_pointer(ins)) {
                fprintf(state->errout, "type: ");
                name_of(state->errout, ins->type);
                fprintf(state->errout, "\n");
                internal_error(state, ins, "unknown type to make constant value: %ld",
                        value);
        }
        wipe_ins(state, ins);
        ins->op = OP_INTCONST;
        ins->u.cval = value;
}

static void mkaddr_const(struct compile_state *state,
        struct triple *ins, struct triple *sdecl, ulong_t value)
{
        if ((sdecl->op != OP_SDECL) && (sdecl->op != OP_LABEL)) {
                internal_error(state, ins, "bad base for addrconst");
        }
        wipe_ins(state, ins);
        ins->op = OP_ADDRCONST;
        ins->misc = 1;
        MISC(ins, 0) = sdecl;
        ins->u.cval = value;
        use_triple(sdecl, ins);
}

#if DEBUG_DECOMPOSE_PRINT_TUPLES
static void print_tuple(struct compile_state *state, 
        struct triple *ins, struct triple *tuple)
{
        FILE *fp = state->dbgout;
        fprintf(fp, "%5s %p tuple: %p ", tops(ins->op), ins, tuple);
        name_of(fp, tuple->type);
        if (tuple->lhs > 0) {
                fprintf(fp, " lhs: ");
                name_of(fp, LHS(tuple, 0)->type);
        }
        fprintf(fp, "\n");
        
}
#endif

static struct triple *decompose_with_tuple(struct compile_state *state, 
        struct triple *ins, struct triple *tuple)
{
        struct triple *next;
        next = ins->next;
        flatten(state, next, tuple);
#if DEBUG_DECOMPOSE_PRINT_TUPLES
        print_tuple(state, ins, tuple);
#endif

        if (!is_compound_type(tuple->type) && (tuple->lhs > 0)) {
                struct triple *tmp;
                if (tuple->lhs != 1) {
                        internal_error(state, tuple, "plain type in multiple registers?");
                }
                tmp = LHS(tuple, 0);
                release_triple(state, tuple);
                tuple = tmp;
        }

        propogate_use(state, ins, tuple);
        release_triple(state, ins);
        
        return next;
}

static struct triple *decompose_unknownval(struct compile_state *state,
        struct triple *ins)
{
        struct triple *tuple;
        ulong_t i;

#if DEBUG_DECOMPOSE_HIRES
        FILE *fp = state->dbgout;
        fprintf(fp, "unknown type: ");
        name_of(fp, ins->type);
        fprintf(fp, "\n");
#endif

        get_occurance(ins->occurance);
        tuple = alloc_triple(state, OP_TUPLE, ins->type, -1, -1, 
                ins->occurance);

        for(i = 0; i < tuple->lhs; i++) {
                struct type *piece_type;
                struct triple *unknown;

                piece_type = reg_type(state, ins->type, i * REG_SIZEOF_REG);
                get_occurance(tuple->occurance);
                unknown = alloc_triple(state, OP_UNKNOWNVAL, piece_type, 0, 0,
                        tuple->occurance);
                LHS(tuple, i) = unknown;
        }
        return decompose_with_tuple(state, ins, tuple);
}


static struct triple *decompose_read(struct compile_state *state, 
        struct triple *ins)
{
        struct triple *tuple, *lval;
        ulong_t i;

        lval = RHS(ins, 0);

        if (lval->op == OP_PIECE) {
                return ins->next;
        }
        get_occurance(ins->occurance);
        tuple = alloc_triple(state, OP_TUPLE, lval->type, -1, -1,
                ins->occurance);

        if ((tuple->lhs != lval->lhs) &&
                (!triple_is_def(state, lval) || (tuple->lhs != 1))) 
        {
                internal_error(state, ins, "lhs size inconsistency?");
        }
        for(i = 0; i < tuple->lhs; i++) {
                struct triple *piece, *read, *bitref;
                if ((i != 0) || !triple_is_def(state, lval)) {
                        piece = LHS(lval, i);
                } else {
                        piece = lval;
                }

                /* See if the piece is really a bitref */
                bitref = 0;
                if (piece->op == OP_BITREF) {
                        bitref = piece;
                        piece = RHS(bitref, 0);
                }

                get_occurance(tuple->occurance);
                read = alloc_triple(state, OP_READ, piece->type, -1, -1, 
                        tuple->occurance);
                RHS(read, 0) = piece;

                if (bitref) {
                        struct triple *extract;
                        int op;
                        if (is_signed(bitref->type->left)) {
                                op = OP_SEXTRACT;
                        } else {
                                op = OP_UEXTRACT;
                        }
                        get_occurance(tuple->occurance);
                        extract = alloc_triple(state, op, bitref->type, -1, -1,
                                tuple->occurance);
                        RHS(extract, 0) = read;
                        extract->u.bitfield.size   = bitref->u.bitfield.size;
                        extract->u.bitfield.offset = bitref->u.bitfield.offset;

                        read = extract;
                }

                LHS(tuple, i) = read;
        }
        return decompose_with_tuple(state, ins, tuple);
}

static struct triple *decompose_write(struct compile_state *state, 
        struct triple *ins)
{
        struct triple *tuple, *lval, *val;
        ulong_t i;
        
        lval = MISC(ins, 0);
        val = RHS(ins, 0);
        get_occurance(ins->occurance);
        tuple = alloc_triple(state, OP_TUPLE, ins->type, -1, -1,
                ins->occurance);

        if ((tuple->lhs != lval->lhs) &&
                (!triple_is_def(state, lval) || tuple->lhs != 1)) 
        {
                internal_error(state, ins, "lhs size inconsistency?");
        }
        for(i = 0; i < tuple->lhs; i++) {
                struct triple *piece, *write, *pval, *bitref;
                if ((i != 0) || !triple_is_def(state, lval)) {
                        piece = LHS(lval, i);
                } else {
                        piece = lval;
                }
                if ((i == 0) && (tuple->lhs == 1) && (val->lhs == 0)) {
                        pval = val;
                }
                else {
                        if (i > val->lhs) {
                                internal_error(state, ins, "lhs size inconsistency?");
                        }
                        pval = LHS(val, i);
                }
                
                /* See if the piece is really a bitref */
                bitref = 0;
                if (piece->op == OP_BITREF) {
                        struct triple *read, *deposit;
                        bitref = piece;
                        piece = RHS(bitref, 0);

                        /* Read the destination register */
                        get_occurance(tuple->occurance);
                        read = alloc_triple(state, OP_READ, piece->type, -1, -1,
                                tuple->occurance);
                        RHS(read, 0) = piece;

                        /* Deposit the new bitfield value */
                        get_occurance(tuple->occurance);
                        deposit = alloc_triple(state, OP_DEPOSIT, piece->type, -1, -1,
                                tuple->occurance);
                        RHS(deposit, 0) = read;
                        RHS(deposit, 1) = pval;
                        deposit->u.bitfield.size   = bitref->u.bitfield.size;
                        deposit->u.bitfield.offset = bitref->u.bitfield.offset;

                        /* Now write the newly generated value */
                        pval = deposit;
                }

                get_occurance(tuple->occurance);
                write = alloc_triple(state, OP_WRITE, piece->type, -1, -1, 
                        tuple->occurance);
                MISC(write, 0) = piece;
                RHS(write, 0) = pval;
                LHS(tuple, i) = write;
        }
        return decompose_with_tuple(state, ins, tuple);
}

struct decompose_load_info {
        struct occurance *occurance;
        struct triple *lval;
        struct triple *tuple;
};
static void decompose_load_cb(struct compile_state *state,
        struct type *type, size_t reg_offset, size_t mem_offset, void *arg)
{
        struct decompose_load_info *info = arg;
        struct triple *load;
        
        if (reg_offset > info->tuple->lhs) {
                internal_error(state, info->tuple, "lhs to small?");
        }
        get_occurance(info->occurance);
        load = alloc_triple(state, OP_LOAD, type, -1, -1, info->occurance);
        RHS(load, 0) = mk_addr_expr(state, info->lval, mem_offset);
        LHS(info->tuple, reg_offset/REG_SIZEOF_REG) = load;
}

static struct triple *decompose_load(struct compile_state *state, 
        struct triple *ins)
{
        struct triple *tuple;
        struct decompose_load_info info;

        if (!is_compound_type(ins->type)) {
                return ins->next;
        }
        get_occurance(ins->occurance);
        tuple = alloc_triple(state, OP_TUPLE, ins->type, -1, -1,
                ins->occurance);

        info.occurance = ins->occurance;
        info.lval      = RHS(ins, 0);
        info.tuple     = tuple;
        walk_type_fields(state, ins->type, 0, 0, decompose_load_cb, &info);

        return decompose_with_tuple(state, ins, tuple);
}


struct decompose_store_info {
        struct occurance *occurance;
        struct triple *lval;
        struct triple *val;
        struct triple *tuple;
};
static void decompose_store_cb(struct compile_state *state,
        struct type *type, size_t reg_offset, size_t mem_offset, void *arg)
{
        struct decompose_store_info *info = arg;
        struct triple *store;
        
        if (reg_offset > info->tuple->lhs) {
                internal_error(state, info->tuple, "lhs to small?");
        }
        get_occurance(info->occurance);
        store = alloc_triple(state, OP_STORE, type, -1, -1, info->occurance);
        RHS(store, 0) = mk_addr_expr(state, info->lval, mem_offset);
        RHS(store, 1) = LHS(info->val, reg_offset);
        LHS(info->tuple, reg_offset/REG_SIZEOF_REG) = store;
}

static struct triple *decompose_store(struct compile_state *state, 
        struct triple *ins)
{
        struct triple *tuple;
        struct decompose_store_info info;

        if (!is_compound_type(ins->type)) {
                return ins->next;
        }
        get_occurance(ins->occurance);
        tuple = alloc_triple(state, OP_TUPLE, ins->type, -1, -1,
                ins->occurance);

        info.occurance = ins->occurance;
        info.lval      = RHS(ins, 0);
        info.val       = RHS(ins, 1);
        info.tuple     = tuple;
        walk_type_fields(state, ins->type, 0, 0, decompose_store_cb, &info);

        return decompose_with_tuple(state, ins, tuple);
}

static struct triple *decompose_dot(struct compile_state *state, 
        struct triple *ins)
{
        struct triple *tuple, *lval;
        struct type *type;
        size_t reg_offset;
        int i, idx;

        lval = MISC(ins, 0);
        reg_offset = field_reg_offset(state, lval->type, ins->u.field);
        idx  = reg_offset/REG_SIZEOF_REG;
        type = field_type(state, lval->type, ins->u.field);
#if DEBUG_DECOMPOSE_HIRES
        {
                FILE *fp = state->dbgout;
                fprintf(fp, "field type: ");
                name_of(fp, type);
                fprintf(fp, "\n");
        }
#endif

        get_occurance(ins->occurance);
        tuple = alloc_triple(state, OP_TUPLE, type, -1, -1, 
                ins->occurance);

        if (((ins->type->type & TYPE_MASK) == TYPE_BITFIELD) &&
                (tuple->lhs != 1))
        {
                internal_error(state, ins, "multi register bitfield?");
        }

        for(i = 0; i < tuple->lhs; i++, idx++) {
                struct triple *piece;
                if (!triple_is_def(state, lval)) {
                        if (idx > lval->lhs) {
                                internal_error(state, ins, "inconsistent lhs count");
                        }
                        piece = LHS(lval, idx);
                } else {
                        if (idx != 0) {
                                internal_error(state, ins, "bad reg_offset into def");
                        }
                        if (i != 0) {
                                internal_error(state, ins, "bad reg count from def");
                        }
                        piece = lval;
                }

                /* Remember the offset of the bitfield */
                if ((type->type & TYPE_MASK) == TYPE_BITFIELD) {
                        get_occurance(ins->occurance);
                        piece = build_triple(state, OP_BITREF, type, piece, 0,
                                ins->occurance);
                        piece->u.bitfield.size   = size_of(state, type);
                        piece->u.bitfield.offset = reg_offset % REG_SIZEOF_REG;
                }
                else if ((reg_offset % REG_SIZEOF_REG) != 0) {
                        internal_error(state, ins, 
                                "request for a nonbitfield sub register?");
                }

                LHS(tuple, i) = piece;
        }

        return decompose_with_tuple(state, ins, tuple);
}

static struct triple *decompose_index(struct compile_state *state, 
        struct triple *ins)
{
        struct triple *tuple, *lval;
        struct type *type;
        int i, idx;

        lval = MISC(ins, 0);
        idx = index_reg_offset(state, lval->type, ins->u.cval)/REG_SIZEOF_REG;
        type = index_type(state, lval->type, ins->u.cval);
#if DEBUG_DECOMPOSE_HIRES
{
        FILE *fp = state->dbgout;
        fprintf(fp, "index type: ");
        name_of(fp, type);
        fprintf(fp, "\n");
}
#endif

        get_occurance(ins->occurance);
        tuple = alloc_triple(state, OP_TUPLE, type, -1, -1, 
                ins->occurance);

        for(i = 0; i < tuple->lhs; i++, idx++) {
                struct triple *piece;
                if (!triple_is_def(state, lval)) {
                        if (idx > lval->lhs) {
                                internal_error(state, ins, "inconsistent lhs count");
                        }
                        piece = LHS(lval, idx);
                } else {
                        if (idx != 0) {
                                internal_error(state, ins, "bad reg_offset into def");
                        }
                        if (i != 0) {
                                internal_error(state, ins, "bad reg count from def");
                        }
                        piece = lval;
                }
                LHS(tuple, i) = piece;
        }

        return decompose_with_tuple(state, ins, tuple);
}

static void decompose_compound_types(struct compile_state *state)
{
        struct triple *ins, *next, *first;
        FILE *fp;
        fp = state->dbgout;
        first = state->first;
        ins = first;

        /* Pass one expand compound values into pseudo registers.
         */
        next = first;
        do {
                ins = next;
                next = ins->next;
                switch(ins->op) {
                case OP_UNKNOWNVAL:
                        next = decompose_unknownval(state, ins);
                        break;

                case OP_READ:
                        next = decompose_read(state, ins);
                        break;

                case OP_WRITE:
                        next = decompose_write(state, ins);
                        break;


                /* Be very careful with the load/store logic. These
                 * operations must convert from the in register layout
                 * to the in memory layout, which is nontrivial.
                 */
                case OP_LOAD:
                        next = decompose_load(state, ins);
                        break;
                case OP_STORE:
                        next = decompose_store(state, ins);
                        break;

                case OP_DOT:
                        next = decompose_dot(state, ins);
                        break;
                case OP_INDEX:
                        next = decompose_index(state, ins);
                        break;
                        
                }
#if DEBUG_DECOMPOSE_HIRES
                fprintf(fp, "decompose next: %p \n", next);
                fflush(fp);
                fprintf(fp, "next->op: %d %s\n",
                        next->op, tops(next->op));
                /* High resolution debugging mode */
                print_triples(state);
#endif
        } while (next != first);

        /* Pass two remove the tuples.
         */
        ins = first;
        do {
                next = ins->next;
                if (ins->op == OP_TUPLE) {
                        if (ins->use) {
                                internal_error(state, ins, "tuple used");
                        }
                        else {
                                release_triple(state, ins);
                        }
                } 
                ins = next;
        } while(ins != first);
        ins = first;
        do {
                next = ins->next;
                if (ins->op == OP_BITREF) {
                        if (ins->use) {
                                internal_error(state, ins, "bitref used");
                        } 
                        else {
                                release_triple(state, ins);
                        }
                }
                ins = next;
        } while(ins != first);

        /* Pass three verify the state and set ->id to 0.
         */
        next = first;
        do {
                ins = next;
                next = ins->next;
                ins->id &= ~TRIPLE_FLAG_FLATTENED;
                if (triple_stores_block(state, ins)) {
                        ins->u.block = 0;
                }
                if (triple_is_def(state, ins)) {
                        if (reg_size_of(state, ins->type) > REG_SIZEOF_REG) {
                                internal_error(state, ins, "multi register value remains?");
                        }
                }
                if (ins->op == OP_DOT) {
                        internal_error(state, ins, "OP_DOT remains?");
                }
                if (ins->op == OP_INDEX) {
                        internal_error(state, ins, "OP_INDEX remains?");
                }
                if (ins->op == OP_BITREF) {
                        internal_error(state, ins, "OP_BITREF remains?");
                }
                if (ins->op == OP_TUPLE) {
                        internal_error(state, ins, "OP_TUPLE remains?");
                }
        } while(next != first);
}

/* For those operations that cannot be simplified */
static void simplify_noop(struct compile_state *state, struct triple *ins)
{
        return;
}

static void simplify_smul(struct compile_state *state, struct triple *ins)
{
        if (is_const(RHS(ins, 0)) && !is_const(RHS(ins, 1))) {
                struct triple *tmp;
                tmp = RHS(ins, 0);
                RHS(ins, 0) = RHS(ins, 1);
                RHS(ins, 1) = tmp;
        }
        if (is_const(RHS(ins, 0)) && is_const(RHS(ins, 1))) {
                long_t left, right;
                left  = read_sconst(state, ins, RHS(ins, 0));
                right = read_sconst(state, ins, RHS(ins, 1));
                mkconst(state, ins, left * right);
        }
        else if (is_zero(RHS(ins, 1))) {
                mkconst(state, ins, 0);
        }
        else if (is_one(RHS(ins, 1))) {
                mkcopy(state, ins, RHS(ins, 0));
        }
        else if (is_pow2(RHS(ins, 1))) {
                struct triple *val;
                val = int_const(state, ins->type, tlog2(RHS(ins, 1)));
                ins->op = OP_SL;
                insert_triple(state, state->global_pool, val);
                unuse_triple(RHS(ins, 1), ins);
                use_triple(val, ins);
                RHS(ins, 1) = val;
        }
}

static void simplify_umul(struct compile_state *state, struct triple *ins)
{
        if (is_const(RHS(ins, 0)) && !is_const(RHS(ins, 1))) {
                struct triple *tmp;
                tmp = RHS(ins, 0);
                RHS(ins, 0) = RHS(ins, 1);
                RHS(ins, 1) = tmp;
        }
        if (is_simple_const(RHS(ins, 0)) && is_simple_const(RHS(ins, 1))) {
                ulong_t left, right;
                left  = read_const(state, ins, RHS(ins, 0));
                right = read_const(state, ins, RHS(ins, 1));
                mkconst(state, ins, left * right);
        }
        else if (is_zero(RHS(ins, 1))) {
                mkconst(state, ins, 0);
        }
        else if (is_one(RHS(ins, 1))) {
                mkcopy(state, ins, RHS(ins, 0));
        }
        else if (is_pow2(RHS(ins, 1))) {
                struct triple *val;
                val = int_const(state, ins->type, tlog2(RHS(ins, 1)));
                ins->op = OP_SL;
                insert_triple(state, state->global_pool, val);
                unuse_triple(RHS(ins, 1), ins);
                use_triple(val, ins);
                RHS(ins, 1) = val;
        }
}

static void simplify_sdiv(struct compile_state *state, struct triple *ins)
{
        if (is_const(RHS(ins, 0)) && is_const(RHS(ins, 1))) {
                long_t left, right;
                left  = read_sconst(state, ins, RHS(ins, 0));
                right = read_sconst(state, ins, RHS(ins, 1));
                mkconst(state, ins, left / right);
        }
        else if (is_zero(RHS(ins, 0))) {
                mkconst(state, ins, 0);
        }
        else if (is_zero(RHS(ins, 1))) {
                error(state, ins, "division by zero");
        }
        else if (is_one(RHS(ins, 1))) {
                mkcopy(state, ins, RHS(ins, 0));
        }
        else if (is_pow2(RHS(ins, 1))) {
                struct triple *val;
                val = int_const(state, ins->type, tlog2(RHS(ins, 1)));
                ins->op = OP_SSR;
                insert_triple(state, state->global_pool, val);
                unuse_triple(RHS(ins, 1), ins);
                use_triple(val, ins);
                RHS(ins, 1) = val;
        }
}

static void simplify_udiv(struct compile_state *state, struct triple *ins)
{
        if (is_simple_const(RHS(ins, 0)) && is_simple_const(RHS(ins, 1))) {
                ulong_t left, right;
                left  = read_const(state, ins, RHS(ins, 0));
                right = read_const(state, ins, RHS(ins, 1));
                mkconst(state, ins, left / right);
        }
        else if (is_zero(RHS(ins, 0))) {
                mkconst(state, ins, 0);
        }
        else if (is_zero(RHS(ins, 1))) {
                error(state, ins, "division by zero");
        }
        else if (is_one(RHS(ins, 1))) {
                mkcopy(state, ins, RHS(ins, 0));
        }
        else if (is_pow2(RHS(ins, 1))) {
                struct triple *val;
                val = int_const(state, ins->type, tlog2(RHS(ins, 1)));
                ins->op = OP_USR;
                insert_triple(state, state->global_pool, val);
                unuse_triple(RHS(ins, 1), ins);
                use_triple(val, ins);
                RHS(ins, 1) = val;
        }
}

static void simplify_smod(struct compile_state *state, struct triple *ins)
{
        if (is_simple_const(RHS(ins, 0)) && is_simple_const(RHS(ins, 1))) {
                long_t left, right;
                left  = read_const(state, ins, RHS(ins, 0));
                right = read_const(state, ins, RHS(ins, 1));
                mkconst(state, ins, left % right);
        }
        else if (is_zero(RHS(ins, 0))) {
                mkconst(state, ins, 0);
        }
        else if (is_zero(RHS(ins, 1))) {
                error(state, ins, "division by zero");
        }
        else if (is_one(RHS(ins, 1))) {
                mkconst(state, ins, 0);
        }
        else if (is_pow2(RHS(ins, 1))) {
                struct triple *val;
                val = int_const(state, ins->type, RHS(ins, 1)->u.cval - 1);
                ins->op = OP_AND;
                insert_triple(state, state->global_pool, val);
                unuse_triple(RHS(ins, 1), ins);
                use_triple(val, ins);
                RHS(ins, 1) = val;
        }
}

static void simplify_umod(struct compile_state *state, struct triple *ins)
{
        if (is_simple_const(RHS(ins, 0)) && is_simple_const(RHS(ins, 1))) {
                ulong_t left, right;
                left  = read_const(state, ins, RHS(ins, 0));
                right = read_const(state, ins, RHS(ins, 1));
                mkconst(state, ins, left % right);
        }
        else if (is_zero(RHS(ins, 0))) {
                mkconst(state, ins, 0);
        }
        else if (is_zero(RHS(ins, 1))) {
                error(state, ins, "division by zero");
        }
        else if (is_one(RHS(ins, 1))) {
                mkconst(state, ins, 0);
        }
        else if (is_pow2(RHS(ins, 1))) {
                struct triple *val;
                val = int_const(state, ins->type, RHS(ins, 1)->u.cval - 1);
                ins->op = OP_AND;
                insert_triple(state, state->global_pool, val);
                unuse_triple(RHS(ins, 1), ins);
                use_triple(val, ins);
                RHS(ins, 1) = val;
        }
}

static void simplify_add(struct compile_state *state, struct triple *ins)
{
        /* start with the pointer on the left */
        if (is_pointer(RHS(ins, 1))) {
                struct triple *tmp;
                tmp = RHS(ins, 0);
                RHS(ins, 0) = RHS(ins, 1);
                RHS(ins, 1) = tmp;
        }
        if (is_const(RHS(ins, 0)) && is_simple_const(RHS(ins, 1))) {
                if (RHS(ins, 0)->op == OP_INTCONST) {
                        ulong_t left, right;
                        left  = read_const(state, ins, RHS(ins, 0));
                        right = read_const(state, ins, RHS(ins, 1));
                        mkconst(state, ins, left + right);
                }
                else if (RHS(ins, 0)->op == OP_ADDRCONST) {
                        struct triple *sdecl;
                        ulong_t left, right;
                        sdecl = MISC(RHS(ins, 0), 0);
                        left  = RHS(ins, 0)->u.cval;
                        right = RHS(ins, 1)->u.cval;
                        mkaddr_const(state, ins, sdecl, left + right);
                }
                else {
                        internal_warning(state, ins, "Optimize me!");
                }
        }
        else if (is_const(RHS(ins, 0)) && !is_const(RHS(ins, 1))) {
                struct triple *tmp;
                tmp = RHS(ins, 1);
                RHS(ins, 1) = RHS(ins, 0);
                RHS(ins, 0) = tmp;
        }
}

static void simplify_sub(struct compile_state *state, struct triple *ins)
{
        if (is_const(RHS(ins, 0)) && is_simple_const(RHS(ins, 1))) {
                if (RHS(ins, 0)->op == OP_INTCONST) {
                        ulong_t left, right;
                        left  = read_const(state, ins, RHS(ins, 0));
                        right = read_const(state, ins, RHS(ins, 1));
                        mkconst(state, ins, left - right);
                }
                else if (RHS(ins, 0)->op == OP_ADDRCONST) {
                        struct triple *sdecl;
                        ulong_t left, right;
                        sdecl = MISC(RHS(ins, 0), 0);
                        left  = RHS(ins, 0)->u.cval;
                        right = RHS(ins, 1)->u.cval;
                        mkaddr_const(state, ins, sdecl, left - right);
                }
                else {
                        internal_warning(state, ins, "Optimize me!");
                }
        }
}

static void simplify_sl(struct compile_state *state, struct triple *ins)
{
        if (is_simple_const(RHS(ins, 1))) {
                ulong_t right;
                right = read_const(state, ins, RHS(ins, 1));
                if (right >= (size_of(state, ins->type))) {
                        warning(state, ins, "left shift count >= width of type");
                }
        }
        if (is_simple_const(RHS(ins, 0)) && is_simple_const(RHS(ins, 1))) {
                ulong_t left, right;
                left  = read_const(state, ins, RHS(ins, 0));
                right = read_const(state, ins, RHS(ins, 1));
                mkconst(state, ins,  left << right);
        }
}

static void simplify_usr(struct compile_state *state, struct triple *ins)
{
        if (is_simple_const(RHS(ins, 1))) {
                ulong_t right;
                right = read_const(state, ins, RHS(ins, 1));
                if (right >= (size_of(state, ins->type))) {
                        warning(state, ins, "right shift count >= width of type");
                }
        }
        if (is_simple_const(RHS(ins, 0)) && is_simple_const(RHS(ins, 1))) {
                ulong_t left, right;
                left  = read_const(state, ins, RHS(ins, 0));
                right = read_const(state, ins, RHS(ins, 1));
                mkconst(state, ins, left >> right);
        }
}

static void simplify_ssr(struct compile_state *state, struct triple *ins)
{
        if (is_simple_const(RHS(ins, 1))) {
                ulong_t right;
                right = read_const(state, ins, RHS(ins, 1));
                if (right >= (size_of(state, ins->type))) {
                        warning(state, ins, "right shift count >= width of type");
                }
        }
        if (is_simple_const(RHS(ins, 0)) && is_simple_const(RHS(ins, 1))) {
                long_t left, right;
                left  = read_sconst(state, ins, RHS(ins, 0));
                right = read_sconst(state, ins, RHS(ins, 1));
                mkconst(state, ins, left >> right);
        }
}

static void simplify_and(struct compile_state *state, struct triple *ins)
{
        struct triple *left, *right;
        left = RHS(ins, 0);
        right = RHS(ins, 1);

        if (is_simple_const(left) && is_simple_const(right)) {
                ulong_t lval, rval;
                lval = read_const(state, ins, left);
                rval = read_const(state, ins, right);
                mkconst(state, ins, lval & rval);
        }
        else if (is_zero(right) || is_zero(left)) {
                mkconst(state, ins, 0);
        }
}

static void simplify_or(struct compile_state *state, struct triple *ins)
{
        struct triple *left, *right;
        left = RHS(ins, 0);
        right = RHS(ins, 1);

        if (is_simple_const(left) && is_simple_const(right)) {
                ulong_t lval, rval;
                lval = read_const(state, ins, left);
                rval = read_const(state, ins, right);
                mkconst(state, ins, lval | rval);
        }
#if 0 /* I need to handle type mismatches here... */
        else if (is_zero(right)) {
                mkcopy(state, ins, left);
        }
        else if (is_zero(left)) {
                mkcopy(state, ins, right);
        }
#endif
}

static void simplify_xor(struct compile_state *state, struct triple *ins)
{
        if (is_simple_const(RHS(ins, 0)) && is_simple_const(RHS(ins, 1))) {
                ulong_t left, right;
                left  = read_const(state, ins, RHS(ins, 0));
                right = read_const(state, ins, RHS(ins, 1));
                mkconst(state, ins, left ^ right);
        }
}

static void simplify_pos(struct compile_state *state, struct triple *ins)
{
        if (is_const(RHS(ins, 0))) {
                mkconst(state, ins, RHS(ins, 0)->u.cval);
        }
        else {
                mkcopy(state, ins, RHS(ins, 0));
        }
}

static void simplify_neg(struct compile_state *state, struct triple *ins)
{
        if (is_simple_const(RHS(ins, 0))) {
                ulong_t left;
                left = read_const(state, ins, RHS(ins, 0));
                mkconst(state, ins, -left);
        }
        else if (RHS(ins, 0)->op == OP_NEG) {
                mkcopy(state, ins, RHS(RHS(ins, 0), 0));
        }
}

static void simplify_invert(struct compile_state *state, struct triple *ins)
{
        if (is_simple_const(RHS(ins, 0))) {
                ulong_t left;
                left = read_const(state, ins, RHS(ins, 0));
                mkconst(state, ins, ~left);
        }
}

static void simplify_eq(struct compile_state *state, struct triple *ins)
{
        struct triple *left, *right;
        left = RHS(ins, 0);
        right = RHS(ins, 1);

        if (is_const(left) && is_const(right)) {
                int val;
                val = const_eq(state, ins, left, right);
                if (val >= 0) {
                        mkconst(state, ins, val == 1);
                }
        }
        else if (left == right) {
                mkconst(state, ins, 1);
        }
}

static void simplify_noteq(struct compile_state *state, struct triple *ins)
{
        struct triple *left, *right;
        left = RHS(ins, 0);
        right = RHS(ins, 1);

        if (is_const(left) && is_const(right)) {
                int val;
                val = const_eq(state, ins, left, right);
                if (val >= 0) {
                        mkconst(state, ins, val != 1);
                }
        }
        if (left == right) {
                mkconst(state, ins, 0);
        }
}

static void simplify_sless(struct compile_state *state, struct triple *ins)
{
        struct triple *left, *right;
        left = RHS(ins, 0);
        right = RHS(ins, 1);

        if (is_const(left) && is_const(right)) {
                int val;
                val = const_scmp(state, ins, left, right);
                if ((val >= -1) && (val <= 1)) {
                        mkconst(state, ins, val < 0);
                }
        }
        else if (left == right) {
                mkconst(state, ins, 0);
        }
}

static void simplify_uless(struct compile_state *state, struct triple *ins)
{
        struct triple *left, *right;
        left = RHS(ins, 0);
        right = RHS(ins, 1);

        if (is_const(left) && is_const(right)) {
                int val;
                val = const_ucmp(state, ins, left, right);
                if ((val >= -1) && (val <= 1)) {
                        mkconst(state, ins, val < 0);
                }
        }
        else if (is_zero(right)) {
                mkconst(state, ins, 0);
        }
        else if (left == right) {
                mkconst(state, ins, 0);
        }
}

static void simplify_smore(struct compile_state *state, struct triple *ins)
{
        struct triple *left, *right;
        left = RHS(ins, 0);
        right = RHS(ins, 1);

        if (is_const(left) && is_const(right)) {
                int val;
                val = const_scmp(state, ins, left, right);
                if ((val >= -1) && (val <= 1)) {
                        mkconst(state, ins, val > 0);
                }
        }
        else if (left == right) {
                mkconst(state, ins, 0);
        }
}

static void simplify_umore(struct compile_state *state, struct triple *ins)
{
        struct triple *left, *right;
        left = RHS(ins, 0);
        right = RHS(ins, 1);

        if (is_const(left) && is_const(right)) {
                int val;
                val = const_ucmp(state, ins, left, right);
                if ((val >= -1) && (val <= 1)) {
                        mkconst(state, ins, val > 0);
                }
        }
        else if (is_zero(left)) {
                mkconst(state, ins, 0);
        }
        else if (left == right) {
                mkconst(state, ins, 0);
        }
}


static void simplify_slesseq(struct compile_state *state, struct triple *ins)
{
        struct triple *left, *right;
        left = RHS(ins, 0);
        right = RHS(ins, 1);

        if (is_const(left) && is_const(right)) {
                int val;
                val = const_scmp(state, ins, left, right);
                if ((val >= -1) && (val <= 1)) {
                        mkconst(state, ins, val <= 0);
                }
        }
        else if (left == right) {
                mkconst(state, ins, 1);
        }
}

static void simplify_ulesseq(struct compile_state *state, struct triple *ins)
{
        struct triple *left, *right;
        left = RHS(ins, 0);
        right = RHS(ins, 1);

        if (is_const(left) && is_const(right)) {
                int val;
                val = const_ucmp(state, ins, left, right);
                if ((val >= -1) && (val <= 1)) {
                        mkconst(state, ins, val <= 0);
                }
        }
        else if (is_zero(left)) {
                mkconst(state, ins, 1);
        }
        else if (left == right) {
                mkconst(state, ins, 1);
        }
}

static void simplify_smoreeq(struct compile_state *state, struct triple *ins)
{
        struct triple *left, *right;
        left = RHS(ins, 0);
        right = RHS(ins, 1);

        if (is_const(left) && is_const(right)) {
                int val;
                val = const_scmp(state, ins, left, right);
                if ((val >= -1) && (val <= 1)) {
                        mkconst(state, ins, val >= 0);
                }
        }
        else if (left == right) {
                mkconst(state, ins, 1);
        }
}

static void simplify_umoreeq(struct compile_state *state, struct triple *ins)
{
        struct triple *left, *right;
        left = RHS(ins, 0);
        right = RHS(ins, 1);

        if (is_const(left) && is_const(right)) {
                int val;
                val = const_ucmp(state, ins, left, right);
                if ((val >= -1) && (val <= 1)) {
                        mkconst(state, ins, val >= 0);
                }
        }
        else if (is_zero(right)) {
                mkconst(state, ins, 1);
        }
        else if (left == right) {
                mkconst(state, ins, 1);
        }
}

static void simplify_lfalse(struct compile_state *state, struct triple *ins)
{
        struct triple *rhs;
        rhs = RHS(ins, 0);

        if (is_const(rhs)) {
                mkconst(state, ins, !const_ltrue(state, ins, rhs));
        }
        /* Otherwise if I am the only user... */
        else if ((rhs->use) &&
                (rhs->use->member == ins) && (rhs->use->next == 0)) {
                int need_copy = 1;
                /* Invert a boolean operation */
                switch(rhs->op) {
                case OP_LTRUE:   rhs->op = OP_LFALSE;  break;
                case OP_LFALSE:  rhs->op = OP_LTRUE;   break;
                case OP_EQ:      rhs->op = OP_NOTEQ;   break;
                case OP_NOTEQ:   rhs->op = OP_EQ;      break;
                case OP_SLESS:   rhs->op = OP_SMOREEQ; break;
                case OP_ULESS:   rhs->op = OP_UMOREEQ; break;
                case OP_SMORE:   rhs->op = OP_SLESSEQ; break;
                case OP_UMORE:   rhs->op = OP_ULESSEQ; break;
                case OP_SLESSEQ: rhs->op = OP_SMORE;   break;
                case OP_ULESSEQ: rhs->op = OP_UMORE;   break;
                case OP_SMOREEQ: rhs->op = OP_SLESS;   break;
                case OP_UMOREEQ: rhs->op = OP_ULESS;   break;
                default:
                        need_copy = 0;
                        break;
                }
                if (need_copy) {
                        mkcopy(state, ins, rhs);
                }
        }
}

static void simplify_ltrue (struct compile_state *state, struct triple *ins)
{
        struct triple *rhs;
        rhs = RHS(ins, 0);

        if (is_const(rhs)) {
                mkconst(state, ins, const_ltrue(state, ins, rhs));
        }
        else switch(rhs->op) {
        case OP_LTRUE:   case OP_LFALSE:  case OP_EQ:      case OP_NOTEQ:
        case OP_SLESS:   case OP_ULESS:   case OP_SMORE:   case OP_UMORE:
        case OP_SLESSEQ: case OP_ULESSEQ: case OP_SMOREEQ: case OP_UMOREEQ:
                mkcopy(state, ins, rhs);
        }

}

static void simplify_load(struct compile_state *state, struct triple *ins)
{
        struct triple *addr, *sdecl, *blob;

        /* If I am doing a load with a constant pointer from a constant
         * table get the value.
         */
        addr = RHS(ins, 0);
        if ((addr->op == OP_ADDRCONST) && (sdecl = MISC(addr, 0)) &&
                (sdecl->op == OP_SDECL) && (blob = MISC(sdecl, 0)) &&
                (blob->op == OP_BLOBCONST)) {
                unsigned char buffer[SIZEOF_WORD];
                size_t reg_size, mem_size;
                const char *src, *end;
                ulong_t val;
                reg_size = reg_size_of(state, ins->type);
                if (reg_size > REG_SIZEOF_REG) {
                        internal_error(state, ins, "load size greater than register");
                }
                mem_size = size_of(state, ins->type);
                end = blob->u.blob;
                end += bits_to_bytes(size_of(state, sdecl->type));
                src = blob->u.blob;
                src += addr->u.cval;

                if (src > end) {
                        error(state, ins, "Load address out of bounds");
                }

                memset(buffer, 0, sizeof(buffer));
                memcpy(buffer, src, bits_to_bytes(mem_size));

                switch(mem_size) {
                case SIZEOF_I8:  val = *((uint8_t *) buffer); break;
                case SIZEOF_I16: val = *((uint16_t *)buffer); break;
                case SIZEOF_I32: val = *((uint32_t *)buffer); break;
                case SIZEOF_I64: val = *((uint64_t *)buffer); break;
                default:
                        internal_error(state, ins, "mem_size: %d not handled",
                                mem_size);
                        val = 0;
                        break;
                }
                mkconst(state, ins, val);
        }
}

static void simplify_uextract(struct compile_state *state, struct triple *ins)
{
        if (is_simple_const(RHS(ins, 0))) {
                ulong_t val;
                ulong_t mask;
                val = read_const(state, ins, RHS(ins, 0));
                mask = 1;
                mask <<= ins->u.bitfield.size;
                mask -= 1;
                val >>= ins->u.bitfield.offset;
                val &= mask;
                mkconst(state, ins, val);
        }
}

static void simplify_sextract(struct compile_state *state, struct triple *ins)
{
        if (is_simple_const(RHS(ins, 0))) {
                ulong_t val;
                ulong_t mask;
                long_t sval;
                val = read_const(state, ins, RHS(ins, 0));
                mask = 1;
                mask <<= ins->u.bitfield.size;
                mask -= 1;
                val >>= ins->u.bitfield.offset;
                val &= mask;
                val <<= (SIZEOF_LONG - ins->u.bitfield.size);
                sval = val;
                sval >>= (SIZEOF_LONG - ins->u.bitfield.size); 
                mkconst(state, ins, sval);
        }
}

static void simplify_deposit(struct compile_state *state, struct triple *ins)
{
        if (is_simple_const(RHS(ins, 0)) && is_simple_const(RHS(ins, 1))) {
                ulong_t targ, val;
                ulong_t mask;
                targ = read_const(state, ins, RHS(ins, 0));
                val  = read_const(state, ins, RHS(ins, 1));
                mask = 1;
                mask <<= ins->u.bitfield.size;
                mask -= 1;
                mask <<= ins->u.bitfield.offset;
                targ &= ~mask;
                val <<= ins->u.bitfield.offset;
                val &= mask;
                targ |= val;
                mkconst(state, ins, targ);
        }
}

static void simplify_copy(struct compile_state *state, struct triple *ins)
{
        struct triple *right;
        right = RHS(ins, 0);
        if (is_subset_type(ins->type, right->type)) {
                ins->type = right->type;
        }
        if (equiv_types(ins->type, right->type)) {
                ins->op = OP_COPY;/* I don't need to convert if the types match */
        } else {
                if (ins->op == OP_COPY) {
                        internal_error(state, ins, "type mismatch on copy");
                }
        }
        if (is_const(right) && (right->op == OP_ADDRCONST) && is_pointer(ins)) {
                struct triple *sdecl;
                ulong_t offset;
                sdecl  = MISC(right, 0);
                offset = right->u.cval;
                mkaddr_const(state, ins, sdecl, offset);
        }
        else if (is_const(right) && is_write_compatible(state, ins->type, right->type)) {
                switch(right->op) {
                case OP_INTCONST:
                {
                        ulong_t left;
                        left = read_const(state, ins, right);
                        /* Ensure I have not overflowed the destination. */
                        if (size_of(state, right->type) > size_of(state, ins->type)) {
                                ulong_t mask;
                                mask = 1;
                                mask <<= size_of(state, ins->type);
                                mask -= 1;
                                left &= mask;
                        }
                        /* Ensure I am properly sign extended */
                        if (size_of(state, right->type) < size_of(state, ins->type) &&
                                is_signed(right->type)) {
                                long_t val;
                                int shift;
                                shift = SIZEOF_LONG - size_of(state, right->type);
                                val = left;
                                val <<= shift;
                                val >>= shift;
                                left = val;
                        }
                        mkconst(state, ins, left);
                        break;
                }
                default:
                        internal_error(state, ins, "uknown constant");
                        break;
                }
        }
}

static int phi_present(struct block *block)
{
        struct triple *ptr;
        if (!block) {
                return 0;
        }
        ptr = block->first;
        do {
                if (ptr->op == OP_PHI) {
                        return 1;
                }
                ptr = ptr->next;
        } while(ptr != block->last);
        return 0;
}

static int phi_dependency(struct block *block)
{
        /* A block has a phi dependency if a phi function
         * depends on that block to exist, and makes a block
         * that is otherwise useless unsafe to remove.
         */
        if (block) {
                struct block_set *edge;
                for(edge = block->edges; edge; edge = edge->next) {
                        if (phi_present(edge->member)) {
                                return 1;
                        }
                }
        }
        return 0;
}

static struct triple *branch_target(struct compile_state *state, struct triple *ins)
{
        struct triple *targ;
        targ = TARG(ins, 0);
        /* During scc_transform temporary triples are allocated that
         * loop back onto themselves. If I see one don't advance the
         * target.
         */
        while(triple_is_structural(state, targ) && 
                (targ->next != targ) && (targ->next != state->first)) {
                targ = targ->next;
        }
        return targ;
}


static void simplify_branch(struct compile_state *state, struct triple *ins)
{
        int simplified, loops;
        if ((ins->op != OP_BRANCH) && (ins->op != OP_CBRANCH)) {
                internal_error(state, ins, "not branch");
        }
        if (ins->use != 0) {
                internal_error(state, ins, "branch use");
        }
        /* The challenge here with simplify branch is that I need to 
         * make modifications to the control flow graph as well
         * as to the branch instruction itself.  That is handled
         * by rebuilding the basic blocks after simplify all is called.
         */

        /* If we have a branch to an unconditional branch update
         * our target.  But watch out for dependencies from phi
         * functions.
         * Also only do this a limited number of times so
         * we don't get into an infinite loop.
         */
        loops = 0;
        do {
                struct triple *targ;
                simplified = 0;
                targ = branch_target(state, ins);
                if ((targ != ins) && (targ->op == OP_BRANCH) && 
                        !phi_dependency(targ->u.block))
                {
                        unuse_triple(TARG(ins, 0), ins);
                        TARG(ins, 0) = TARG(targ, 0);
                        use_triple(TARG(ins, 0), ins);
                        simplified = 1;
                }
        } while(simplified && (++loops < 20));

        /* If we have a conditional branch with a constant condition
         * make it an unconditional branch.
         */
        if ((ins->op == OP_CBRANCH) && is_simple_const(RHS(ins, 0))) {
                struct triple *targ;
                ulong_t value;
                value = read_const(state, ins, RHS(ins, 0));
                unuse_triple(RHS(ins, 0), ins);
                targ = TARG(ins, 0);
                ins->rhs  = 0;
                ins->targ = 1;
                ins->op = OP_BRANCH;
                if (value) {
                        unuse_triple(ins->next, ins);
                        TARG(ins, 0) = targ;
                }
                else {
                        unuse_triple(targ, ins);
                        TARG(ins, 0) = ins->next;
                }
        }

        /* If we have a branch to the next instruction,
         * make it a noop.
         */
        if (TARG(ins, 0) == ins->next) {
                unuse_triple(TARG(ins, 0), ins);
                if (ins->op == OP_CBRANCH) {
                        unuse_triple(RHS(ins, 0), ins);
                        unuse_triple(ins->next, ins);
                }
                ins->lhs = 0;
                ins->rhs = 0;
                ins->misc = 0;
                ins->targ = 0;
                ins->op = OP_NOOP;
                if (ins->use) {
                        internal_error(state, ins, "noop use != 0");
                }
        }
}

static void simplify_label(struct compile_state *state, struct triple *ins)
{
        /* Ignore volatile labels */
        if (!triple_is_pure(state, ins, ins->id)) {
                return;
        }
        if (ins->use == 0) {
                ins->op = OP_NOOP;
        }
        else if (ins->prev->op == OP_LABEL) {
                /* In general it is not safe to merge one label that
                 * imediately follows another.  The problem is that the empty
                 * looking block may have phi functions that depend on it.
                 */
                if (!phi_dependency(ins->prev->u.block)) {
                        struct triple_set *user, *next;
                        ins->op = OP_NOOP;
                        for(user = ins->use; user; user = next) {
                                struct triple *use, **expr;
                                next = user->next;
                                use = user->member;
                                expr = triple_targ(state, use, 0);
                                for(;expr; expr = triple_targ(state, use, expr)) {
                                        if (*expr == ins) {
                                                *expr = ins->prev;
                                                unuse_triple(ins, use);
                                                use_triple(ins->prev, use);
                                        }
                                        
                                }
                        }
                        if (ins->use) {
                                internal_error(state, ins, "noop use != 0");
                        }
                }
        }
}

static void simplify_phi(struct compile_state *state, struct triple *ins)
{
        struct triple **slot;
        struct triple *value;
        int zrhs, i;
        ulong_t cvalue;
        slot = &RHS(ins, 0);
        zrhs = ins->rhs;
        if (zrhs == 0) {
                return;
        }
        /* See if all of the rhs members of a phi have the same value */
        if (slot[0] && is_simple_const(slot[0])) {
                cvalue = read_const(state, ins, slot[0]);
                for(i = 1; i < zrhs; i++) {
                        if (    !slot[i] ||
                                !is_simple_const(slot[i]) ||
                                !equiv_types(slot[0]->type, slot[i]->type) ||
                                (cvalue != read_const(state, ins, slot[i]))) {
                                break;
                        }
                }
                if (i == zrhs) {
                        mkconst(state, ins, cvalue);
                        return;
                }
        }
        
        /* See if all of rhs members of a phi are the same */
        value = slot[0];
        for(i = 1; i < zrhs; i++) {
                if (slot[i] != value) {
                        break;
                }
        }
        if (i == zrhs) {
                /* If the phi has a single value just copy it */
                if (!is_subset_type(ins->type, value->type)) {
                        internal_error(state, ins, "bad input type to phi");
                }
                /* Make the types match */
                if (!equiv_types(ins->type, value->type)) {
                        ins->type = value->type;
                }
                /* Now make the actual copy */
                mkcopy(state, ins, value);
                return;
        }
}


static void simplify_bsf(struct compile_state *state, struct triple *ins)
{
        if (is_simple_const(RHS(ins, 0))) {
                ulong_t left;
                left = read_const(state, ins, RHS(ins, 0));
                mkconst(state, ins, bsf(left));
        }
}

static void simplify_bsr(struct compile_state *state, struct triple *ins)
{
        if (is_simple_const(RHS(ins, 0))) {
                ulong_t left;
                left = read_const(state, ins, RHS(ins, 0));
                mkconst(state, ins, bsr(left));
        }
}


typedef void (*simplify_t)(struct compile_state *state, struct triple *ins);
static const struct simplify_table {
        simplify_t func;
        unsigned long flag;
} table_simplify[] = {
#define simplify_sdivt    simplify_noop
#define simplify_udivt    simplify_noop
#define simplify_piece    simplify_noop

[OP_SDIVT      ] = { simplify_sdivt,    COMPILER_SIMPLIFY_ARITH },
[OP_UDIVT      ] = { simplify_udivt,    COMPILER_SIMPLIFY_ARITH },
[OP_SMUL       ] = { simplify_smul,     COMPILER_SIMPLIFY_ARITH },
[OP_UMUL       ] = { simplify_umul,     COMPILER_SIMPLIFY_ARITH },
[OP_SDIV       ] = { simplify_sdiv,     COMPILER_SIMPLIFY_ARITH },
[OP_UDIV       ] = { simplify_udiv,     COMPILER_SIMPLIFY_ARITH },
[OP_SMOD       ] = { simplify_smod,     COMPILER_SIMPLIFY_ARITH },
[OP_UMOD       ] = { simplify_umod,     COMPILER_SIMPLIFY_ARITH },
[OP_ADD        ] = { simplify_add,      COMPILER_SIMPLIFY_ARITH },
[OP_SUB        ] = { simplify_sub,      COMPILER_SIMPLIFY_ARITH },
[OP_SL         ] = { simplify_sl,       COMPILER_SIMPLIFY_SHIFT },
[OP_USR        ] = { simplify_usr,      COMPILER_SIMPLIFY_SHIFT },
[OP_SSR        ] = { simplify_ssr,      COMPILER_SIMPLIFY_SHIFT },
[OP_AND        ] = { simplify_and,      COMPILER_SIMPLIFY_BITWISE },
[OP_XOR        ] = { simplify_xor,      COMPILER_SIMPLIFY_BITWISE },
[OP_OR         ] = { simplify_or,       COMPILER_SIMPLIFY_BITWISE },
[OP_POS        ] = { simplify_pos,      COMPILER_SIMPLIFY_ARITH },
[OP_NEG        ] = { simplify_neg,      COMPILER_SIMPLIFY_ARITH },
[OP_INVERT     ] = { simplify_invert,   COMPILER_SIMPLIFY_BITWISE },

[OP_EQ         ] = { simplify_eq,       COMPILER_SIMPLIFY_LOGICAL },
[OP_NOTEQ      ] = { simplify_noteq,    COMPILER_SIMPLIFY_LOGICAL },
[OP_SLESS      ] = { simplify_sless,    COMPILER_SIMPLIFY_LOGICAL },
[OP_ULESS      ] = { simplify_uless,    COMPILER_SIMPLIFY_LOGICAL },
[OP_SMORE      ] = { simplify_smore,    COMPILER_SIMPLIFY_LOGICAL },
[OP_UMORE      ] = { simplify_umore,    COMPILER_SIMPLIFY_LOGICAL },
[OP_SLESSEQ    ] = { simplify_slesseq,  COMPILER_SIMPLIFY_LOGICAL },
[OP_ULESSEQ    ] = { simplify_ulesseq,  COMPILER_SIMPLIFY_LOGICAL },
[OP_SMOREEQ    ] = { simplify_smoreeq,  COMPILER_SIMPLIFY_LOGICAL },
[OP_UMOREEQ    ] = { simplify_umoreeq,  COMPILER_SIMPLIFY_LOGICAL },
[OP_LFALSE     ] = { simplify_lfalse,   COMPILER_SIMPLIFY_LOGICAL },
[OP_LTRUE      ] = { simplify_ltrue,    COMPILER_SIMPLIFY_LOGICAL },

[OP_LOAD       ] = { simplify_load,     COMPILER_SIMPLIFY_OP },
[OP_STORE      ] = { simplify_noop,     COMPILER_SIMPLIFY_OP },

[OP_UEXTRACT   ] = { simplify_uextract, COMPILER_SIMPLIFY_BITFIELD },
[OP_SEXTRACT   ] = { simplify_sextract, COMPILER_SIMPLIFY_BITFIELD },
[OP_DEPOSIT    ] = { simplify_deposit,  COMPILER_SIMPLIFY_BITFIELD },

[OP_NOOP       ] = { simplify_noop,     COMPILER_SIMPLIFY_OP },

[OP_INTCONST   ] = { simplify_noop,     COMPILER_SIMPLIFY_OP },
[OP_BLOBCONST  ] = { simplify_noop,     COMPILER_SIMPLIFY_OP },
[OP_ADDRCONST  ] = { simplify_noop,     COMPILER_SIMPLIFY_OP },
[OP_UNKNOWNVAL ] = { simplify_noop,     COMPILER_SIMPLIFY_OP },

[OP_WRITE      ] = { simplify_noop,     COMPILER_SIMPLIFY_OP },
[OP_READ       ] = { simplify_noop,     COMPILER_SIMPLIFY_OP },
[OP_COPY       ] = { simplify_copy,     COMPILER_SIMPLIFY_COPY },
[OP_CONVERT    ] = { simplify_copy,     COMPILER_SIMPLIFY_COPY },
[OP_PIECE      ] = { simplify_piece,    COMPILER_SIMPLIFY_OP },
[OP_ASM        ] = { simplify_noop,     COMPILER_SIMPLIFY_OP },

[OP_DOT        ] = { simplify_noop,     COMPILER_SIMPLIFY_OP },
[OP_INDEX      ] = { simplify_noop,     COMPILER_SIMPLIFY_OP },

[OP_LIST       ] = { simplify_noop,     COMPILER_SIMPLIFY_OP },
[OP_BRANCH     ] = { simplify_branch,   COMPILER_SIMPLIFY_BRANCH },
[OP_CBRANCH    ] = { simplify_branch,   COMPILER_SIMPLIFY_BRANCH },
[OP_CALL       ] = { simplify_noop,     COMPILER_SIMPLIFY_BRANCH },
[OP_RET        ] = { simplify_noop,     COMPILER_SIMPLIFY_BRANCH },
[OP_LABEL      ] = { simplify_label,    COMPILER_SIMPLIFY_LABEL },
[OP_ADECL      ] = { simplify_noop,     COMPILER_SIMPLIFY_OP },
[OP_SDECL      ] = { simplify_noop,     COMPILER_SIMPLIFY_OP },
[OP_PHI        ] = { simplify_phi,      COMPILER_SIMPLIFY_PHI },

[OP_INB        ] = { simplify_noop,     COMPILER_SIMPLIFY_OP },
[OP_INW        ] = { simplify_noop,     COMPILER_SIMPLIFY_OP },
[OP_INL        ] = { simplify_noop,     COMPILER_SIMPLIFY_OP },
[OP_OUTB       ] = { simplify_noop,     COMPILER_SIMPLIFY_OP },
[OP_OUTW       ] = { simplify_noop,     COMPILER_SIMPLIFY_OP },
[OP_OUTL       ] = { simplify_noop,     COMPILER_SIMPLIFY_OP },
[OP_BSF        ] = { simplify_bsf,      COMPILER_SIMPLIFY_OP },
[OP_BSR        ] = { simplify_bsr,      COMPILER_SIMPLIFY_OP },
[OP_RDMSR      ] = { simplify_noop,     COMPILER_SIMPLIFY_OP },
[OP_WRMSR      ] = { simplify_noop,     COMPILER_SIMPLIFY_OP },               
[OP_HLT        ] = { simplify_noop,     COMPILER_SIMPLIFY_OP },
};

static inline void debug_simplify(struct compile_state *state, 
        simplify_t do_simplify, struct triple *ins)
{
#if DEBUG_SIMPLIFY_HIRES
                if (state->functions_joined && (do_simplify != simplify_noop)) {
                        /* High resolution debugging mode */
                        fprintf(state->dbgout, "simplifing: ");
                        display_triple(state->dbgout, ins);
                }
#endif
                do_simplify(state, ins);
#if DEBUG_SIMPLIFY_HIRES
                if (state->functions_joined && (do_simplify != simplify_noop)) {
                        /* High resolution debugging mode */
                        fprintf(state->dbgout, "simplified: ");
                        display_triple(state->dbgout, ins);
                }
#endif
}
static void simplify(struct compile_state *state, struct triple *ins)
{
        int op;
        simplify_t do_simplify;
        if (ins == &unknown_triple) {
                internal_error(state, ins, "simplifying the unknown triple?");
        }
        do {
                op = ins->op;
                do_simplify = 0;
                if ((op < 0) || (op > sizeof(table_simplify)/sizeof(table_simplify[0]))) {
                        do_simplify = 0;
                }
                else {
                        do_simplify = table_simplify[op].func;
                }
                if (do_simplify && 
                        !(state->compiler->flags & table_simplify[op].flag)) {
                        do_simplify = simplify_noop;
                }
                if (do_simplify && (ins->id & TRIPLE_FLAG_VOLATILE)) {
                        do_simplify = simplify_noop;
                }
        
                if (!do_simplify) {
                        internal_error(state, ins, "cannot simplify op: %d %s",
                                op, tops(op));
                        return;
                }
                debug_simplify(state, do_simplify, ins);
        } while(ins->op != op);
}

static void rebuild_ssa_form(struct compile_state *state);

static void simplify_all(struct compile_state *state)
{
        struct triple *ins, *first;
        if (!(state->compiler->flags & COMPILER_SIMPLIFY)) {
                return;
        }
        first = state->first;
        ins = first->prev;
        do {
                simplify(state, ins);
                ins = ins->prev;
        } while(ins != first->prev);
        ins = first;
        do {
                simplify(state, ins);
                ins = ins->next;
        }while(ins != first);
        rebuild_ssa_form(state);

        print_blocks(state, __func__, state->dbgout);
}

/*
 * Builtins....
 * ============================
 */

static void register_builtin_function(struct compile_state *state,
        const char *name, int op, struct type *rtype, ...)
{
        struct type *ftype, *atype, *ctype, *crtype, *param, **next;
        struct triple *def, *arg, *result, *work, *last, *first, *retvar, *ret;
        struct hash_entry *ident;
        struct file_state file;
        int parameters;
        int name_len;
        va_list args;
        int i;

        /* Dummy file state to get debug handling right */
        memset(&file, 0, sizeof(file));
        file.basename = "<built-in>";
        file.line = 1;
        file.report_line = 1;
        file.report_name = file.basename;
        file.prev = state->file;
        state->file = &file;
        state->function = name;

        /* Find the Parameter count */
        valid_op(state, op);
        parameters = table_ops[op].rhs;
        if (parameters < 0 ) {
                internal_error(state, 0, "Invalid builtin parameter count");
        }

        /* Find the function type */
        ftype = new_type(TYPE_FUNCTION | STOR_INLINE | STOR_STATIC, rtype, 0);
        ftype->elements = parameters;
        next = &ftype->right;
        va_start(args, rtype);
        for(i = 0; i < parameters; i++) {
                atype = va_arg(args, struct type *);
                if (!*next) {
                        *next = atype;
                } else {
                        *next = new_type(TYPE_PRODUCT, *next, atype);
                        next = &((*next)->right);
                }
        }
        if (!*next) {
                *next = &void_type;
        }
        va_end(args);

        /* Get the initial closure type */
        ctype = new_type(TYPE_JOIN, &void_type, 0);
        ctype->elements = 1;

        /* Get the return type */
        crtype = new_type(TYPE_TUPLE, new_type(TYPE_PRODUCT, ctype, rtype), 0);
        crtype->elements = 2;

        /* Generate the needed triples */
        def = triple(state, OP_LIST, ftype, 0, 0);
        first = label(state);
        RHS(def, 0) = first;
        result = flatten(state, first, variable(state, crtype));
        retvar = flatten(state, first, variable(state, &void_ptr_type));
        ret = triple(state, OP_RET, &void_type, read_expr(state, retvar), 0);

        /* Now string them together */
        param = ftype->right;
        for(i = 0; i < parameters; i++) {
                if ((param->type & TYPE_MASK) == TYPE_PRODUCT) {
                        atype = param->left;
                } else {
                        atype = param;
                }
                arg = flatten(state, first, variable(state, atype));
                param = param->right;
        }
        work = new_triple(state, op, rtype, -1, parameters);
        generate_lhs_pieces(state, work);
        for(i = 0; i < parameters; i++) {
                RHS(work, i) = read_expr(state, farg(state, def, i));
        }
        if ((rtype->type & TYPE_MASK) != TYPE_VOID) {
                work = write_expr(state, deref_index(state, result, 1), work);
        }
        work = flatten(state, first, work);
        last = flatten(state, first, label(state));
        ret  = flatten(state, first, ret);
        name_len = strlen(name);
        ident = lookup(state, name, name_len);
        ftype->type_ident = ident;
        symbol(state, ident, &ident->sym_ident, def, ftype);
        
        state->file = file.prev;
        state->function = 0;
        state->main_function = 0;

        if (!state->functions) {
                state->functions = def;
        } else {
                insert_triple(state, state->functions, def);
        }
        if (state->compiler->debug & DEBUG_INLINE) {
                FILE *fp = state->dbgout;
                fprintf(fp, "\n");
                loc(fp, state, 0);
                fprintf(fp, "\n__________ %s _________\n", __FUNCTION__);
                display_func(state, fp, def);
                fprintf(fp, "__________ %s _________ done\n\n", __FUNCTION__);
        }
}

static struct type *partial_struct(struct compile_state *state,
        const char *field_name, struct type *type, struct type *rest)
{
        struct hash_entry *field_ident;
        struct type *result;
        int field_name_len;

        field_name_len = strlen(field_name);
        field_ident = lookup(state, field_name, field_name_len);

        result = clone_type(0, type);
        result->field_ident = field_ident;

        if (rest) {
                result = new_type(TYPE_PRODUCT, result, rest);
        }
        return result;
}

static struct type *register_builtin_type(struct compile_state *state,
        const char *name, struct type *type)
{
        struct hash_entry *ident;
        int name_len;

        name_len = strlen(name);
        ident = lookup(state, name, name_len);
        
        if ((type->type & TYPE_MASK) == TYPE_PRODUCT) {
                ulong_t elements = 0;
                struct type *field;
                type = new_type(TYPE_STRUCT, type, 0);
                field = type->left;
                while((field->type & TYPE_MASK) == TYPE_PRODUCT) {
                        elements++;
                        field = field->right;
                }
                elements++;
                symbol(state, ident, &ident->sym_tag, 0, type);
                type->type_ident = ident;
                type->elements = elements;
        }
        symbol(state, ident, &ident->sym_ident, 0, type);
        ident->tok = TOK_TYPE_NAME;
        return type;
}


static void register_builtins(struct compile_state *state)
{
        struct type *div_type, *ldiv_type;
        struct type *udiv_type, *uldiv_type;
        struct type *msr_type;

        div_type = register_builtin_type(state, "__builtin_div_t",
                partial_struct(state, "quot", &int_type,
                partial_struct(state, "rem",  &int_type, 0)));
        ldiv_type = register_builtin_type(state, "__builtin_ldiv_t",
                partial_struct(state, "quot", &long_type,
                partial_struct(state, "rem",  &long_type, 0)));
        udiv_type = register_builtin_type(state, "__builtin_udiv_t",
                partial_struct(state, "quot", &uint_type,
                partial_struct(state, "rem",  &uint_type, 0)));
        uldiv_type = register_builtin_type(state, "__builtin_uldiv_t",
                partial_struct(state, "quot", &ulong_type,
                partial_struct(state, "rem",  &ulong_type, 0)));

        register_builtin_function(state, "__builtin_div",   OP_SDIVT, div_type,
                &int_type, &int_type);
        register_builtin_function(state, "__builtin_ldiv",  OP_SDIVT, ldiv_type,
                &long_type, &long_type);
        register_builtin_function(state, "__builtin_udiv",  OP_UDIVT, udiv_type,
                &uint_type, &uint_type);
        register_builtin_function(state, "__builtin_uldiv", OP_UDIVT, uldiv_type,
                &ulong_type, &ulong_type);

        register_builtin_function(state, "__builtin_inb", OP_INB, &uchar_type, 
                &ushort_type);
        register_builtin_function(state, "__builtin_inw", OP_INW, &ushort_type,
                &ushort_type);
        register_builtin_function(state, "__builtin_inl", OP_INL, &uint_type,   
                &ushort_type);

        register_builtin_function(state, "__builtin_outb", OP_OUTB, &void_type, 
                &uchar_type, &ushort_type);
        register_builtin_function(state, "__builtin_outw", OP_OUTW, &void_type, 
                &ushort_type, &ushort_type);
        register_builtin_function(state, "__builtin_outl", OP_OUTL, &void_type, 
                &uint_type, &ushort_type);
        
        register_builtin_function(state, "__builtin_bsf", OP_BSF, &int_type, 
                &int_type);
        register_builtin_function(state, "__builtin_bsr", OP_BSR, &int_type, 
                &int_type);

        msr_type = register_builtin_type(state, "__builtin_msr_t",
                partial_struct(state, "lo", &ulong_type,
                partial_struct(state, "hi", &ulong_type, 0)));

        register_builtin_function(state, "__builtin_rdmsr", OP_RDMSR, msr_type,
                &ulong_type);
        register_builtin_function(state, "__builtin_wrmsr", OP_WRMSR, &void_type,
                &ulong_type, &ulong_type, &ulong_type);
        
        register_builtin_function(state, "__builtin_hlt", OP_HLT, &void_type, 
                &void_type);
}

static struct type *declarator(
        struct compile_state *state, struct type *type, 
        struct hash_entry **ident, int need_ident);
static void decl(struct compile_state *state, struct triple *first);
static struct type *specifier_qualifier_list(struct compile_state *state);
static int isdecl_specifier(int tok);
static struct type *decl_specifiers(struct compile_state *state);
static int istype(int tok);
static struct triple *expr(struct compile_state *state);
static struct triple *assignment_expr(struct compile_state *state);
static struct type *type_name(struct compile_state *state);
static void statement(struct compile_state *state, struct triple *first);

static struct triple *call_expr(
        struct compile_state *state, struct triple *func)
{
        struct triple *def;
        struct type *param, *type;
        ulong_t pvals, index;

        if ((func->type->type & TYPE_MASK) != TYPE_FUNCTION) {
                error(state, 0, "Called object is not a function");
        }
        if (func->op != OP_LIST) {
                internal_error(state, 0, "improper function");
        }
        eat(state, TOK_LPAREN);
        /* Find the return type without any specifiers */
        type = clone_type(0, func->type->left);
        /* Count the number of rhs entries for OP_FCALL */
        param = func->type->right;
        pvals = 0;
        while((param->type & TYPE_MASK) == TYPE_PRODUCT) {
                pvals++;
                param = param->right;
        }
        if ((param->type & TYPE_MASK) != TYPE_VOID) {
                pvals++;
        }
        def = new_triple(state, OP_FCALL, type, -1, pvals);
        MISC(def, 0) = func;

        param = func->type->right;
        for(index = 0; index < pvals; index++) {
                struct triple *val;
                struct type *arg_type;
                val = read_expr(state, assignment_expr(state));
                arg_type = param;
                if ((param->type & TYPE_MASK) == TYPE_PRODUCT) {
                        arg_type = param->left;
                }
                write_compatible(state, arg_type, val->type);
                RHS(def, index) = val;
                if (index != (pvals - 1)) {
                        eat(state, TOK_COMMA);
                        param = param->right;
                }
        }
        eat(state, TOK_RPAREN);
        return def;
}


static struct triple *character_constant(struct compile_state *state)
{
        struct triple *def;
        struct token *tk;
        const signed char *str, *end;
        int c;
        int str_len;
        tk = eat(state, TOK_LIT_CHAR);
        str = tk->val.str + 1;
        str_len = tk->str_len - 2;
        if (str_len <= 0) {
                error(state, 0, "empty character constant");
        }
        end = str + str_len;
        c = char_value(state, &str, end);
        if (str != end) {
                error(state, 0, "multibyte character constant not supported");
        }
        def = int_const(state, &char_type, (ulong_t)((long_t)c));
        return def;
}

static struct triple *string_constant(struct compile_state *state)
{
        struct triple *def;
        struct token *tk;
        struct type *type;
        const signed char *str, *end;
        signed char *buf, *ptr;
        int str_len;

        buf = 0;
        type = new_type(TYPE_ARRAY, &char_type, 0);
        type->elements = 0;
        /* The while loop handles string concatenation */
        do {
                tk = eat(state, TOK_LIT_STRING);
                str = tk->val.str + 1;
                str_len = tk->str_len - 2;
                if (str_len < 0) {
                        error(state, 0, "negative string constant length");
                }
                end = str + str_len;
                ptr = buf;
                buf = xmalloc(type->elements + str_len + 1, "string_constant");
                memcpy(buf, ptr, type->elements);
                ptr = buf + type->elements;
                do {
                        *ptr++ = char_value(state, &str, end);
                } while(str < end);
                type->elements = ptr - buf;
        } while(peek(state) == TOK_LIT_STRING);
        *ptr = '\0';
        type->elements += 1;
        def = triple(state, OP_BLOBCONST, type, 0, 0);
        def->u.blob = buf;

        return def;
}


static struct triple *integer_constant(struct compile_state *state)
{
        struct triple *def;
        unsigned long val;
        struct token *tk;
        char *end;
        int u, l, decimal;
        struct type *type;

        tk = eat(state, TOK_LIT_INT);
        errno = 0;
        decimal = (tk->val.str[0] != '0');
        val = strtoul(tk->val.str, &end, 0);
        if ((val > ULONG_T_MAX) || ((val == ULONG_MAX) && (errno == ERANGE))) {
                error(state, 0, "Integer constant to large");
        }
        u = l = 0;
        if ((*end == 'u') || (*end == 'U')) {
                u = 1;
                        end++;
        }
        if ((*end == 'l') || (*end == 'L')) {
                l = 1;
                end++;
        }
        if ((*end == 'u') || (*end == 'U')) {
                u = 1;
                end++;
        }
        if (*end) {
                error(state, 0, "Junk at end of integer constant");
        }
        if (u && l)  {
                type = &ulong_type;
        }
        else if (l) {
                type = &long_type;
                if (!decimal && (val > LONG_T_MAX)) {
                        type = &ulong_type;
                }
        }
        else if (u) {
                type = &uint_type;
                if (val > UINT_T_MAX) {
                        type = &ulong_type;
                }
        }
        else {
                type = &int_type;
                if (!decimal && (val > INT_T_MAX) && (val <= UINT_T_MAX)) {
                        type = &uint_type;
                }
                else if (!decimal && (val > LONG_T_MAX)) {
                        type = &ulong_type;
                }
                else if (val > INT_T_MAX) {
                        type = &long_type;
                }
        }
        def = int_const(state, type, val);
        return def;
}

static struct triple *primary_expr(struct compile_state *state)
{
        struct triple *def;
        int tok;
        tok = peek(state);
        switch(tok) {
        case TOK_IDENT:
        {
                struct hash_entry *ident;
                /* Here ident is either:
                 * a varable name
                 * a function name
                 */
                ident = eat(state, TOK_IDENT)->ident;
                if (!ident->sym_ident) {
                        error(state, 0, "%s undeclared", ident->name);
                }
                def = ident->sym_ident->def;
                break;
        }
        case TOK_ENUM_CONST:
        {
                struct hash_entry *ident;
                /* Here ident is an enumeration constant */
                ident = eat(state, TOK_ENUM_CONST)->ident;
                if (!ident->sym_ident) {
                        error(state, 0, "%s undeclared", ident->name);
                }
                def = ident->sym_ident->def;
                break;
        }
        case TOK_MIDENT:
        {
                struct hash_entry *ident;
                ident = eat(state, TOK_MIDENT)->ident;
                warning(state, 0, "Replacing undefined macro: %s with 0",
                        ident->name);
                def = int_const(state, &int_type, 0);
                break;
        }
        case TOK_LPAREN:
                eat(state, TOK_LPAREN);
                def = expr(state);
                eat(state, TOK_RPAREN);
                break;
        case TOK_LIT_INT:
                def = integer_constant(state);
                break;
        case TOK_LIT_FLOAT:
                eat(state, TOK_LIT_FLOAT);
                error(state, 0, "Floating point constants not supported");
                def = 0;
                FINISHME();
                break;
        case TOK_LIT_CHAR:
                def = character_constant(state);
                break;
        case TOK_LIT_STRING:
                def = string_constant(state);
                break;
        default:
                def = 0;
                error(state, 0, "Unexpected token: %s\n", tokens[tok]);
        }
        return def;
}

static struct triple *postfix_expr(struct compile_state *state)
{
        struct triple *def;
        int postfix;
        def = primary_expr(state);
        do {
                struct triple *left;
                int tok;
                postfix = 1;
                left = def;
                switch((tok = peek(state))) {
                case TOK_LBRACKET:
                        eat(state, TOK_LBRACKET);
                        def = mk_subscript_expr(state, left, expr(state));
                        eat(state, TOK_RBRACKET);
                        break;
                case TOK_LPAREN:
                        def = call_expr(state, def);
                        break;
                case TOK_DOT:
                {
                        struct hash_entry *field;
                        eat(state, TOK_DOT);
                        field = eat(state, TOK_IDENT)->ident;
                        def = deref_field(state, def, field);
                        break;
                }
                case TOK_ARROW:
                {
                        struct hash_entry *field;
                        eat(state, TOK_ARROW);
                        field = eat(state, TOK_IDENT)->ident;
                        def = mk_deref_expr(state, read_expr(state, def));
                        def = deref_field(state, def, field);
                        break;
                }
                case TOK_PLUSPLUS:
                        eat(state, TOK_PLUSPLUS);
                        def = mk_post_inc_expr(state, left);
                        break;
                case TOK_MINUSMINUS:
                        eat(state, TOK_MINUSMINUS);
                        def = mk_post_dec_expr(state, left);
                        break;
                default:
                        postfix = 0;
                        break;
                }
        } while(postfix);
        return def;
}

static struct triple *cast_expr(struct compile_state *state);

static struct triple *unary_expr(struct compile_state *state)
{
        struct triple *def, *right;
        int tok;
        switch((tok = peek(state))) {
        case TOK_PLUSPLUS:
                eat(state, TOK_PLUSPLUS);
                def = mk_pre_inc_expr(state, unary_expr(state));
                break;
        case TOK_MINUSMINUS:
                eat(state, TOK_MINUSMINUS);
                def = mk_pre_dec_expr(state, unary_expr(state));
                break;
        case TOK_AND:
                eat(state, TOK_AND);
                def = mk_addr_expr(state, cast_expr(state), 0);
                break;
        case TOK_STAR:
                eat(state, TOK_STAR);
                def = mk_deref_expr(state, read_expr(state, cast_expr(state)));
                break;
        case TOK_PLUS:
                eat(state, TOK_PLUS);
                right = read_expr(state, cast_expr(state));
                arithmetic(state, right);
                def = integral_promotion(state, right);
                break;
        case TOK_MINUS:
                eat(state, TOK_MINUS);
                right = read_expr(state, cast_expr(state));
                arithmetic(state, right);
                def = integral_promotion(state, right);
                def = triple(state, OP_NEG, def->type, def, 0);
                break;
        case TOK_TILDE:
                eat(state, TOK_TILDE);
                right = read_expr(state, cast_expr(state));
                integral(state, right);
                def = integral_promotion(state, right);
                def = triple(state, OP_INVERT, def->type, def, 0);
                break;
        case TOK_BANG:
                eat(state, TOK_BANG);
                right = read_expr(state, cast_expr(state));
                bool(state, right);
                def = lfalse_expr(state, right);
                break;
        case TOK_SIZEOF:
        {
                struct type *type;
                int tok1, tok2;
                eat(state, TOK_SIZEOF);
                tok1 = peek(state);
                tok2 = peek2(state);
                if ((tok1 == TOK_LPAREN) && istype(tok2)) {
                        eat(state, TOK_LPAREN);
                        type = type_name(state);
                        eat(state, TOK_RPAREN);
                }
                else {
                        struct triple *expr;
                        expr = unary_expr(state);
                        type = expr->type;
                        release_expr(state, expr);
                }
                def = int_const(state, &ulong_type, size_of_in_bytes(state, type));
                break;
        }
        case TOK_ALIGNOF:
        {
                struct type *type;
                int tok1, tok2;
                eat(state, TOK_ALIGNOF);
                tok1 = peek(state);
                tok2 = peek2(state);
                if ((tok1 == TOK_LPAREN) && istype(tok2)) {
                        eat(state, TOK_LPAREN);
                        type = type_name(state);
                        eat(state, TOK_RPAREN);
                }
                else {
                        struct triple *expr;
                        expr = unary_expr(state);
                        type = expr->type;
                        release_expr(state, expr);
                }
                def = int_const(state, &ulong_type, align_of_in_bytes(state, type));
                break;
        }
        case TOK_MDEFINED:
        {
                /* We only come here if we are called from the preprocessor */
                struct hash_entry *ident;
                int parens;
                eat(state, TOK_MDEFINED);
                parens = 0;
                if (pp_peek(state) == TOK_LPAREN) {
                        pp_eat(state, TOK_LPAREN);
                        parens = 1;
                }
                ident = pp_eat(state, TOK_MIDENT)->ident;
                if (parens) {
                        eat(state, TOK_RPAREN);
                }
                def = int_const(state, &int_type, ident->sym_define != 0);
                break;
        }
        default:
                def = postfix_expr(state);
                break;
        }
        return def;
}

static struct triple *cast_expr(struct compile_state *state)
{
        struct triple *def;
        int tok1, tok2;
        tok1 = peek(state);
        tok2 = peek2(state);
        if ((tok1 == TOK_LPAREN) && istype(tok2)) {
                struct type *type;
                eat(state, TOK_LPAREN);
                type = type_name(state);
                eat(state, TOK_RPAREN);
                def = mk_cast_expr(state, type, cast_expr(state));
        }
        else {
                def = unary_expr(state);
        }
        return def;
}

static struct triple *mult_expr(struct compile_state *state)
{
        struct triple *def;
        int done;
        def = cast_expr(state);
        do {
                struct triple *left, *right;
                struct type *result_type;
                int tok, op, sign;
                done = 0;
                tok = peek(state);
                switch(tok) {
                case TOK_STAR:
                case TOK_DIV:
                case TOK_MOD:
                        left = read_expr(state, def);
                        arithmetic(state, left);

                        eat(state, tok);

                        right = read_expr(state, cast_expr(state));
                        arithmetic(state, right);

                        result_type = arithmetic_result(state, left, right);
                        sign = is_signed(result_type);
                        op = -1;
                        switch(tok) {
                        case TOK_STAR: op = sign? OP_SMUL : OP_UMUL; break;
                        case TOK_DIV:  op = sign? OP_SDIV : OP_UDIV; break;
                        case TOK_MOD:  op = sign? OP_SMOD : OP_UMOD; break;
                        }
                        def = triple(state, op, result_type, left, right);
                        break;
                default:
                        done = 1;
                        break;
                }
        } while(!done);
        return def;
}

static struct triple *add_expr(struct compile_state *state)
{
        struct triple *def;
        int done;
        def = mult_expr(state);
        do {
                done = 0;
                switch( peek(state)) {
                case TOK_PLUS:
                        eat(state, TOK_PLUS);
                        def = mk_add_expr(state, def, mult_expr(state));
                        break;
                case TOK_MINUS:
                        eat(state, TOK_MINUS);
                        def = mk_sub_expr(state, def, mult_expr(state));
                        break;
                default:
                        done = 1;
                        break;
                }
        } while(!done);
        return def;
}

static struct triple *shift_expr(struct compile_state *state)
{
        struct triple *def;
        int done;
        def = add_expr(state);
        do {
                struct triple *left, *right;
                int tok, op;
                done = 0;
                switch((tok = peek(state))) {
                case TOK_SL:
                case TOK_SR:
                        left = read_expr(state, def);
                        integral(state, left);
                        left = integral_promotion(state, left);

                        eat(state, tok);

                        right = read_expr(state, add_expr(state));
                        integral(state, right);
                        right = integral_promotion(state, right);
                        
                        op = (tok == TOK_SL)? OP_SL : 
                                is_signed(left->type)? OP_SSR: OP_USR;

                        def = triple(state, op, left->type, left, right);
                        break;
                default:
                        done = 1;
                        break;
                }
        } while(!done);
        return def;
}

static struct triple *relational_expr(struct compile_state *state)
{
#warning "Extend relational exprs to work on more than arithmetic types"
        struct triple *def;
        int done;
        def = shift_expr(state);
        do {
                struct triple *left, *right;
                struct type *arg_type;
                int tok, op, sign;
                done = 0;
                switch((tok = peek(state))) {
                case TOK_LESS:
                case TOK_MORE:
                case TOK_LESSEQ:
                case TOK_MOREEQ:
                        left = read_expr(state, def);
                        arithmetic(state, left);

                        eat(state, tok);

                        right = read_expr(state, shift_expr(state));
                        arithmetic(state, right);

                        arg_type = arithmetic_result(state, left, right);
                        sign = is_signed(arg_type);
                        op = -1;
                        switch(tok) {
                        case TOK_LESS:   op = sign? OP_SLESS : OP_ULESS; break;
                        case TOK_MORE:   op = sign? OP_SMORE : OP_UMORE; break;
                        case TOK_LESSEQ: op = sign? OP_SLESSEQ : OP_ULESSEQ; break;
                        case TOK_MOREEQ: op = sign? OP_SMOREEQ : OP_UMOREEQ; break;
                        }
                        def = triple(state, op, &int_type, left, right);
                        break;
                default:
                        done = 1;
                        break;
                }
        } while(!done);
        return def;
}

static struct triple *equality_expr(struct compile_state *state)
{
#warning "Extend equality exprs to work on more than arithmetic types"
        struct triple *def;
        int done;
        def = relational_expr(state);
        do {
                struct triple *left, *right;
                int tok, op;
                done = 0;
                switch((tok = peek(state))) {
                case TOK_EQEQ:
                case TOK_NOTEQ:
                        left = read_expr(state, def);
                        arithmetic(state, left);
                        eat(state, tok);
                        right = read_expr(state, relational_expr(state));
                        arithmetic(state, right);
                        op = (tok == TOK_EQEQ) ? OP_EQ: OP_NOTEQ;
                        def = triple(state, op, &int_type, left, right);
                        break;
                default:
                        done = 1;
                        break;
                }
        } while(!done);
        return def;
}

static struct triple *and_expr(struct compile_state *state)
{
        struct triple *def;
        def = equality_expr(state);
        while(peek(state) == TOK_AND) {
                struct triple *left, *right;
                struct type *result_type;
                left = read_expr(state, def);
                integral(state, left);
                eat(state, TOK_AND);
                right = read_expr(state, equality_expr(state));
                integral(state, right);
                result_type = arithmetic_result(state, left, right);
                def = triple(state, OP_AND, result_type, left, right);
        }
        return def;
}

static struct triple *xor_expr(struct compile_state *state)
{
        struct triple *def;
        def = and_expr(state);
        while(peek(state) == TOK_XOR) {
                struct triple *left, *right;
                struct type *result_type;
                left = read_expr(state, def);
                integral(state, left);
                eat(state, TOK_XOR);
                right = read_expr(state, and_expr(state));
                integral(state, right);
                result_type = arithmetic_result(state, left, right);
                def = triple(state, OP_XOR, result_type, left, right);
        }
        return def;
}

static struct triple *or_expr(struct compile_state *state)
{
        struct triple *def;
        def = xor_expr(state);
        while(peek(state) == TOK_OR) {
                struct triple *left, *right;
                struct type *result_type;
                left = read_expr(state, def);
                integral(state, left);
                eat(state, TOK_OR);
                right = read_expr(state, xor_expr(state));
                integral(state, right);
                result_type = arithmetic_result(state, left, right);
                def = triple(state, OP_OR, result_type, left, right);
        }
        return def;
}

static struct triple *land_expr(struct compile_state *state)
{
        struct triple *def;
        def = or_expr(state);
        while(peek(state) == TOK_LOGAND) {
                struct triple *left, *right;
                left = read_expr(state, def);
                bool(state, left);
                eat(state, TOK_LOGAND);
                right = read_expr(state, or_expr(state));
                bool(state, right);

                def = mkland_expr(state,
                        ltrue_expr(state, left),
                        ltrue_expr(state, right));
        }
        return def;
}

static struct triple *lor_expr(struct compile_state *state)
{
        struct triple *def;
        def = land_expr(state);
        while(peek(state) == TOK_LOGOR) {
                struct triple *left, *right;
                left = read_expr(state, def);
                bool(state, left);
                eat(state, TOK_LOGOR);
                right = read_expr(state, land_expr(state));
                bool(state, right);

                def = mklor_expr(state, 
                        ltrue_expr(state, left),
                        ltrue_expr(state, right));
        }
        return def;
}

static struct triple *conditional_expr(struct compile_state *state)
{
        struct triple *def;
        def = lor_expr(state);
        if (peek(state) == TOK_QUEST) {
                struct triple *test, *left, *right;
                bool(state, def);
                test = ltrue_expr(state, read_expr(state, def));
                eat(state, TOK_QUEST);
                left = read_expr(state, expr(state));
                eat(state, TOK_COLON);
                right = read_expr(state, conditional_expr(state));

                def = mkcond_expr(state, test, left, right);
        }
        return def;
}

struct cv_triple {
        struct triple *val;
        int id;
};

static void set_cv(struct compile_state *state, struct cv_triple *cv,
        struct triple *dest, struct triple *val)
{
        if (cv[dest->id].val) {
                free_triple(state, cv[dest->id].val);
        }
        cv[dest->id].val = val;
}
static struct triple *get_cv(struct compile_state *state, struct cv_triple *cv,
        struct triple *src)
{
        return cv[src->id].val;
}

static struct triple *eval_const_expr(
        struct compile_state *state, struct triple *expr)
{
        struct triple *def;
        if (is_const(expr)) {
                def = expr;
        }
        else {
                /* If we don't start out as a constant simplify into one */
                struct triple *head, *ptr;
                struct cv_triple *cv;
                int i, count;
                head = label(state); /* dummy initial triple */
                flatten(state, head, expr);
                count = 1;
                for(ptr = head->next; ptr != head; ptr = ptr->next) {
                        count++;
                }
                cv = xcmalloc(sizeof(struct cv_triple)*count, "const value vector");
                i = 1;
                for(ptr = head->next; ptr != head; ptr = ptr->next) {
                        cv[i].val = 0;
                        cv[i].id  = ptr->id;
                        ptr->id   = i;
                        i++;
                }
                ptr = head->next;
                do {
                        valid_ins(state, ptr);
                        if ((ptr->op == OP_PHI) || (ptr->op == OP_LIST)) {
                                internal_error(state, ptr, 
                                        "unexpected %s in constant expression",
                                        tops(ptr->op));
                        }
                        else if (ptr->op == OP_LIST) {
                        }
                        else if (triple_is_structural(state, ptr)) {
                                ptr = ptr->next;
                        }
                        else if (triple_is_ubranch(state, ptr)) {
                                ptr = TARG(ptr, 0);
                        }
                        else if (triple_is_cbranch(state, ptr)) {
                                struct triple *cond_val;
                                cond_val = get_cv(state, cv, RHS(ptr, 0));
                                if (!cond_val || !is_const(cond_val) || 
                                        (cond_val->op != OP_INTCONST)) 
                                {
                                        internal_error(state, ptr, "bad branch condition");
                                }
                                if (cond_val->u.cval == 0) {
                                        ptr = ptr->next;
                                } else {
                                        ptr = TARG(ptr, 0);
                                }
                        }
                        else if (triple_is_branch(state, ptr)) {
                                error(state, ptr, "bad branch type in constant expression");
                        }
                        else if (ptr->op == OP_WRITE) {
                                struct triple *val;
                                val = get_cv(state, cv, RHS(ptr, 0));
                                
                                set_cv(state, cv, MISC(ptr, 0), 
                                        copy_triple(state, val));
                                set_cv(state, cv, ptr, 
                                        copy_triple(state, val));
                                ptr = ptr->next;
                        }
                        else if (ptr->op == OP_READ) {
                                set_cv(state, cv, ptr, 
                                        copy_triple(state, 
                                                get_cv(state, cv, RHS(ptr, 0))));
                                ptr = ptr->next;
                        }
                        else if (triple_is_pure(state, ptr, cv[ptr->id].id)) {
                                struct triple *val, **rhs;
                                val = copy_triple(state, ptr);
                                rhs = triple_rhs(state, val, 0);
                                for(; rhs; rhs = triple_rhs(state, val, rhs)) {
                                        if (!*rhs) {
                                                internal_error(state, ptr, "Missing rhs");
                                        }
                                        *rhs = get_cv(state, cv, *rhs);
                                }
                                simplify(state, val);
                                set_cv(state, cv, ptr, val);
                                ptr = ptr->next;
                        }
                        else {
                                error(state, ptr, "impure operation in constant expression");
                        }
                        
                } while(ptr != head);

                /* Get the result value */
                def = get_cv(state, cv, head->prev);
                cv[head->prev->id].val = 0;

                /* Free the temporary values */
                for(i = 0; i < count; i++) {
                        if (cv[i].val) {
                                free_triple(state, cv[i].val);
                                cv[i].val = 0;
                        }
                }
                xfree(cv);
                /* Free the intermediate expressions */
                while(head->next != head) {
                        release_triple(state, head->next);
                }
                free_triple(state, head);
        }
        if (!is_const(def)) {
                error(state, expr, "Not a constant expression");
        }
        return def;
}

static struct triple *constant_expr(struct compile_state *state)
{
        return eval_const_expr(state, conditional_expr(state));
}

static struct triple *assignment_expr(struct compile_state *state)
{
        struct triple *def, *left, *right;
        int tok, op, sign;
        /* The C grammer in K&R shows assignment expressions
         * only taking unary expressions as input on their
         * left hand side.  But specifies the precedence of
         * assignemnt as the lowest operator except for comma.
         *
         * Allowing conditional expressions on the left hand side
         * of an assignement results in a grammar that accepts
         * a larger set of statements than standard C.   As long
         * as the subset of the grammar that is standard C behaves
         * correctly this should cause no problems.
         * 
         * For the extra token strings accepted by the grammar
         * none of them should produce a valid lvalue, so they
         * should not produce functioning programs.
         *
         * GCC has this bug as well, so surprises should be minimal.
         */
        def = conditional_expr(state);
        left = def;
        switch((tok = peek(state))) {
        case TOK_EQ:
                lvalue(state, left);
                eat(state, TOK_EQ);
                def = write_expr(state, left, 
                        read_expr(state, assignment_expr(state)));
                break;
        case TOK_TIMESEQ:
        case TOK_DIVEQ:
        case TOK_MODEQ:
                lvalue(state, left);
                arithmetic(state, left);
                eat(state, tok);
                right = read_expr(state, assignment_expr(state));
                arithmetic(state, right);

                sign = is_signed(left->type);
                op = -1;
                switch(tok) {
                case TOK_TIMESEQ: op = sign? OP_SMUL : OP_UMUL; break;
                case TOK_DIVEQ:   op = sign? OP_SDIV : OP_UDIV; break;
                case TOK_MODEQ:   op = sign? OP_SMOD : OP_UMOD; break;
                }
                def = write_expr(state, left,
                        triple(state, op, left->type, 
                                read_expr(state, left), right));
                break;
        case TOK_PLUSEQ:
                lvalue(state, left);
                eat(state, TOK_PLUSEQ);
                def = write_expr(state, left,
                        mk_add_expr(state, left, assignment_expr(state)));
                break;
        case TOK_MINUSEQ:
                lvalue(state, left);
                eat(state, TOK_MINUSEQ);
                def = write_expr(state, left,
                        mk_sub_expr(state, left, assignment_expr(state)));
                break;
        case TOK_SLEQ:
        case TOK_SREQ:
        case TOK_ANDEQ:
        case TOK_XOREQ:
        case TOK_OREQ:
                lvalue(state, left);
                integral(state, left);
                eat(state, tok);
                right = read_expr(state, assignment_expr(state));
                integral(state, right);
                right = integral_promotion(state, right);
                sign = is_signed(left->type);
                op = -1;
                switch(tok) {
                case TOK_SLEQ:  op = OP_SL; break;
                case TOK_SREQ:  op = sign? OP_SSR: OP_USR; break;
                case TOK_ANDEQ: op = OP_AND; break;
                case TOK_XOREQ: op = OP_XOR; break;
                case TOK_OREQ:  op = OP_OR; break;
                }
                def = write_expr(state, left,
                        triple(state, op, left->type, 
                                read_expr(state, left), right));
                break;
        }
        return def;
}

static struct triple *expr(struct compile_state *state)
{
        struct triple *def;
        def = assignment_expr(state);
        while(peek(state) == TOK_COMMA) {
                eat(state, TOK_COMMA);
                def = mkprog(state, def, assignment_expr(state), 0);
        }
        return def;
}

static void expr_statement(struct compile_state *state, struct triple *first)
{
        if (peek(state) != TOK_SEMI) {
                /* lvalue conversions always apply except when certian operators
                 * are applied.  I apply the lvalue conversions here
                 * as I know no more operators will be applied.
                 */
                flatten(state, first, lvalue_conversion(state, expr(state)));
        }
        eat(state, TOK_SEMI);
}

static void if_statement(struct compile_state *state, struct triple *first)
{
        struct triple *test, *jmp1, *jmp2, *middle, *end;

        jmp1 = jmp2 = middle = 0;
        eat(state, TOK_IF);
        eat(state, TOK_LPAREN);
        test = expr(state);
        bool(state, test);
        /* Cleanup and invert the test */
        test = lfalse_expr(state, read_expr(state, test));
        eat(state, TOK_RPAREN);
        /* Generate the needed pieces */
        middle = label(state);
        jmp1 = branch(state, middle, test);
        /* Thread the pieces together */
        flatten(state, first, test);
        flatten(state, first, jmp1);
        flatten(state, first, label(state));
        statement(state, first);
        if (peek(state) == TOK_ELSE) {
                eat(state, TOK_ELSE);
                /* Generate the rest of the pieces */
                end = label(state);
                jmp2 = branch(state, end, 0);
                /* Thread them together */
                flatten(state, first, jmp2);
                flatten(state, first, middle);
                statement(state, first);
                flatten(state, first, end);
        }
        else {
                flatten(state, first, middle);
        }
}

static void for_statement(struct compile_state *state, struct triple *first)
{
        struct triple *head, *test, *tail, *jmp1, *jmp2, *end;
        struct triple *label1, *label2, *label3;
        struct hash_entry *ident;

        eat(state, TOK_FOR);
        eat(state, TOK_LPAREN);
        head = test = tail = jmp1 = jmp2 = 0;
        if (peek(state) != TOK_SEMI) {
                head = expr(state);
        } 
        eat(state, TOK_SEMI);
        if (peek(state) != TOK_SEMI) {
                test = expr(state);
                bool(state, test);
                test = ltrue_expr(state, read_expr(state, test));
        }
        eat(state, TOK_SEMI);
        if (peek(state) != TOK_RPAREN) {
                tail = expr(state);
        }
        eat(state, TOK_RPAREN);
        /* Generate the needed pieces */
        label1 = label(state);
        label2 = label(state);
        label3 = label(state);
        if (test) {
                jmp1 = branch(state, label3, 0);
                jmp2 = branch(state, label1, test);
        }
        else {
                jmp2 = branch(state, label1, 0);
        }
        end = label(state);
        /* Remember where break and continue go */
        start_scope(state);
        ident = state->i_break;
        symbol(state, ident, &ident->sym_ident, end, end->type);
        ident = state->i_continue;
        symbol(state, ident, &ident->sym_ident, label2, label2->type);
        /* Now include the body */
        flatten(state, first, head);
        flatten(state, first, jmp1);
        flatten(state, first, label1);
        statement(state, first);
        flatten(state, first, label2);
        flatten(state, first, tail);
        flatten(state, first, label3);
        flatten(state, first, test);
        flatten(state, first, jmp2);
        flatten(state, first, end);
        /* Cleanup the break/continue scope */
        end_scope(state);
}

static void while_statement(struct compile_state *state, struct triple *first)
{
        struct triple *label1, *test, *label2, *jmp1, *jmp2, *end;
        struct hash_entry *ident;
        eat(state, TOK_WHILE);
        eat(state, TOK_LPAREN);
        test = expr(state);
        bool(state, test);
        test = ltrue_expr(state, read_expr(state, test));
        eat(state, TOK_RPAREN);
        /* Generate the needed pieces */
        label1 = label(state);
        label2 = label(state);
        jmp1 = branch(state, label2, 0);
        jmp2 = branch(state, label1, test);
        end = label(state);
        /* Remember where break and continue go */
        start_scope(state);
        ident = state->i_break;
        symbol(state, ident, &ident->sym_ident, end, end->type);
        ident = state->i_continue;
        symbol(state, ident, &ident->sym_ident, label2, label2->type);
        /* Thread them together */
        flatten(state, first, jmp1);
        flatten(state, first, label1);
        statement(state, first);
        flatten(state, first, label2);
        flatten(state, first, test);
        flatten(state, first, jmp2);
        flatten(state, first, end);
        /* Cleanup the break/continue scope */
        end_scope(state);
}

static void do_statement(struct compile_state *state, struct triple *first)
{
        struct triple *label1, *label2, *test, *end;
        struct hash_entry *ident;
        eat(state, TOK_DO);
        /* Generate the needed pieces */
        label1 = label(state);
        label2 = label(state);
        end = label(state);
        /* Remember where break and continue go */
        start_scope(state);
        ident = state->i_break;
        symbol(state, ident, &ident->sym_ident, end, end->type);
        ident = state->i_continue;
        symbol(state, ident, &ident->sym_ident, label2, label2->type);
        /* Now include the body */
        flatten(state, first, label1);
        statement(state, first);
        /* Cleanup the break/continue scope */
        end_scope(state);
        /* Eat the rest of the loop */
        eat(state, TOK_WHILE);
        eat(state, TOK_LPAREN);
        test = read_expr(state, expr(state));
        bool(state, test);
        eat(state, TOK_RPAREN);
        eat(state, TOK_SEMI);
        /* Thread the pieces together */
        test = ltrue_expr(state, test);
        flatten(state, first, label2);
        flatten(state, first, test);
        flatten(state, first, branch(state, label1, test));
        flatten(state, first, end);
}


static void return_statement(struct compile_state *state, struct triple *first)
{
        struct triple *jmp, *mv, *dest, *var, *val;
        int last;
        eat(state, TOK_RETURN);

#warning "FIXME implement a more general excess branch elimination"
        val = 0;
        /* If we have a return value do some more work */
        if (peek(state) != TOK_SEMI) {
                val = read_expr(state, expr(state));
        }
        eat(state, TOK_SEMI);

        /* See if this last statement in a function */
        last = ((peek(state) == TOK_RBRACE) && 
                (state->scope_depth == GLOBAL_SCOPE_DEPTH +2));

        /* Find the return variable */
        var = fresult(state, state->main_function);

        /* Find the return destination */
        dest = state->i_return->sym_ident->def;
        mv = jmp = 0;
        /* If needed generate a jump instruction */
        if (!last) {
                jmp = branch(state, dest, 0);
        }
        /* If needed generate an assignment instruction */
        if (val) {
                mv = write_expr(state, deref_index(state, var, 1), val);
        }
        /* Now put the code together */
        if (mv) {
                flatten(state, first, mv);
                flatten(state, first, jmp);
        }
        else if (jmp) {
                flatten(state, first, jmp);
        }
}

static void break_statement(struct compile_state *state, struct triple *first)
{
        struct triple *dest;
        eat(state, TOK_BREAK);
        eat(state, TOK_SEMI);
        if (!state->i_break->sym_ident) {
                error(state, 0, "break statement not within loop or switch");
        }
        dest = state->i_break->sym_ident->def;
        flatten(state, first, branch(state, dest, 0));
}

static void continue_statement(struct compile_state *state, struct triple *first)
{
        struct triple *dest;
        eat(state, TOK_CONTINUE);
        eat(state, TOK_SEMI);
        if (!state->i_continue->sym_ident) {
                error(state, 0, "continue statement outside of a loop");
        }
        dest = state->i_continue->sym_ident->def;
        flatten(state, first, branch(state, dest, 0));
}

static void goto_statement(struct compile_state *state, struct triple *first)
{
        struct hash_entry *ident;
        eat(state, TOK_GOTO);
        ident = eat(state, TOK_IDENT)->ident;
        if (!ident->sym_label) {
                /* If this is a forward branch allocate the label now,
                 * it will be flattend in the appropriate location later.
                 */
                struct triple *ins;
                ins = label(state);
                label_symbol(state, ident, ins, FUNCTION_SCOPE_DEPTH);
        }
        eat(state, TOK_SEMI);

        flatten(state, first, branch(state, ident->sym_label->def, 0));
}

static void labeled_statement(struct compile_state *state, struct triple *first)
{
        struct triple *ins;
        struct hash_entry *ident;

        ident = eat(state, TOK_IDENT)->ident;
        if (ident->sym_label && ident->sym_label->def) {
                ins = ident->sym_label->def;
                put_occurance(ins->occurance);
                ins->occurance = new_occurance(state);
        }
        else {
                ins = label(state);
                label_symbol(state, ident, ins, FUNCTION_SCOPE_DEPTH);
        }
        if (ins->id & TRIPLE_FLAG_FLATTENED) {
                error(state, 0, "label %s already defined", ident->name);
        }
        flatten(state, first, ins);

        eat(state, TOK_COLON);
        statement(state, first);
}

static void switch_statement(struct compile_state *state, struct triple *first)
{
        struct triple *value, *top, *end, *dbranch;
        struct hash_entry *ident;

        /* See if we have a valid switch statement */
        eat(state, TOK_SWITCH);
        eat(state, TOK_LPAREN);
        value = expr(state);
        integral(state, value);
        value = read_expr(state, value);
        eat(state, TOK_RPAREN);
        /* Generate the needed pieces */
        top = label(state);
        end = label(state);
        dbranch = branch(state, end, 0);
        /* Remember where case branches and break goes */
        start_scope(state);
        ident = state->i_switch;
        symbol(state, ident, &ident->sym_ident, value, value->type);
        ident = state->i_case;
        symbol(state, ident, &ident->sym_ident, top, top->type);
        ident = state->i_break;
        symbol(state, ident, &ident->sym_ident, end, end->type);
        ident = state->i_default;
        symbol(state, ident, &ident->sym_ident, dbranch, dbranch->type);
        /* Thread them together */
        flatten(state, first, value);
        flatten(state, first, top);
        flatten(state, first, dbranch);
        statement(state, first);
        flatten(state, first, end);
        /* Cleanup the switch scope */
        end_scope(state);
}

static void case_statement(struct compile_state *state, struct triple *first)
{
        struct triple *cvalue, *dest, *test, *jmp;
        struct triple *ptr, *value, *top, *dbranch;

        /* See if w have a valid case statement */
        eat(state, TOK_CASE);
        cvalue = constant_expr(state);
        integral(state, cvalue);
        if (cvalue->op != OP_INTCONST) {
                error(state, 0, "integer constant expected");
        }
        eat(state, TOK_COLON);
        if (!state->i_case->sym_ident) {
                error(state, 0, "case statement not within a switch");
        }

        /* Lookup the interesting pieces */
        top = state->i_case->sym_ident->def;
        value = state->i_switch->sym_ident->def;
        dbranch = state->i_default->sym_ident->def;

        /* See if this case label has already been used */
        for(ptr = top; ptr != dbranch; ptr = ptr->next) {
                if (ptr->op != OP_EQ) {
                        continue;
                }
                if (RHS(ptr, 1)->u.cval == cvalue->u.cval) {
                        error(state, 0, "duplicate case %d statement",
                                cvalue->u.cval);
                }
        }
        /* Generate the needed pieces */
        dest = label(state);
        test = triple(state, OP_EQ, &int_type, value, cvalue);
        jmp = branch(state, dest, test);
        /* Thread the pieces together */
        flatten(state, dbranch, test);
        flatten(state, dbranch, jmp);
        flatten(state, dbranch, label(state));
        flatten(state, first, dest);
        statement(state, first);
}

static void default_statement(struct compile_state *state, struct triple *first)
{
        struct triple *dest;
        struct triple *dbranch, *end;

        /* See if we have a valid default statement */
        eat(state, TOK_DEFAULT);
        eat(state, TOK_COLON);

        if (!state->i_case->sym_ident) {
                error(state, 0, "default statement not within a switch");
        }

        /* Lookup the interesting pieces */
        dbranch = state->i_default->sym_ident->def;
        end = state->i_break->sym_ident->def;

        /* See if a default statement has already happened */
        if (TARG(dbranch, 0) != end) {
                error(state, 0, "duplicate default statement");
        }

        /* Generate the needed pieces */
        dest = label(state);

        /* Blame the branch on the default statement */
        put_occurance(dbranch->occurance);
        dbranch->occurance = new_occurance(state);

        /* Thread the pieces together */
        TARG(dbranch, 0) = dest;
        use_triple(dest, dbranch);
        flatten(state, first, dest);
        statement(state, first);
}

static void asm_statement(struct compile_state *state, struct triple *first)
{
        struct asm_info *info;
        struct {
                struct triple *constraint;
                struct triple *expr;
        } out_param[MAX_LHS], in_param[MAX_RHS], clob_param[MAX_LHS];
        struct triple *def, *asm_str;
        int out, in, clobbers, more, colons, i;
        int flags;

        flags = 0;
        eat(state, TOK_ASM);
        /* For now ignore the qualifiers */
        switch(peek(state)) {
        case TOK_CONST:
                eat(state, TOK_CONST);
                break;
        case TOK_VOLATILE:
                eat(state, TOK_VOLATILE);
                flags |= TRIPLE_FLAG_VOLATILE;
                break;
        }
        eat(state, TOK_LPAREN);
        asm_str = string_constant(state);

        colons = 0;
        out = in = clobbers = 0;
        /* Outputs */
        if ((colons == 0) && (peek(state) == TOK_COLON)) {
                eat(state, TOK_COLON);
                colons++;
                more = (peek(state) == TOK_LIT_STRING);
                while(more) {
                        struct triple *var;
                        struct triple *constraint;
                        char *str;
                        more = 0;
                        if (out > MAX_LHS) {
                                error(state, 0, "Maximum output count exceeded.");
                        }
                        constraint = string_constant(state);
                        str = constraint->u.blob;
                        if (str[0] != '=') {
                                error(state, 0, "Output constraint does not start with =");
                        }
                        constraint->u.blob = str + 1;
                        eat(state, TOK_LPAREN);
                        var = conditional_expr(state);
                        eat(state, TOK_RPAREN);

                        lvalue(state, var);
                        out_param[out].constraint = constraint;
                        out_param[out].expr       = var;
                        if (peek(state) == TOK_COMMA) {
                                eat(state, TOK_COMMA);
                                more = 1;
                        }
                        out++;
                }
        }
        /* Inputs */
        if ((colons == 1) && (peek(state) == TOK_COLON)) {
                eat(state, TOK_COLON);
                colons++;
                more = (peek(state) == TOK_LIT_STRING);
                while(more) {
                        struct triple *val;
                        struct triple *constraint;
                        char *str;
                        more = 0;
                        if (in > MAX_RHS) {
                                error(state, 0, "Maximum input count exceeded.");
                        }
                        constraint = string_constant(state);
                        str = constraint->u.blob;
                        if (digitp(str[0] && str[1] == '\0')) {
                                int val;
                                val = digval(str[0]);
                                if ((val < 0) || (val >= out)) {
                                        error(state, 0, "Invalid input constraint %d", val);
                                }
                        }
                        eat(state, TOK_LPAREN);
                        val = conditional_expr(state);
                        eat(state, TOK_RPAREN);

                        in_param[in].constraint = constraint;
                        in_param[in].expr       = val;
                        if (peek(state) == TOK_COMMA) {
                                eat(state, TOK_COMMA);
                                more = 1;
                        }
                        in++;
                }
        }

        /* Clobber */
        if ((colons == 2) && (peek(state) == TOK_COLON)) {
                eat(state, TOK_COLON);
                colons++;
                more = (peek(state) == TOK_LIT_STRING);
                while(more) {
                        struct triple *clobber;
                        more = 0;
                        if ((clobbers + out) > MAX_LHS) {
                                error(state, 0, "Maximum clobber limit exceeded.");
                        }
                        clobber = string_constant(state);

                        clob_param[clobbers].constraint = clobber;
                        if (peek(state) == TOK_COMMA) {
                                eat(state, TOK_COMMA);
                                more = 1;
                        }
                        clobbers++;
                }
        }
        eat(state, TOK_RPAREN);
        eat(state, TOK_SEMI);


        info = xcmalloc(sizeof(*info), "asm_info");
        info->str = asm_str->u.blob;
        free_triple(state, asm_str);

        def = new_triple(state, OP_ASM, &void_type, clobbers + out, in);
        def->u.ainfo = info;
        def->id |= flags;

        /* Find the register constraints */
        for(i = 0; i < out; i++) {
                struct triple *constraint;
                constraint = out_param[i].constraint;
                info->tmpl.lhs[i] = arch_reg_constraint(state, 
                        out_param[i].expr->type, constraint->u.blob);
                free_triple(state, constraint);
        }
        for(; i - out < clobbers; i++) {
                struct triple *constraint;
                constraint = clob_param[i - out].constraint;
                info->tmpl.lhs[i] = arch_reg_clobber(state, constraint->u.blob);
                free_triple(state, constraint);
        }
        for(i = 0; i < in; i++) {
                struct triple *constraint;
                const char *str;
                constraint = in_param[i].constraint;
                str = constraint->u.blob;
                if (digitp(str[0]) && str[1] == '\0') {
                        struct reg_info cinfo;
                        int val;
                        val = digval(str[0]);
                        cinfo.reg = info->tmpl.lhs[val].reg;
                        cinfo.regcm = arch_type_to_regcm(state, in_param[i].expr->type);
                        cinfo.regcm &= info->tmpl.lhs[val].regcm;
                        if (cinfo.reg == REG_UNSET) {
                                cinfo.reg = REG_VIRT0 + val;
                        }
                        if (cinfo.regcm == 0) {
                                error(state, 0, "No registers for %d", val);
                        }
                        info->tmpl.lhs[val] = cinfo;
                        info->tmpl.rhs[i]   = cinfo;
                                
                } else {
                        info->tmpl.rhs[i] = arch_reg_constraint(state, 
                                in_param[i].expr->type, str);
                }
                free_triple(state, constraint);
        }

        /* Now build the helper expressions */
        for(i = 0; i < in; i++) {
                RHS(def, i) = read_expr(state, in_param[i].expr);
        }
        flatten(state, first, def);
        for(i = 0; i < (out + clobbers); i++) {
                struct type *type;
                struct triple *piece;
                if (i < out) {
                        type = out_param[i].expr->type;
                } else {
                        size_t size = arch_reg_size(info->tmpl.lhs[i].reg);
                        if (size >= SIZEOF_LONG) {
                                type = &ulong_type;
                        } 
                        else if (size >= SIZEOF_INT) {
                                type = &uint_type;
                        }
                        else if (size >= SIZEOF_SHORT) {
                                type = &ushort_type;
                        }
                        else {
                                type = &uchar_type;
                        }
                }
                piece = triple(state, OP_PIECE, type, def, 0);
                piece->u.cval = i;
                LHS(def, i) = piece;
                flatten(state, first, piece);
        }
        /* And write the helpers to their destinations */
        for(i = 0; i < out; i++) {
                struct triple *piece;
                piece = LHS(def, i);
                flatten(state, first,
                        write_expr(state, out_param[i].expr, piece));
        }
}


static int isdecl(int tok)
{
        switch(tok) {
        case TOK_AUTO:
        case TOK_REGISTER:
        case TOK_STATIC:
        case TOK_EXTERN:
        case TOK_TYPEDEF:
        case TOK_CONST:
        case TOK_RESTRICT:
        case TOK_VOLATILE:
        case TOK_VOID:
        case TOK_CHAR:
        case TOK_SHORT:
        case TOK_INT:
        case TOK_LONG:
        case TOK_FLOAT:
        case TOK_DOUBLE:
        case TOK_SIGNED:
        case TOK_UNSIGNED:
        case TOK_STRUCT:
        case TOK_UNION:
        case TOK_ENUM:
        case TOK_TYPE_NAME: /* typedef name */
                return 1;
        default:
                return 0;
        }
}

static void compound_statement(struct compile_state *state, struct triple *first)
{
        eat(state, TOK_LBRACE);
        start_scope(state);

        /* statement-list opt */
        while (peek(state) != TOK_RBRACE) {
                statement(state, first);
        }
        end_scope(state);
        eat(state, TOK_RBRACE);
}

static void statement(struct compile_state *state, struct triple *first)
{
        int tok;
        tok = peek(state);
        if (tok == TOK_LBRACE) {
                compound_statement(state, first);
        }
        else if (tok == TOK_IF) {
                if_statement(state, first); 
        }
        else if (tok == TOK_FOR) {
                for_statement(state, first);
        }
        else if (tok == TOK_WHILE) {
                while_statement(state, first);
        }
        else if (tok == TOK_DO) {
                do_statement(state, first);
        }
        else if (tok == TOK_RETURN) {
                return_statement(state, first);
        }
        else if (tok == TOK_BREAK) {
                break_statement(state, first);
        }
        else if (tok == TOK_CONTINUE) {
                continue_statement(state, first);
        }
        else if (tok == TOK_GOTO) {
                goto_statement(state, first);
        }
        else if (tok == TOK_SWITCH) {
                switch_statement(state, first);
        }
        else if (tok == TOK_ASM) {
                asm_statement(state, first);
        }
        else if ((tok == TOK_IDENT) && (peek2(state) == TOK_COLON)) {
                labeled_statement(state, first); 
        }
        else if (tok == TOK_CASE) {
                case_statement(state, first);
        }
        else if (tok == TOK_DEFAULT) {
                default_statement(state, first);
        }
        else if (isdecl(tok)) {
                /* This handles C99 intermixing of statements and decls */
                decl(state, first);
        }
        else {
                expr_statement(state, first);
        }
}

static struct type *param_decl(struct compile_state *state)
{
        struct type *type;
        struct hash_entry *ident;
        /* Cheat so the declarator will know we are not global */
        start_scope(state); 
        ident = 0;
        type = decl_specifiers(state);
        type = declarator(state, type, &ident, 0);
        type->field_ident = ident;
        end_scope(state);
        return type;
}

static struct type *param_type_list(struct compile_state *state, struct type *type)
{
        struct type *ftype, **next;
        ftype = new_type(TYPE_FUNCTION | (type->type & STOR_MASK), type, param_decl(state));
        next = &ftype->right;
        ftype->elements = 1;
        while(peek(state) == TOK_COMMA) {
                eat(state, TOK_COMMA);
                if (peek(state) == TOK_DOTS) {
                        eat(state, TOK_DOTS);
                        error(state, 0, "variadic functions not supported");
                }
                else {
                        *next = new_type(TYPE_PRODUCT, *next, param_decl(state));
                        next = &((*next)->right);
                        ftype->elements++;
                }
        }
        return ftype;
}

static struct type *type_name(struct compile_state *state)
{
        struct type *type;
        type = specifier_qualifier_list(state);
        /* abstract-declarator (may consume no tokens) */
        type = declarator(state, type, 0, 0);
        return type;
}

static struct type *direct_declarator(
        struct compile_state *state, struct type *type, 
        struct hash_entry **pident, int need_ident)
{
        struct hash_entry *ident;
        struct type *outer;
        int op;
        outer = 0;
        arrays_complete(state, type);
        switch(peek(state)) {
        case TOK_IDENT:
                ident = eat(state, TOK_IDENT)->ident;
                if (!ident) {
                        error(state, 0, "Unexpected identifier found");
                }
                /* The name of what we are declaring */
                *pident = ident;
                break;
        case TOK_LPAREN:
                eat(state, TOK_LPAREN);
                outer = declarator(state, type, pident, need_ident);
                eat(state, TOK_RPAREN);
                break;
        default:
                if (need_ident) {
                        error(state, 0, "Identifier expected");
                }
                break;
        }
        do {
                op = 1;
                arrays_complete(state, type);
                switch(peek(state)) {
                case TOK_LPAREN:
                        eat(state, TOK_LPAREN);
                        type = param_type_list(state, type);
                        eat(state, TOK_RPAREN);
                        break;
                case TOK_LBRACKET:
                {
                        unsigned int qualifiers;
                        struct triple *value;
                        value = 0;
                        eat(state, TOK_LBRACKET);
                        if (peek(state) != TOK_RBRACKET) {
                                value = constant_expr(state);
                                integral(state, value);
                        }
                        eat(state, TOK_RBRACKET);

                        qualifiers = type->type & (QUAL_MASK | STOR_MASK);
                        type = new_type(TYPE_ARRAY | qualifiers, type, 0);
                        if (value) {
                                type->elements = value->u.cval;
                                free_triple(state, value);
                        } else {
                                type->elements = ELEMENT_COUNT_UNSPECIFIED;
                                op = 0;
                        }
                }
                        break;
                default:
                        op = 0;
                        break;
                }
        } while(op);
        if (outer) {
                struct type *inner;
                arrays_complete(state, type);
                FINISHME();
                for(inner = outer; inner->left; inner = inner->left)
                        ;
                inner->left = type;
                type = outer;
        }
        return type;
}

static struct type *declarator(
        struct compile_state *state, struct type *type, 
        struct hash_entry **pident, int need_ident)
{
        while(peek(state) == TOK_STAR) {
                eat(state, TOK_STAR);
                type = new_type(TYPE_POINTER | (type->type & STOR_MASK), type, 0);
        }
        type = direct_declarator(state, type, pident, need_ident);
        return type;
}

static struct type *typedef_name(
        struct compile_state *state, unsigned int specifiers)
{
        struct hash_entry *ident;
        struct type *type;
        ident = eat(state, TOK_TYPE_NAME)->ident;
        type = ident->sym_ident->type;
        specifiers |= type->type & QUAL_MASK;
        if ((specifiers & (STOR_MASK | QUAL_MASK)) != 
                (type->type & (STOR_MASK | QUAL_MASK))) {
                type = clone_type(specifiers, type);
        }
        return type;
}

static struct type *enum_specifier(
        struct compile_state *state, unsigned int spec)
{
        struct hash_entry *ident;
        ulong_t base;
        int tok;
        struct type *enum_type;
        enum_type = 0;
        ident = 0;
        eat(state, TOK_ENUM);
        tok = peek(state);
        if ((tok == TOK_IDENT) || (tok == TOK_ENUM_CONST) || (tok == TOK_TYPE_NAME)) {
                ident = eat(state, tok)->ident;
        }
        base = 0;
        if (!ident || (peek(state) == TOK_LBRACE)) {
                struct type **next;
                eat(state, TOK_LBRACE);
                enum_type = new_type(TYPE_ENUM | spec, 0, 0);
                enum_type->type_ident = ident;
                next = &enum_type->right;
                do {
                        struct hash_entry *eident;
                        struct triple *value;
                        struct type *entry;
                        eident = eat(state, TOK_IDENT)->ident;
                        if (eident->sym_ident) {
                                error(state, 0, "%s already declared", 
                                        eident->name);
                        }
                        eident->tok = TOK_ENUM_CONST;
                        if (peek(state) == TOK_EQ) {
                                struct triple *val;
                                eat(state, TOK_EQ);
                                val = constant_expr(state);
                                integral(state, val);
                                base = val->u.cval;
                        }
                        value = int_const(state, &int_type, base);
                        symbol(state, eident, &eident->sym_ident, value, &int_type);
                        entry = new_type(TYPE_LIST, 0, 0);
                        entry->field_ident = eident;
                        *next = entry;
                        next = &entry->right;
                        base += 1;
                        if (peek(state) == TOK_COMMA) {
                                eat(state, TOK_COMMA);
                        }
                } while(peek(state) != TOK_RBRACE);
                eat(state, TOK_RBRACE);
                if (ident) {
                        symbol(state, ident, &ident->sym_tag, 0, enum_type);
                }
        }
        if (ident && ident->sym_tag &&
                ident->sym_tag->type &&
                ((ident->sym_tag->type->type & TYPE_MASK) == TYPE_ENUM)) {
                enum_type = clone_type(spec, ident->sym_tag->type);
        }
        else if (ident && !enum_type) {
                error(state, 0, "enum %s undeclared", ident->name);
        }
        return enum_type;
}

static struct type *struct_declarator(
        struct compile_state *state, struct type *type, struct hash_entry **ident)
{
        if (peek(state) != TOK_COLON) {
                type = declarator(state, type, ident, 1);
        }
        if (peek(state) == TOK_COLON) {
                struct triple *value;
                eat(state, TOK_COLON);
                value = constant_expr(state);
                if (value->op != OP_INTCONST) {
                        error(state, 0, "Invalid constant expression");
                }
                if (value->u.cval > size_of(state, type)) {
                        error(state, 0, "bitfield larger than base type");
                }
                if (!TYPE_INTEGER(type->type) || ((type->type & TYPE_MASK) == TYPE_BITFIELD)) {
                        error(state, 0, "bitfield base not an integer type");
                }
                type = new_type(TYPE_BITFIELD, type, 0);
                type->elements = value->u.cval;
        }
        return type;
}

static struct type *struct_or_union_specifier(
        struct compile_state *state, unsigned int spec)
{
        struct type *struct_type;
        struct hash_entry *ident;
        unsigned int type_main;
        unsigned int type_join;
        int tok;
        struct_type = 0;
        ident = 0;
        switch(peek(state)) {
        case TOK_STRUCT:
                eat(state, TOK_STRUCT);
                type_main = TYPE_STRUCT;
                type_join = TYPE_PRODUCT;
                break;
        case TOK_UNION:
                eat(state, TOK_UNION);
                type_main = TYPE_UNION;
                type_join = TYPE_OVERLAP;
                break;
        default:
                eat(state, TOK_STRUCT);
                type_main = TYPE_STRUCT;
                type_join = TYPE_PRODUCT;
                break;
        }
        tok = peek(state);
        if ((tok == TOK_IDENT) || (tok == TOK_ENUM_CONST) || (tok == TOK_TYPE_NAME)) {
                ident = eat(state, tok)->ident;
        }
        if (!ident || (peek(state) == TOK_LBRACE)) {
                ulong_t elements;
                struct type **next;
                elements = 0;
                eat(state, TOK_LBRACE);
                next = &struct_type;
                do {
                        struct type *base_type;
                        int done;
                        base_type = specifier_qualifier_list(state);
                        do {
                                struct type *type;
                                struct hash_entry *fident;
                                done = 1;
                                type = struct_declarator(state, base_type, &fident);
                                elements++;
                                if (peek(state) == TOK_COMMA) {
                                        done = 0;
                                        eat(state, TOK_COMMA);
                                }
                                type = clone_type(0, type);
                                type->field_ident = fident;
                                if (*next) {
                                        *next = new_type(type_join, *next, type);
                                        next = &((*next)->right);
                                } else {
                                        *next = type;
                                }
                        } while(!done);
                        eat(state, TOK_SEMI);
                } while(peek(state) != TOK_RBRACE);
                eat(state, TOK_RBRACE);
                struct_type = new_type(type_main | spec, struct_type, 0);
                struct_type->type_ident = ident;
                struct_type->elements = elements;
                if (ident) {
                        symbol(state, ident, &ident->sym_tag, 0, struct_type);
                }
        }
        if (ident && ident->sym_tag && 
                ident->sym_tag->type && 
                ((ident->sym_tag->type->type & TYPE_MASK) == type_main)) {
                struct_type = clone_type(spec, ident->sym_tag->type);
        }
        else if (ident && !struct_type) {
                error(state, 0, "%s %s undeclared", 
                        (type_main == TYPE_STRUCT)?"struct" : "union",
                        ident->name);
        }
        return struct_type;
}

static unsigned int storage_class_specifier_opt(struct compile_state *state)
{
        unsigned int specifiers;
        switch(peek(state)) {
        case TOK_AUTO:
                eat(state, TOK_AUTO);
                specifiers = STOR_AUTO;
                break;
        case TOK_REGISTER:
                eat(state, TOK_REGISTER);
                specifiers = STOR_REGISTER;
                break;
        case TOK_STATIC:
                eat(state, TOK_STATIC);
                specifiers = STOR_STATIC;
                break;
        case TOK_EXTERN:
                eat(state, TOK_EXTERN);
                specifiers = STOR_EXTERN;
                break;
        case TOK_TYPEDEF:
                eat(state, TOK_TYPEDEF);
                specifiers = STOR_TYPEDEF;
                break;
        default:
                if (state->scope_depth <= GLOBAL_SCOPE_DEPTH) {
                        specifiers = STOR_LOCAL;
                }
                else {
                        specifiers = STOR_AUTO;
                }
        }
        return specifiers;
}

static unsigned int function_specifier_opt(struct compile_state *state)
{
        /* Ignore the inline keyword */
        unsigned int specifiers;
        specifiers = 0;
        switch(peek(state)) {
        case TOK_INLINE:
                eat(state, TOK_INLINE);
                specifiers = STOR_INLINE;
        }
        return specifiers;
}

static unsigned int attrib(struct compile_state *state, unsigned int attributes)
{
        int tok = peek(state);
        switch(tok) {
        case TOK_COMMA:
        case TOK_LPAREN:
                /* The empty attribute ignore it */
                break;
        case TOK_IDENT:
        case TOK_ENUM_CONST:
        case TOK_TYPE_NAME:
        {
                struct hash_entry *ident;
                ident = eat(state, TOK_IDENT)->ident;

                if (ident == state->i_noinline) {
                        if (attributes & ATTRIB_ALWAYS_INLINE) {
                                error(state, 0, "both always_inline and noinline attribtes");
                        }
                        attributes |= ATTRIB_NOINLINE;
                }
                else if (ident == state->i_always_inline) {
                        if (attributes & ATTRIB_NOINLINE) {
                                error(state, 0, "both noinline and always_inline attribtes");
                        }
                        attributes |= ATTRIB_ALWAYS_INLINE;
                }
                else {
                        error(state, 0, "Unknown attribute:%s", ident->name);
                }
                break;
        }
        default:
                error(state, 0, "Unexpected token: %s\n", tokens[tok]);
                break;
        }
        return attributes;
}

static unsigned int attribute_list(struct compile_state *state, unsigned type)
{
        type = attrib(state, type);
        while(peek(state) == TOK_COMMA) {
                eat(state, TOK_COMMA);
                type = attrib(state, type);
        }
        return type;
}

static unsigned int attributes_opt(struct compile_state *state, unsigned type)
{
        if (peek(state) == TOK_ATTRIBUTE) {
                eat(state, TOK_ATTRIBUTE);
                eat(state, TOK_LPAREN);
                eat(state, TOK_LPAREN);
                type = attribute_list(state, type);
                eat(state, TOK_RPAREN);
                eat(state, TOK_RPAREN);
        }
        return type;
}

static unsigned int type_qualifiers(struct compile_state *state)
{
        unsigned int specifiers;
        int done;
        done = 0;
        specifiers = QUAL_NONE;
        do {
                switch(peek(state)) {
                case TOK_CONST:
                        eat(state, TOK_CONST);
                        specifiers |= QUAL_CONST;
                        break;
                case TOK_VOLATILE:
                        eat(state, TOK_VOLATILE);
                        specifiers |= QUAL_VOLATILE;
                        break;
                case TOK_RESTRICT:
                        eat(state, TOK_RESTRICT);
                        specifiers |= QUAL_RESTRICT;
                        break;
                default:
                        done = 1;
                        break;
                }
        } while(!done);
        return specifiers;
}

static struct type *type_specifier(
        struct compile_state *state, unsigned int spec)
{
        struct type *type;
        int tok;
        type = 0;
        switch((tok = peek(state))) {
        case TOK_VOID:
                eat(state, TOK_VOID);
                type = new_type(TYPE_VOID | spec, 0, 0);
                break;
        case TOK_CHAR:
                eat(state, TOK_CHAR);
                type = new_type(TYPE_CHAR | spec, 0, 0);
                break;
        case TOK_SHORT:
                eat(state, TOK_SHORT);
                if (peek(state) == TOK_INT) {
                        eat(state, TOK_INT);
                }
                type = new_type(TYPE_SHORT | spec, 0, 0);
                break;
        case TOK_INT:
                eat(state, TOK_INT);
                type = new_type(TYPE_INT | spec, 0, 0);
                break;
        case TOK_LONG:
                eat(state, TOK_LONG);
                switch(peek(state)) {
                case TOK_LONG:
                        eat(state, TOK_LONG);
                        error(state, 0, "long long not supported");
                        break;
                case TOK_DOUBLE:
                        eat(state, TOK_DOUBLE);
                        error(state, 0, "long double not supported");
                        break;
                case TOK_INT:
                        eat(state, TOK_INT);
                        type = new_type(TYPE_LONG | spec, 0, 0);
                        break;
                default:
                        type = new_type(TYPE_LONG | spec, 0, 0);
                        break;
                }
                break;
        case TOK_FLOAT:
                eat(state, TOK_FLOAT);
                error(state, 0, "type float not supported");
                break;
        case TOK_DOUBLE:
                eat(state, TOK_DOUBLE);
                error(state, 0, "type double not supported");
                break;
        case TOK_SIGNED:
                eat(state, TOK_SIGNED);
                switch(peek(state)) {
                case TOK_LONG:
                        eat(state, TOK_LONG);
                        switch(peek(state)) {
                        case TOK_LONG:
                                eat(state, TOK_LONG);
                                error(state, 0, "type long long not supported");
                                break;
                        case TOK_INT:
                                eat(state, TOK_INT);
                                type = new_type(TYPE_LONG | spec, 0, 0);
                                break;
                        default:
                                type = new_type(TYPE_LONG | spec, 0, 0);
                                break;
                        }
                        break;
                case TOK_INT:
                        eat(state, TOK_INT);
                        type = new_type(TYPE_INT | spec, 0, 0);
                        break;
                case TOK_SHORT:
                        eat(state, TOK_SHORT);
                        type = new_type(TYPE_SHORT | spec, 0, 0);
                        break;
                case TOK_CHAR:
                        eat(state, TOK_CHAR);
                        type = new_type(TYPE_CHAR | spec, 0, 0);
                        break;
                default:
                        type = new_type(TYPE_INT | spec, 0, 0);
                        break;
                }
                break;
        case TOK_UNSIGNED:
                eat(state, TOK_UNSIGNED);
                switch(peek(state)) {
                case TOK_LONG:
                        eat(state, TOK_LONG);
                        switch(peek(state)) {
                        case TOK_LONG:
                                eat(state, TOK_LONG);
                                error(state, 0, "unsigned long long not supported");
                                break;
                        case TOK_INT:
                                eat(state, TOK_INT);
                                type = new_type(TYPE_ULONG | spec, 0, 0);
                                break;
                        default:
                                type = new_type(TYPE_ULONG | spec, 0, 0);
                                break;
                        }
                        break;
                case TOK_INT:
                        eat(state, TOK_INT);
                        type = new_type(TYPE_UINT | spec, 0, 0);
                        break;
                case TOK_SHORT:
                        eat(state, TOK_SHORT);
                        type = new_type(TYPE_USHORT | spec, 0, 0);
                        break;
                case TOK_CHAR:
                        eat(state, TOK_CHAR);
                        type = new_type(TYPE_UCHAR | spec, 0, 0);
                        break;
                default:
                        type = new_type(TYPE_UINT | spec, 0, 0);
                        break;
                }
                break;
                /* struct or union specifier */
        case TOK_STRUCT:
        case TOK_UNION:
                type = struct_or_union_specifier(state, spec);
                break;
                /* enum-spefifier */
        case TOK_ENUM:
                type = enum_specifier(state, spec);
                break;
                /* typedef name */
        case TOK_TYPE_NAME:
                type = typedef_name(state, spec);
                break;
        default:
                error(state, 0, "bad type specifier %s", 
                        tokens[tok]);
                break;
        }
        return type;
}

static int istype(int tok)
{
        switch(tok) {
        case TOK_CONST:
        case TOK_RESTRICT:
        case TOK_VOLATILE:
        case TOK_VOID:
        case TOK_CHAR:
        case TOK_SHORT:
        case TOK_INT:
        case TOK_LONG:
        case TOK_FLOAT:
        case TOK_DOUBLE:
        case TOK_SIGNED:
        case TOK_UNSIGNED:
        case TOK_STRUCT:
        case TOK_UNION:
        case TOK_ENUM:
        case TOK_TYPE_NAME:
                return 1;
        default:
                return 0;
        }
}


static struct type *specifier_qualifier_list(struct compile_state *state)
{
        struct type *type;
        unsigned int specifiers = 0;

        /* type qualifiers */
        specifiers |= type_qualifiers(state);

        /* type specifier */
        type = type_specifier(state, specifiers);

        return type;
}

static int isdecl_specifier(int tok)
{
        switch(tok) {
                /* storage class specifier */
        case TOK_AUTO:
        case TOK_REGISTER:
        case TOK_STATIC:
        case TOK_EXTERN:
        case TOK_TYPEDEF:
                /* type qualifier */
        case TOK_CONST:
        case TOK_RESTRICT:
        case TOK_VOLATILE:
                /* type specifiers */
        case TOK_VOID:
        case TOK_CHAR:
        case TOK_SHORT:
        case TOK_INT:
        case TOK_LONG:
        case TOK_FLOAT:
        case TOK_DOUBLE:
        case TOK_SIGNED:
        case TOK_UNSIGNED:
                /* struct or union specifier */
        case TOK_STRUCT:
        case TOK_UNION:
                /* enum-spefifier */
        case TOK_ENUM:
                /* typedef name */
        case TOK_TYPE_NAME:
                /* function specifiers */
        case TOK_INLINE:
                return 1;
        default:
                return 0;
        }
}

static struct type *decl_specifiers(struct compile_state *state)
{
        struct type *type;
        unsigned int specifiers;
        /* I am overly restrictive in the arragement of specifiers supported.
         * C is overly flexible in this department it makes interpreting
         * the parse tree difficult.
         */
        specifiers = 0;

        /* storage class specifier */
        specifiers |= storage_class_specifier_opt(state);

        /* function-specifier */
        specifiers |= function_specifier_opt(state);

        /* attributes */
        specifiers |= attributes_opt(state, 0);

        /* type qualifier */
        specifiers |= type_qualifiers(state);

        /* type specifier */
        type = type_specifier(state, specifiers);
        return type;
}

struct field_info {
        struct type *type;
        size_t offset;
};

static struct field_info designator(struct compile_state *state, struct type *type)
{
        int tok;
        struct field_info info;
        info.offset = ~0U;
        info.type = 0;
        do {
                switch(peek(state)) {
                case TOK_LBRACKET:
                {
                        struct triple *value;
                        if ((type->type & TYPE_MASK) != TYPE_ARRAY) {
                                error(state, 0, "Array designator not in array initializer");
                        }
                        eat(state, TOK_LBRACKET);
                        value = constant_expr(state);
                        eat(state, TOK_RBRACKET);

                        info.type = type->left;
                        info.offset = value->u.cval * size_of(state, info.type);
                        break;
                }
                case TOK_DOT:
                {
                        struct hash_entry *field;
                        if (((type->type & TYPE_MASK) != TYPE_STRUCT) &&
                                ((type->type & TYPE_MASK) != TYPE_UNION))
                        {
                                error(state, 0, "Struct designator not in struct initializer");
                        }
                        eat(state, TOK_DOT);
                        field = eat(state, TOK_IDENT)->ident;
                        info.offset = field_offset(state, type, field);
                        info.type   = field_type(state, type, field);
                        break;
                }
                default:
                        error(state, 0, "Invalid designator");
                }
                tok = peek(state);
        } while((tok == TOK_LBRACKET) || (tok == TOK_DOT));
        eat(state, TOK_EQ);
        return info;
}

static struct triple *initializer(
        struct compile_state *state, struct type *type)
{
        struct triple *result;
#warning "FIXME more consistent initializer handling (where should eval_const_expr go?"
        if (peek(state) != TOK_LBRACE) {
                result = assignment_expr(state);
                if (((type->type & TYPE_MASK) == TYPE_ARRAY) &&
                        (type->elements == ELEMENT_COUNT_UNSPECIFIED) &&
                        ((result->type->type & TYPE_MASK) == TYPE_ARRAY) &&
                        (result->type->elements != ELEMENT_COUNT_UNSPECIFIED) &&
                        (equiv_types(type->left, result->type->left))) {
                        type->elements = result->type->elements;
                }
                if (is_lvalue(state, result) && 
                        ((result->type->type & TYPE_MASK) == TYPE_ARRAY) &&
                        (type->type & TYPE_MASK) != TYPE_ARRAY)
                {
                        result = lvalue_conversion(state, result);
                }
                if (!is_init_compatible(state, type, result->type)) {
                        error(state, 0, "Incompatible types in initializer");
                }
                if (!equiv_types(type, result->type)) {
                        result = mk_cast_expr(state, type, result);
                }
        }
        else {
                int comma;
                size_t max_offset;
                struct field_info info;
                void *buf;
                if (((type->type & TYPE_MASK) != TYPE_ARRAY) &&
                        ((type->type & TYPE_MASK) != TYPE_STRUCT)) {
                        internal_error(state, 0, "unknown initializer type");
                }
                info.offset = 0;
                info.type = type->left;
                if ((type->type & TYPE_MASK) == TYPE_STRUCT) {
                        info.type = next_field(state, type, 0);
                }
                if (type->elements == ELEMENT_COUNT_UNSPECIFIED) {
                        max_offset = 0;
                } else {
                        max_offset = size_of(state, type);
                }
                buf = xcmalloc(bits_to_bytes(max_offset), "initializer");
                eat(state, TOK_LBRACE);
                do {
                        struct triple *value;
                        struct type *value_type;
                        size_t value_size;
                        void *dest;
                        int tok;
                        comma = 0;
                        tok = peek(state);
                        if ((tok == TOK_LBRACKET) || (tok == TOK_DOT)) {
                                info = designator(state, type);
                        }
                        if ((type->elements != ELEMENT_COUNT_UNSPECIFIED) &&
                                (info.offset >= max_offset)) {
                                error(state, 0, "element beyond bounds");
                        }
                        value_type = info.type;
                        value = eval_const_expr(state, initializer(state, value_type));
                        value_size = size_of(state, value_type);
                        if (((type->type & TYPE_MASK) == TYPE_ARRAY) &&
                                (type->elements == ELEMENT_COUNT_UNSPECIFIED) &&
                                (max_offset <= info.offset)) {
                                void *old_buf;
                                size_t old_size;
                                old_buf = buf;
                                old_size = max_offset;
                                max_offset = info.offset + value_size;
                                buf = xmalloc(bits_to_bytes(max_offset), "initializer");
                                memcpy(buf, old_buf, bits_to_bytes(old_size));
                                xfree(old_buf);
                        }
                        dest = ((char *)buf) + bits_to_bytes(info.offset);
#if DEBUG_INITIALIZER
                        fprintf(state->errout, "dest = buf + %d max_offset: %d value_size: %d op: %d\n", 
                                dest - buf,
                                bits_to_bytes(max_offset),
                                bits_to_bytes(value_size),
                                value->op);
#endif
                        if (value->op == OP_BLOBCONST) {
                                memcpy(dest, value->u.blob, bits_to_bytes(value_size));
                        }
                        else if ((value->op == OP_INTCONST) && (value_size == SIZEOF_I8)) {
#if DEBUG_INITIALIZER
                                fprintf(state->errout, "byte: %02x\n", value->u.cval & 0xff);
#endif
                                *((uint8_t *)dest) = value->u.cval & 0xff;
                        }
                        else if ((value->op == OP_INTCONST) && (value_size == SIZEOF_I16)) {
                                *((uint16_t *)dest) = value->u.cval & 0xffff;
                        }
                        else if ((value->op == OP_INTCONST) && (value_size == SIZEOF_I32)) {
                                *((uint32_t *)dest) = value->u.cval & 0xffffffff;
                        }
                        else {
                                internal_error(state, 0, "unhandled constant initializer");
                        }
                        free_triple(state, value);
                        if (peek(state) == TOK_COMMA) {
                                eat(state, TOK_COMMA);
                                comma = 1;
                        }
                        info.offset += value_size;
                        if ((type->type & TYPE_MASK) == TYPE_STRUCT) {
                                info.type = next_field(state, type, info.type);
                                info.offset = field_offset(state, type, 
                                        info.type->field_ident);
                        }
                } while(comma && (peek(state) != TOK_RBRACE));
                if ((type->elements == ELEMENT_COUNT_UNSPECIFIED) &&
                        ((type->type & TYPE_MASK) == TYPE_ARRAY)) {
                        type->elements = max_offset / size_of(state, type->left);
                }
                eat(state, TOK_RBRACE);
                result = triple(state, OP_BLOBCONST, type, 0, 0);
                result->u.blob = buf;
        }
        return result;
}

static void resolve_branches(struct compile_state *state, struct triple *first)
{
        /* Make a second pass and finish anything outstanding
         * with respect to branches.  The only outstanding item
         * is to see if there are goto to labels that have not
         * been defined and to error about them.
         */
        int i;
        struct triple *ins;
        /* Also error on branches that do not use their targets */
        ins = first;
        do {
                if (!triple_is_ret(state, ins)) {
                        struct triple **expr ;
                        struct triple_set *set;
                        expr = triple_targ(state, ins, 0);
                        for(; expr; expr = triple_targ(state, ins, expr)) {
                                struct triple *targ;
                                targ = *expr;
                                for(set = targ?targ->use:0; set; set = set->next) {
                                        if (set->member == ins) {
                                                break;
                                        }
                                }
                                if (!set) {
                                        internal_error(state, ins, "targ not used");
                                }
                        }
                }
                ins = ins->next;
        } while(ins != first);
        /* See if there are goto to labels that have not been defined */
        for(i = 0; i < HASH_TABLE_SIZE; i++) {
                struct hash_entry *entry;
                for(entry = state->hash_table[i]; entry; entry = entry->next) {
                        struct triple *ins;
                        if (!entry->sym_label) {
                                continue;
                        }
                        ins = entry->sym_label->def;
                        if (!(ins->id & TRIPLE_FLAG_FLATTENED)) {
                                error(state, ins, "label `%s' used but not defined",
                                        entry->name);
                        }
                }
        }
}

static struct triple *function_definition(
        struct compile_state *state, struct type *type)
{
        struct triple *def, *tmp, *first, *end, *retvar, *result, *ret;
        struct triple *fname;
        struct type *fname_type;
        struct hash_entry *ident;
        struct type *param, *crtype, *ctype;
        int i;
        if ((type->type &TYPE_MASK) != TYPE_FUNCTION) {
                error(state, 0, "Invalid function header");
        }

        /* Verify the function type */
        if (((type->right->type & TYPE_MASK) != TYPE_VOID)  &&
                ((type->right->type & TYPE_MASK) != TYPE_PRODUCT) &&
                (type->right->field_ident == 0)) {
                error(state, 0, "Invalid function parameters");
        }
        param = type->right;
        i = 0;
        while((param->type & TYPE_MASK) == TYPE_PRODUCT) {
                i++;
                if (!param->left->field_ident) {
                        error(state, 0, "No identifier for parameter %d\n", i);
                }
                param = param->right;
        }
        i++;
        if (((param->type & TYPE_MASK) != TYPE_VOID) && !param->field_ident) {
                error(state, 0, "No identifier for paramter %d\n", i);
        }
        
        /* Get a list of statements for this function. */
        def = triple(state, OP_LIST, type, 0, 0);

        /* Start a new scope for the passed parameters */
        start_scope(state);

        /* Put a label at the very start of a function */
        first = label(state);
        RHS(def, 0) = first;

        /* Put a label at the very end of a function */
        end = label(state);
        flatten(state, first, end);
        /* Remember where return goes */
        ident = state->i_return;
        symbol(state, ident, &ident->sym_ident, end, end->type);

        /* Get the initial closure type */
        ctype = new_type(TYPE_JOIN, &void_type, 0);
        ctype->elements = 1;

        /* Add a variable for the return value */
        crtype = new_type(TYPE_TUPLE, 
                /* Remove all type qualifiers from the return type */
                new_type(TYPE_PRODUCT, ctype, clone_type(0, type->left)), 0);
        crtype->elements = 2;
        result = flatten(state, end, variable(state, crtype));

        /* Allocate a variable for the return address */
        retvar = flatten(state, end, variable(state, &void_ptr_type));

        /* Add in the return instruction */
        ret = triple(state, OP_RET, &void_type, read_expr(state, retvar), 0);
        ret = flatten(state, first, ret);

        /* Walk through the parameters and create symbol table entries
         * for them.
         */
        param = type->right;
        while((param->type & TYPE_MASK) == TYPE_PRODUCT) {
                ident = param->left->field_ident;
                tmp = variable(state, param->left);
                var_symbol(state, ident, tmp);
                flatten(state, end, tmp);
                param = param->right;
        }
        if ((param->type & TYPE_MASK) != TYPE_VOID) {
                /* And don't forget the last parameter */
                ident = param->field_ident;
                tmp = variable(state, param);
                symbol(state, ident, &ident->sym_ident, tmp, tmp->type);
                flatten(state, end, tmp);
        }

        /* Add the declaration static const char __func__ [] = "func-name"  */
        fname_type = new_type(TYPE_ARRAY, 
                clone_type(QUAL_CONST | STOR_STATIC, &char_type), 0);
        fname_type->type |= QUAL_CONST | STOR_STATIC;
        fname_type->elements = strlen(state->function) + 1;

        fname = triple(state, OP_BLOBCONST, fname_type, 0, 0);
        fname->u.blob = (void *)state->function;
        fname = flatten(state, end, fname);

        ident = state->i___func__;
        symbol(state, ident, &ident->sym_ident, fname, fname_type);

        /* Remember which function I am compiling.
         * Also assume the last defined function is the main function.
         */
        state->main_function = def;

        /* Now get the actual function definition */
        compound_statement(state, end);

        /* Finish anything unfinished with branches */
        resolve_branches(state, first);

        /* Remove the parameter scope */
        end_scope(state);


        /* Remember I have defined a function */
        if (!state->functions) {
                state->functions = def;
        } else {
                insert_triple(state, state->functions, def);
        }
        if (state->compiler->debug & DEBUG_INLINE) {
                FILE *fp = state->dbgout;
                fprintf(fp, "\n");
                loc(fp, state, 0);
                fprintf(fp, "\n__________ %s _________\n", __FUNCTION__);
                display_func(state, fp, def);
                fprintf(fp, "__________ %s _________ done\n\n", __FUNCTION__);
        }

        return def;
}

static struct triple *do_decl(struct compile_state *state, 
        struct type *type, struct hash_entry *ident)
{
        struct triple *def;
        def = 0;
        /* Clean up the storage types used */
        switch (type->type & STOR_MASK) {
        case STOR_AUTO:
        case STOR_STATIC:
                /* These are the good types I am aiming for */
                break;
        case STOR_REGISTER:
                type->type &= ~STOR_MASK;
                type->type |= STOR_AUTO;
                break;
        case STOR_LOCAL:
        case STOR_EXTERN:
                type->type &= ~STOR_MASK;
                type->type |= STOR_STATIC;
                break;
        case STOR_TYPEDEF:
                if (!ident) {
                        error(state, 0, "typedef without name");
                }
                symbol(state, ident, &ident->sym_ident, 0, type);
                ident->tok = TOK_TYPE_NAME;
                return 0;
                break;
        default:
                internal_error(state, 0, "Undefined storage class");
        }
        if ((type->type & TYPE_MASK) == TYPE_FUNCTION) {
                error(state, 0, "Function prototypes not supported");
        }
        if (ident && 
                ((type->type & STOR_MASK) == STOR_STATIC) &&
                ((type->type & QUAL_CONST) == 0)) {
                error(state, 0, "non const static variables not supported");
        }
        if (ident) {
                def = variable(state, type);
                var_symbol(state, ident, def);
        }
        return def;
}

static void decl(struct compile_state *state, struct triple *first)
{
        struct type *base_type, *type;
        struct hash_entry *ident;
        struct triple *def;
        int global;
        global = (state->scope_depth <= GLOBAL_SCOPE_DEPTH);
        base_type = decl_specifiers(state);
        ident = 0;
        type = declarator(state, base_type, &ident, 0);
        type->type = attributes_opt(state, type->type);
        if (global && ident && (peek(state) == TOK_LBRACE)) {
                /* function */
                type->type_ident = ident;
                state->function = ident->name;
                def = function_definition(state, type);
                symbol(state, ident, &ident->sym_ident, def, type);
                state->function = 0;
        }
        else {
                int done;
                flatten(state, first, do_decl(state, type, ident));
                /* type or variable definition */
                do {
                        done = 1;
                        if (peek(state) == TOK_EQ) {
                                if (!ident) {
                                        error(state, 0, "cannot assign to a type");
                                }
                                eat(state, TOK_EQ);
                                flatten(state, first,
                                        init_expr(state, 
                                                ident->sym_ident->def, 
                                                initializer(state, type)));
                        }
                        arrays_complete(state, type);
                        if (peek(state) == TOK_COMMA) {
                                eat(state, TOK_COMMA);
                                ident = 0;
                                type = declarator(state, base_type, &ident, 0);
                                flatten(state, first, do_decl(state, type, ident));
                                done = 0;
                        }
                } while(!done);
                eat(state, TOK_SEMI);
        }
}

static void decls(struct compile_state *state)
{
        struct triple *list;
        int tok;
        list = label(state);
        while(1) {
                tok = peek(state);
                if (tok == TOK_EOF) {
                        return;
                }
                if (tok == TOK_SPACE) {
                        eat(state, TOK_SPACE);
                }
                decl(state, list);
                if (list->next != list) {
                        error(state, 0, "global variables not supported");
                }
        }
}

/* 
 * Function inlining
 */
struct triple_reg_set {
        struct triple_reg_set *next;
        struct triple *member;
        struct triple *new;
};
struct reg_block {
        struct block *block;
        struct triple_reg_set *in;
        struct triple_reg_set *out;
        int vertex;
};
static void setup_basic_blocks(struct compile_state *, struct basic_blocks *bb);
static void analyze_basic_blocks(struct compile_state *state, struct basic_blocks *bb);
static void free_basic_blocks(struct compile_state *, struct basic_blocks *bb);
static int tdominates(struct compile_state *state, struct triple *dom, struct triple *sub);
static void walk_blocks(struct compile_state *state, struct basic_blocks *bb,
        void (*cb)(struct compile_state *state, struct block *block, void *arg),
        void *arg);
static void print_block(
        struct compile_state *state, struct block *block, void *arg);
static int do_triple_set(struct triple_reg_set **head, 
        struct triple *member, struct triple *new_member);
static void do_triple_unset(struct triple_reg_set **head, struct triple *member);
static struct reg_block *compute_variable_lifetimes(
        struct compile_state *state, struct basic_blocks *bb);
static void free_variable_lifetimes(struct compile_state *state, 
        struct basic_blocks *bb, struct reg_block *blocks);
static void print_live_variables(struct compile_state *state, 
        struct basic_blocks *bb, struct reg_block *rb, FILE *fp);


static struct triple *call(struct compile_state *state,
        struct triple *retvar, struct triple *ret_addr, 
        struct triple *targ, struct triple *ret)
{
        struct triple *call;

        if (!retvar || !is_lvalue(state, retvar)) {
                internal_error(state, 0, "writing to a non lvalue?");
        }
        write_compatible(state, retvar->type, &void_ptr_type);

        call = new_triple(state, OP_CALL, &void_type, 1, 0);
        TARG(call, 0) = targ;
        MISC(call, 0) = ret;
        if (!targ || (targ->op != OP_LABEL)) {
                internal_error(state, 0, "call not to a label");
        }
        if (!ret || (ret->op != OP_RET)) {
                internal_error(state, 0, "call not matched with return");
        }
        return call;
}

static void walk_functions(struct compile_state *state,
        void (*cb)(struct compile_state *state, struct triple *func, void *arg),
        void *arg)
{
        struct triple *func, *first;
        func = first = state->functions;
        do {
                cb(state, func, arg);
                func = func->next;
        } while(func != first);
}

static void reverse_walk_functions(struct compile_state *state,
        void (*cb)(struct compile_state *state, struct triple *func, void *arg),
        void *arg)
{
        struct triple *func, *first;
        func = first = state->functions;
        do {
                func = func->prev;
                cb(state, func, arg);
        } while(func != first);
}


static void mark_live(struct compile_state *state, struct triple *func, void *arg)
{
        struct triple *ptr, *first;
        if (func->u.cval == 0) {
                return;
        }
        ptr = first = RHS(func, 0);
        do {
                if (ptr->op == OP_FCALL) {
                        struct triple *called_func;
                        called_func = MISC(ptr, 0);
                        /* Mark the called function as used */
                        if (!(func->id & TRIPLE_FLAG_FLATTENED)) {
                                called_func->u.cval++;
                        }
                        /* Remove the called function from the list */
                        called_func->prev->next = called_func->next;
                        called_func->next->prev = called_func->prev;

                        /* Place the called function before me on the list */
                        called_func->next       = func;
                        called_func->prev       = func->prev;
                        called_func->prev->next = called_func;
                        called_func->next->prev = called_func;
                }
                ptr = ptr->next;
        } while(ptr != first);
        func->id |= TRIPLE_FLAG_FLATTENED;
}

static void mark_live_functions(struct compile_state *state)
{
        /* Ensure state->main_function is the last function in 
         * the list of functions.
         */
        if ((state->main_function->next != state->functions) ||
                (state->functions->prev != state->main_function)) {
                internal_error(state, 0, 
                        "state->main_function is not at the end of the function list ");
        }
        state->main_function->u.cval = 1;
        reverse_walk_functions(state, mark_live, 0);
}

static int local_triple(struct compile_state *state, 
        struct triple *func, struct triple *ins)
{
        int local = (ins->id & TRIPLE_FLAG_LOCAL);
#if 0
        if (!local) {
                FILE *fp = state->errout;
                fprintf(fp, "global: ");
                display_triple(fp, ins);
        }
#endif
        return local;
}

struct triple *copy_func(struct compile_state *state, struct triple *ofunc, 
        struct occurance *base_occurance)
{
        struct triple *nfunc;
        struct triple *nfirst, *ofirst;
        struct triple *new, *old;

        if (state->compiler->debug & DEBUG_INLINE) {
                FILE *fp = state->dbgout;
                fprintf(fp, "\n");
                loc(fp, state, 0);
                fprintf(fp, "\n__________ %s _________\n", __FUNCTION__);
                display_func(state, fp, ofunc);
                fprintf(fp, "__________ %s _________ done\n\n", __FUNCTION__);
        }

        /* Make a new copy of the old function */
        nfunc = triple(state, OP_LIST, ofunc->type, 0, 0);
        nfirst = 0;
        ofirst = old = RHS(ofunc, 0);
        do {
                struct triple *new;
                struct occurance *occurance;
                int old_lhs, old_rhs;
                old_lhs = old->lhs;
                old_rhs = old->rhs;
                occurance = inline_occurance(state, base_occurance, old->occurance);
                if (ofunc->u.cval && (old->op == OP_FCALL)) {
                        MISC(old, 0)->u.cval += 1;
                }
                new = alloc_triple(state, old->op, old->type, old_lhs, old_rhs,
                        occurance);
                if (!triple_stores_block(state, new)) {
                        memcpy(&new->u, &old->u, sizeof(new->u));
                }
                if (!nfirst) {
                        RHS(nfunc, 0) = nfirst = new;
                }
                else {
                        insert_triple(state, nfirst, new);
                }
                new->id |= TRIPLE_FLAG_FLATTENED;
                new->id |= old->id & TRIPLE_FLAG_COPY;
                
                /* During the copy remember new as user of old */
                use_triple(old, new);

                /* Remember which instructions are local */
                old->id |= TRIPLE_FLAG_LOCAL;
                old = old->next;
        } while(old != ofirst);

        /* Make a second pass to fix up any unresolved references */
        old = ofirst;
        new = nfirst;
        do {
                struct triple **oexpr, **nexpr;
                int count, i;
                /* Lookup where the copy is, to join pointers */
                count = TRIPLE_SIZE(old);
                for(i = 0; i < count; i++) {
                        oexpr = &old->param[i];
                        nexpr = &new->param[i];
                        if (*oexpr && !*nexpr) {
                                if (!local_triple(state, ofunc, *oexpr)) {
                                        *nexpr = *oexpr;
                                }
                                else if ((*oexpr)->use) {
                                        *nexpr = (*oexpr)->use->member;
                                }
                                if (*nexpr == old) {
                                        internal_error(state, 0, "new == old?");
                                }
                                use_triple(*nexpr, new);
                        }
                        if (!*nexpr && *oexpr) {
                                internal_error(state, 0, "Could not copy %d", i);
                        }
                }
                old = old->next;
                new = new->next;
        } while((old != ofirst) && (new != nfirst));
        
        /* Make a third pass to cleanup the extra useses */
        old = ofirst;
        new = nfirst;
        do {
                unuse_triple(old, new);
                /* Forget which instructions are local */
                old->id &= ~TRIPLE_FLAG_LOCAL;
                old = old->next;
                new = new->next;
        } while ((old != ofirst) && (new != nfirst));
        return nfunc;
}

static void expand_inline_call(
        struct compile_state *state, struct triple *me, struct triple *fcall)
{
        /* Inline the function call */
        struct type *ptype;
        struct triple *ofunc, *nfunc, *nfirst, *result, *retvar, *ins;
        struct triple *end, *nend;
        int pvals, i;

        /* Find the triples */
        ofunc = MISC(fcall, 0);
        if (ofunc->op != OP_LIST) {
                internal_error(state, 0, "improper function");
        }
        nfunc = copy_func(state, ofunc, fcall->occurance);
        /* Prepend the parameter reading into the new function list */
        ptype = nfunc->type->right;
        pvals = fcall->rhs;
        for(i = 0; i < pvals; i++) {
                struct type *atype;
                struct triple *arg, *param;
                atype = ptype;
                if ((ptype->type & TYPE_MASK) == TYPE_PRODUCT) {
                        atype = ptype->left;
                }
                param = farg(state, nfunc, i);
                if ((param->type->type & TYPE_MASK) != (atype->type & TYPE_MASK)) {
                        internal_error(state, fcall, "param %d type mismatch", i);
                }
                arg = RHS(fcall, i);
                flatten(state, fcall, write_expr(state, param, arg));
                ptype = ptype->right;
        }
        result = 0;
        if ((nfunc->type->left->type & TYPE_MASK) != TYPE_VOID) {
                result = read_expr(state, 
                        deref_index(state, fresult(state, nfunc), 1));
        }
        if (state->compiler->debug & DEBUG_INLINE) {
                FILE *fp = state->dbgout;
                fprintf(fp, "\n");
                loc(fp, state, 0);
                fprintf(fp, "\n__________ %s _________\n", __FUNCTION__);
                display_func(state, fp, nfunc);
                fprintf(fp, "__________ %s _________ done\n\n", __FUNCTION__);
        }

        /* 
         * Get rid of the extra triples 
         */
        /* Remove the read of the return address */
        ins = RHS(nfunc, 0)->prev->prev;
        if ((ins->op != OP_READ) || (RHS(ins, 0) != fretaddr(state, nfunc))) {
                internal_error(state, ins, "Not return addres read?");
        }
        release_triple(state, ins);
        /* Remove the return instruction */
        ins = RHS(nfunc, 0)->prev;
        if (ins->op != OP_RET) {
                internal_error(state, ins, "Not return?");
        }
        release_triple(state, ins);
        /* Remove the retaddres variable */
        retvar = fretaddr(state, nfunc);
        if ((retvar->lhs != 1) || 
                (retvar->op != OP_ADECL) ||
                (retvar->next->op != OP_PIECE) ||
                (MISC(retvar->next, 0) != retvar)) {
                internal_error(state, retvar, "Not the return address?");
        }
        release_triple(state, retvar->next);
        release_triple(state, retvar);

        /* Remove the label at the start of the function */
        ins = RHS(nfunc, 0);
        if (ins->op != OP_LABEL) {
                internal_error(state, ins, "Not label?");
        }
        nfirst = ins->next;
        free_triple(state, ins);
        /* Release the new function header */
        RHS(nfunc, 0) = 0;
        free_triple(state, nfunc);

        /* Append the new function list onto the return list */
        end = fcall->prev;
        nend = nfirst->prev;
        end->next    = nfirst;
        nfirst->prev = end;
        nend->next   = fcall;
        fcall->prev  = nend;

        /* Now the result reading code */
        if (result) {
                result = flatten(state, fcall, result);
                propogate_use(state, fcall, result);
        }

        /* Release the original fcall instruction */
        release_triple(state, fcall);

        return;
}

/*
 *
 * Type of the result variable.
 * 
 *                                     result
 *                                        |
 *                             +----------+------------+
 *                             |                       |
 *                     union of closures         result_type
 *                             |
 *          +------------------+---------------+
 *          |                                  |
 *       closure1                    ...   closuerN
 *          |                                  | 
 *  +----+--+-+--------+-----+       +----+----+---+-----+
 *  |    |    |        |     |       |    |        |     |
 * var1 var2 var3 ... varN result   var1 var2 ... varN result
 *                           |
 *                  +--------+---------+
 *                  |                  |
 *          union of closures     result_type
 *                  |
 *            +-----+-------------------+
 *            |                         |
 *         closure1            ...  closureN
 *            |                         |
 *  +-----+---+----+----+      +----+---+----+-----+
 *  |     |        |    |      |    |        |     |
 * var1 var2 ... varN result  var1 var2 ... varN result
 */

static int add_closure_type(struct compile_state *state, 
        struct triple *func, struct type *closure_type)
{
        struct type *type, *ctype, **next;
        struct triple *var, *new_var;
        int i;

#if 0
        FILE *fp = state->errout;
        fprintf(fp, "original_type: ");
        name_of(fp, fresult(state, func)->type);
        fprintf(fp, "\n");
#endif
        /* find the original type */
        var = fresult(state, func);
        type = var->type;
        if (type->elements != 2) {
                internal_error(state, var, "bad return type");
        }

        /* Find the complete closure type and update it */
        ctype = type->left->left;
        next = &ctype->left;
        while(((*next)->type & TYPE_MASK) == TYPE_OVERLAP) {
                next = &(*next)->right;
        }
        *next = new_type(TYPE_OVERLAP, *next, dup_type(state, closure_type));
        ctype->elements += 1;

#if 0
        fprintf(fp, "new_type: ");
        name_of(fp, type);
        fprintf(fp, "\n");
        fprintf(fp, "ctype: %p %d bits: %d ", 
                ctype, ctype->elements, reg_size_of(state, ctype));
        name_of(fp, ctype);
        fprintf(fp, "\n");
#endif
        
        /* Regenerate the variable with the new type definition */
        new_var = pre_triple(state, var, OP_ADECL, type, 0, 0);
        new_var->id |= TRIPLE_FLAG_FLATTENED;
        for(i = 0; i < new_var->lhs; i++) {
                LHS(new_var, i)->id |= TRIPLE_FLAG_FLATTENED;
        }
        
        /* Point everyone at the new variable */
        propogate_use(state, var, new_var);

        /* Release the original variable */
        for(i = 0; i < var->lhs; i++) {
                release_triple(state, LHS(var, i));
        }
        release_triple(state, var);
        
        /* Return the index of the added closure type */
        return ctype->elements - 1;
}

static struct triple *closure_expr(struct compile_state *state,
        struct triple *func, int closure_idx, int var_idx)
{
        return deref_index(state,
                deref_index(state,
                        deref_index(state, fresult(state, func), 0),
                        closure_idx),
                var_idx);
}


static void insert_triple_set(
        struct triple_reg_set **head, struct triple *member)
{
        struct triple_reg_set *new;
        new = xcmalloc(sizeof(*new), "triple_set");
        new->member = member;
        new->new    = 0;
        new->next   = *head;
        *head       = new;
}

static int ordered_triple_set(
        struct triple_reg_set **head, struct triple *member)
{
        struct triple_reg_set **ptr;
        if (!member)
                return 0;
        ptr = head;
        while(*ptr) {
                if (member == (*ptr)->member) {
                        return 0;
                }
                /* keep the list ordered */
                if (member->id < (*ptr)->member->id) {
                        break;
                }
                ptr = &(*ptr)->next;
        }
        insert_triple_set(ptr, member);
        return 1;
}


static void free_closure_variables(struct compile_state *state,
        struct triple_reg_set **enclose)
{
        struct triple_reg_set *entry, *next;
        for(entry = *enclose; entry; entry = next) {
                next = entry->next;
                do_triple_unset(enclose, entry->member);
        }
}

static int lookup_closure_index(struct compile_state *state,
        struct triple *me, struct triple *val)
{
        struct triple *first, *ins, *next;
        first = RHS(me, 0);
        ins = next = first;
        do {
                struct triple *result;
                struct triple *index0, *index1, *index2, *read, *write;
                ins = next;
                next = ins->next;
                if (ins->op != OP_CALL) {
                        continue;
                }
                /* I am at a previous call point examine it closely */
                if (ins->next->op != OP_LABEL) {
                        internal_error(state, ins, "call not followed by label");
                }
                /* Does this call does not enclose any variables? */
                if ((ins->next->next->op != OP_INDEX) ||
                        (ins->next->next->u.cval != 0) ||
                        (result = MISC(ins->next->next, 0)) ||
                        (result->id & TRIPLE_FLAG_LOCAL)) {
                        continue;
                }
                index0 = ins->next->next;
                /* The pattern is:
                 * 0 index result < 0 >
                 * 1 index 0 < ? >
                 * 2 index 1 < ? >
                 * 3 read  2
                 * 4 write 3 var
                 */
                for(index0 = ins->next->next;
                        (index0->op == OP_INDEX) &&
                                (MISC(index0, 0) == result) &&
                                (index0->u.cval == 0) ; 
                        index0 = write->next)
                {
                        index1 = index0->next;
                        index2 = index1->next;
                        read   = index2->next;
                        write  = read->next;
                        if ((index0->op != OP_INDEX) ||
                                (index1->op != OP_INDEX) ||
                                (index2->op != OP_INDEX) ||
                                (read->op != OP_READ) ||
                                (write->op != OP_WRITE) ||
                                (MISC(index1, 0) != index0) ||
                                (MISC(index2, 0) != index1) ||
                                (RHS(read, 0) != index2) ||
                                (RHS(write, 0) != read)) {
                                internal_error(state, index0, "bad var read");
                        }
                        if (MISC(write, 0) == val) {
                                return index2->u.cval;
                        }
                }
        } while(next != first);
        return -1;
}

static inline int enclose_triple(struct triple *ins)
{
        return (ins && ((ins->type->type & TYPE_MASK) != TYPE_VOID));
}

static void compute_closure_variables(struct compile_state *state,
        struct triple *me, struct triple *fcall, struct triple_reg_set **enclose)
{
        struct triple_reg_set *set, *vars, **last_var;
        struct basic_blocks bb;
        struct reg_block *rb;
        struct block *block;
        struct triple *old_result, *first, *ins;
        size_t count, idx;
        unsigned long used_indicies;
        int i, max_index;
#define MAX_INDICIES (sizeof(used_indicies)*CHAR_BIT)
#define ID_BITS(X) ((X) & (TRIPLE_FLAG_LOCAL -1))
        struct { 
                unsigned id;
                int index;
        } *info;

        
        /* Find the basic blocks of this function */
        bb.func = me;
        bb.first = RHS(me, 0);
        old_result = 0;
        if (!triple_is_ret(state, bb.first->prev)) {
                bb.func = 0;
        } else {
                old_result = fresult(state, me);
        }
        analyze_basic_blocks(state, &bb);

        /* Find which variables are currently alive in a given block */
        rb = compute_variable_lifetimes(state, &bb);

        /* Find the variables that are currently alive */
        block = block_of_triple(state, fcall);
        if (!block || (block->vertex <= 0) || (block->vertex > bb.last_vertex)) {
                internal_error(state, fcall, "No reg block? block: %p", block);
        }

#if DEBUG_EXPLICIT_CLOSURES
        print_live_variables(state, &bb, rb, state->dbgout);
        fflush(state->dbgout);
#endif

        /* Count the number of triples in the function */
        first = RHS(me, 0);
        ins = first;
        count = 0;
        do {
                count++;
                ins = ins->next;
        } while(ins != first);

        /* Allocate some memory to temorary hold the id info */
        info = xcmalloc(sizeof(*info) * (count +1), "info");

        /* Mark the local function */
        first = RHS(me, 0);
        ins = first;
        idx = 1;
        do {
                info[idx].id = ins->id;
                ins->id = TRIPLE_FLAG_LOCAL | idx;
                idx++;
                ins = ins->next;
        } while(ins != first);

        /* 
         * Build the list of variables to enclose.
         *
         * A target it to put the same variable in the
         * same slot for ever call of a given function.
         * After coloring this removes all of the variable
         * manipulation code.
         *
         * The list of variables to enclose is built ordered
         * program order because except in corner cases this
         * gives me the stability of assignment I need.
         *
         * To gurantee that stability I lookup the variables
         * to see where they have been used before and
         * I build my final list with the assigned indicies.
         */
        vars = 0;
        if (enclose_triple(old_result)) {
                ordered_triple_set(&vars, old_result);
        }
        for(set = rb[block->vertex].out; set; set = set->next) {
                if (!enclose_triple(set->member)) {
                        continue;
                }
                if ((set->member == fcall) || (set->member == old_result)) {
                        continue;
                }
                if (!local_triple(state, me, set->member)) {
                        internal_error(state, set->member, "not local?");
                }
                ordered_triple_set(&vars, set->member);
        }

        /* Lookup the current indicies of the live varialbe */
        used_indicies = 0;
        max_index = -1;
        for(set = vars; set ; set = set->next) {
                struct triple *ins;
                int index;
                ins = set->member;
                index  = lookup_closure_index(state, me, ins);
                info[ID_BITS(ins->id)].index = index;
                if (index < 0) {
                        continue;
                }
                if (index >= MAX_INDICIES) {
                        internal_error(state, ins, "index unexpectedly large");
                }
                if (used_indicies & (1 << index)) {
                        internal_error(state, ins, "index previously used?");
                }
                /* Remember which indicies have been used */
                used_indicies |= (1 << index);
                if (index > max_index) {
                        max_index = index;
                }
        }

        /* Walk through the live variables and make certain
         * everything is assigned an index.
         */
        for(set = vars; set; set = set->next) {
                struct triple *ins;
                int index;
                ins = set->member;
                index = info[ID_BITS(ins->id)].index;
                if (index >= 0) {
                        continue;
                }
                /* Find the lowest unused index value */
                for(index = 0; index < MAX_INDICIES; index++) {
                        if (!(used_indicies & (1 << index))) {
                                break;
                        }
                }
                if (index == MAX_INDICIES) {
                        internal_error(state, ins, "no free indicies?");
                }
                info[ID_BITS(ins->id)].index = index;
                /* Remember which indicies have been used */
                used_indicies |= (1 << index);
                if (index > max_index) {
                        max_index = index;
                }
        }

        /* Build the return list of variables with positions matching
         * their indicies.
         */
        *enclose = 0;
        last_var = enclose;
        for(i = 0; i <= max_index; i++) {
                struct triple *var;
                var = 0;
                if (used_indicies & (1 << i)) {
                        for(set = vars; set; set = set->next) {
                                int index;
                                index = info[ID_BITS(set->member->id)].index;
                                if (index == i) {
                                        var = set->member;
                                        break;
                                }
                        }
                        if (!var) {
                                internal_error(state, me, "missing variable");
                        }
                }
                insert_triple_set(last_var, var);
                last_var = &(*last_var)->next;
        }

#if DEBUG_EXPLICIT_CLOSURES
        /* Print out the variables to be enclosed */
        loc(state->dbgout, state, fcall);
        fprintf(state->dbgout, "Alive: \n");
        for(set = *enclose; set; set = set->next) {
                display_triple(state->dbgout, set->member);
        }
        fflush(state->dbgout);
#endif

        /* Clear the marks */
        ins = first;
        do {
                ins->id = info[ID_BITS(ins->id)].id;
                ins = ins->next;
        } while(ins != first);

        /* Release the ordered list of live variables */
        free_closure_variables(state, &vars);

        /* Release the storage of the old ids */
        xfree(info);

        /* Release the variable lifetime information */
        free_variable_lifetimes(state, &bb, rb);

        /* Release the basic blocks of this function */
        free_basic_blocks(state, &bb);
}

static void expand_function_call(
        struct compile_state *state, struct triple *me, struct triple *fcall)
{
        /* Generate an ordinary function call */
        struct type *closure_type, **closure_next;
        struct triple *func, *func_first, *func_last, *retvar;
        struct triple *first;
        struct type *ptype, *rtype;
        struct triple *jmp;
        struct triple *ret_addr, *ret_loc, *ret_set;
        struct triple_reg_set *enclose, *set;
        int closure_idx, pvals, i;

#if DEBUG_EXPLICIT_CLOSURES
        FILE *fp = state->dbgout;
        fprintf(fp, "\ndisplay_func(me) ptr: %p\n", fcall);
        display_func(state, fp, MISC(fcall, 0));
        display_func(state, fp, me);
        fprintf(fp, "__________ %s _________ done\n\n", __FUNCTION__);
#endif

        /* Find the triples */
        func = MISC(fcall, 0);
        func_first = RHS(func, 0);
        retvar = fretaddr(state, func);
        func_last  = func_first->prev;
        first = fcall->next;

        /* Find what I need to enclose */
        compute_closure_variables(state, me, fcall, &enclose);

        /* Compute the closure type */
        closure_type = new_type(TYPE_TUPLE, 0, 0);
        closure_type->elements = 0;
        closure_next = &closure_type->left;
        for(set = enclose; set ; set = set->next) {
                struct type *type;
                type = &void_type;
                if (set->member) {
                        type = set->member->type;
                }
                if (!*closure_next) {
                        *closure_next = type;
                } else {
                        *closure_next = new_type(TYPE_PRODUCT, *closure_next, 
                                type);
                        closure_next = &(*closure_next)->right;
                }
                closure_type->elements += 1;
        }
        if (closure_type->elements == 0) {
                closure_type->type = TYPE_VOID;
        }


#if DEBUG_EXPLICIT_CLOSURES
        fprintf(state->dbgout, "closure type: ");
        name_of(state->dbgout, closure_type);
        fprintf(state->dbgout, "\n");
#endif

        /* Update the called functions closure variable */
        closure_idx = add_closure_type(state, func, closure_type);

        /* Generate some needed triples */
        ret_loc = label(state);
        ret_addr = triple(state, OP_ADDRCONST, &void_ptr_type, ret_loc, 0);

        /* Pass the parameters to the new function */
        ptype = func->type->right;
        pvals = fcall->rhs;
        for(i = 0; i < pvals; i++) {
                struct type *atype;
                struct triple *arg, *param;
                atype = ptype;
                if ((ptype->type & TYPE_MASK) == TYPE_PRODUCT) {
                        atype = ptype->left;
                }
                param = farg(state, func, i);
                if ((param->type->type & TYPE_MASK) != (atype->type & TYPE_MASK)) {
                        internal_error(state, fcall, "param type mismatch");
                }
                arg = RHS(fcall, i);
                flatten(state, first, write_expr(state, param, arg));
                ptype = ptype->right;
        }
        rtype = func->type->left;

        /* Thread the triples together */
        ret_loc       = flatten(state, first, ret_loc);

        /* Save the active variables in the result variable */
        for(i = 0, set = enclose; set ; set = set->next, i++) {
                if (!set->member) {
                        continue;
                }
                flatten(state, ret_loc,
                        write_expr(state,
                                closure_expr(state, func, closure_idx, i),
                                read_expr(state, set->member)));
        }

        /* Initialize the return value */
        if ((rtype->type & TYPE_MASK) != TYPE_VOID) {
                flatten(state, ret_loc, 
                        write_expr(state, 
                                deref_index(state, fresult(state, func), 1),
                                new_triple(state, OP_UNKNOWNVAL, rtype,  0, 0)));
        }

        ret_addr      = flatten(state, ret_loc, ret_addr);
        ret_set       = flatten(state, ret_loc, write_expr(state, retvar, ret_addr));
        jmp           = flatten(state, ret_loc, 
                call(state, retvar, ret_addr, func_first, func_last));

        /* Find the result */
        if ((rtype->type & TYPE_MASK) != TYPE_VOID) {
                struct triple * result;
                result = flatten(state, first, 
                        read_expr(state, 
                                deref_index(state, fresult(state, func), 1)));

                propogate_use(state, fcall, result);
        }

        /* Release the original fcall instruction */
        release_triple(state, fcall);

        /* Restore the active variables from the result variable */
        for(i = 0, set = enclose; set ; set = set->next, i++) {
                struct triple_set *use, *next;
                struct triple *new;
                struct basic_blocks bb;
                if (!set->member || (set->member == fcall)) {
                        continue;
                }
                /* Generate an expression for the value */
                new = flatten(state, first,
                        read_expr(state, 
                                closure_expr(state, func, closure_idx, i)));


                /* If the original is an lvalue restore the preserved value */
                if (is_lvalue(state, set->member)) {
                        flatten(state, first,
                                write_expr(state, set->member, new));
                        continue;
                }
                /*
                 * If the original is a value update the dominated uses.
                 */
                
                /* Analyze the basic blocks so I can see who dominates whom */
                bb.func = me;
                bb.first = RHS(me, 0);
                if (!triple_is_ret(state, bb.first->prev)) {
                        bb.func = 0;
                }
                analyze_basic_blocks(state, &bb);
                

#if DEBUG_EXPLICIT_CLOSURES
                fprintf(state->errout, "Updating domindated uses: %p -> %p\n",
                        set->member, new);
#endif
                /* If fcall dominates the use update the expression */
                for(use = set->member->use; use; use = next) {
                        /* Replace use modifies the use chain and 
                         * removes use, so I must take a copy of the
                         * next entry early.
                         */
                        next = use->next;
                        if (!tdominates(state, fcall, use->member)) {
                                continue;
                        }
                        replace_use(state, set->member, new, use->member);
                }

                /* Release the basic blocks, the instructions will be
                 * different next time, and flatten/insert_triple does
                 * not update the block values so I can't cache the analysis.
                 */
                free_basic_blocks(state, &bb);
        }

        /* Release the closure variable list */
        free_closure_variables(state, &enclose);

        if (state->compiler->debug & DEBUG_INLINE) {
                FILE *fp = state->dbgout;
                fprintf(fp, "\n");
                loc(fp, state, 0);
                fprintf(fp, "\n__________ %s _________\n", __FUNCTION__);
                display_func(state, fp, func);
                display_func(state, fp, me);
                fprintf(fp, "__________ %s _________ done\n\n", __FUNCTION__);
        }

        return;
}

static int do_inline(struct compile_state *state, struct triple *func)
{
        int do_inline;
        int policy;

        policy = state->compiler->flags & COMPILER_INLINE_MASK;
        switch(policy) {
        case COMPILER_INLINE_ALWAYS:
                do_inline = 1;
                if (func->type->type & ATTRIB_NOINLINE) {
                        error(state, func, "noinline with always_inline compiler option");
                }
                break;
        case COMPILER_INLINE_NEVER:
                do_inline = 0;
                if (func->type->type & ATTRIB_ALWAYS_INLINE) {
                        error(state, func, "always_inline with noinline compiler option");
                }
                break;
        case COMPILER_INLINE_DEFAULTON:
                switch(func->type->type & STOR_MASK) {
                case STOR_STATIC | STOR_INLINE:
                case STOR_LOCAL  | STOR_INLINE:
                case STOR_EXTERN | STOR_INLINE:
                        do_inline = 1;
                        break;
                default:
                        do_inline = 1;
                        break;
                }
                break;
        case COMPILER_INLINE_DEFAULTOFF:
                switch(func->type->type & STOR_MASK) {
                case STOR_STATIC | STOR_INLINE:
                case STOR_LOCAL  | STOR_INLINE:
                case STOR_EXTERN | STOR_INLINE:
                        do_inline = 1;
                        break;
                default:
                        do_inline = 0;
                        break;
                }
                break;
        case COMPILER_INLINE_NOPENALTY:
                switch(func->type->type & STOR_MASK) {
                case STOR_STATIC | STOR_INLINE:
                case STOR_LOCAL  | STOR_INLINE:
                case STOR_EXTERN | STOR_INLINE:
                        do_inline = 1;
                        break;
                default:
                        do_inline = (func->u.cval == 1);
                        break;
                }
                break;
        default:
                do_inline = 0;
                internal_error(state, 0, "Unimplemented inline policy");
                break;
        }
        /* Force inlining */
        if (func->type->type & ATTRIB_NOINLINE) {
                do_inline = 0;
        }
        if (func->type->type & ATTRIB_ALWAYS_INLINE) {
                do_inline = 1;
        }
        return do_inline;
}

static void inline_function(struct compile_state *state, struct triple *me, void *arg)
{
        struct triple *first, *ptr, *next;
        /* If the function is not used don't bother */
        if (me->u.cval <= 0) {
                return;
        }
        if (state->compiler->debug & DEBUG_CALLS2) {
                FILE *fp = state->dbgout;
                fprintf(fp, "in: %s\n",
                        me->type->type_ident->name);
        }

        first = RHS(me, 0);
        ptr = next = first;
        do {
                struct triple *func, *prev;
                ptr = next;
                prev = ptr->prev;
                next = ptr->next;
                if (ptr->op != OP_FCALL) {
                        continue;
                }
                func = MISC(ptr, 0);
                /* See if the function should be inlined */
                if (!do_inline(state, func)) {
                        /* Put a label after the fcall */
                        post_triple(state, ptr, OP_LABEL, &void_type, 0, 0);
                        continue;
                }
                if (state->compiler->debug & DEBUG_CALLS) {
                        FILE *fp = state->dbgout;
                        if (state->compiler->debug & DEBUG_CALLS2) {
                                loc(fp, state, ptr);
                        }
                        fprintf(fp, "inlining %s\n",
                                func->type->type_ident->name);
                        fflush(fp);
                }

                /* Update the function use counts */
                func->u.cval -= 1;

                /* Replace the fcall with the called function */
                expand_inline_call(state, me, ptr);

                next = prev->next;
        } while (next != first);

        ptr = next = first;
        do {
                struct triple *prev, *func;
                ptr = next;
                prev = ptr->prev;
                next = ptr->next;
                if (ptr->op != OP_FCALL) {
                        continue;
                }
                func = MISC(ptr, 0);
                if (state->compiler->debug & DEBUG_CALLS) {
                        FILE *fp = state->dbgout;
                        if (state->compiler->debug & DEBUG_CALLS2) {
                                loc(fp, state, ptr);
                        }
                        fprintf(fp, "calling %s\n",
                                func->type->type_ident->name);
                        fflush(fp);
                }
                /* Replace the fcall with the instruction sequence
                 * needed to make the call.
                 */
                expand_function_call(state, me, ptr);
                next = prev->next;
        } while(next != first);
}

static void inline_functions(struct compile_state *state, struct triple *func)
{
        inline_function(state, func, 0);
        reverse_walk_functions(state, inline_function, 0);
}

static void insert_function(struct compile_state *state,
        struct triple *func, void *arg)
{
        struct triple *first, *end, *ffirst, *fend;

        if (state->compiler->debug & DEBUG_INLINE) {
                FILE *fp = state->errout;
                fprintf(fp, "%s func count: %d\n", 
                        func->type->type_ident->name, func->u.cval);
        }
        if (func->u.cval == 0) {
                return;
        }

        /* Find the end points of the lists */
        first  = arg;
        end    = first->prev;
        ffirst = RHS(func, 0);
        fend   = ffirst->prev;

        /* splice the lists together */
        end->next    = ffirst;
        ffirst->prev = end;
        fend->next   = first;
        first->prev  = fend;
}

struct triple *input_asm(struct compile_state *state)
{
        struct asm_info *info;
        struct triple *def;
        int i, out;
        
        info = xcmalloc(sizeof(*info), "asm_info");
        info->str = "";

        out = sizeof(arch_input_regs)/sizeof(arch_input_regs[0]);
        memcpy(&info->tmpl.lhs, arch_input_regs, sizeof(arch_input_regs));

        def = new_triple(state, OP_ASM, &void_type, out, 0);
        def->u.ainfo = info;
        def->id |= TRIPLE_FLAG_VOLATILE;
        
        for(i = 0; i < out; i++) {
                struct triple *piece;
                piece = triple(state, OP_PIECE, &int_type, def, 0);
                piece->u.cval = i;
                LHS(def, i) = piece;
        }

        return def;
}

struct triple *output_asm(struct compile_state *state)
{
        struct asm_info *info;
        struct triple *def;
        int in;
        
        info = xcmalloc(sizeof(*info), "asm_info");
        info->str = "";

        in = sizeof(arch_output_regs)/sizeof(arch_output_regs[0]);
        memcpy(&info->tmpl.rhs, arch_output_regs, sizeof(arch_output_regs));

        def = new_triple(state, OP_ASM, &void_type, 0, in);
        def->u.ainfo = info;
        def->id |= TRIPLE_FLAG_VOLATILE;
        
        return def;
}

static void join_functions(struct compile_state *state)
{
        struct triple *jmp, *start, *end, *call, *in, *out, *func;
        struct file_state file;
        struct type *pnext, *param;
        struct type *result_type, *args_type;
        int idx;

        /* Be clear the functions have not been joined yet */
        state->functions_joined = 0;

        /* Dummy file state to get debug handing right */
        memset(&file, 0, sizeof(file));
        file.basename = "";
        file.line = 0;
        file.report_line = 0;
        file.report_name = file.basename;
        file.prev = state->file;
        state->file = &file;
        state->function = "";

        if (!state->main_function) {
                error(state, 0, "No functions to compile\n");
        }

        /* The type of arguments */
        args_type   = state->main_function->type->right;
        /* The return type without any specifiers */
        result_type = clone_type(0, state->main_function->type->left);


        /* Verify the external arguments */
        if (registers_of(state, args_type) > ARCH_INPUT_REGS) {
                error(state, state->main_function, 
                        "Too many external input arguments");
        }
        if (registers_of(state, result_type) > ARCH_OUTPUT_REGS) {
                error(state, state->main_function, 
                        "Too many external output arguments");
        }

        /* Lay down the basic program structure */
        end           = label(state);
        start         = label(state);
        start         = flatten(state, state->first, start);
        end           = flatten(state, state->first, end);
        in            = input_asm(state);
        out           = output_asm(state);
        call          = new_triple(state, OP_FCALL, result_type, -1, registers_of(state, args_type));
        MISC(call, 0) = state->main_function;
        in            = flatten(state, state->first, in);
        call          = flatten(state, state->first, call);
        out           = flatten(state, state->first, out);


        /* Read the external input arguments */
        pnext = args_type;
        idx = 0;
        while(pnext && ((pnext->type & TYPE_MASK) != TYPE_VOID)) {
                struct triple *expr;
                param = pnext;
                pnext = 0;
                if ((param->type & TYPE_MASK) == TYPE_PRODUCT) {
                        pnext = param->right;
                        param = param->left;
                }
                if (registers_of(state, param) != 1) {
                        error(state, state->main_function, 
                                "Arg: %d %s requires multiple registers", 
                                idx + 1, param->field_ident->name);
                }
                expr = read_expr(state, LHS(in, idx));
                RHS(call, idx) = expr;
                expr = flatten(state, call, expr);
                use_triple(expr, call);

                idx++;  
        }


        /* Write the external output arguments */
        pnext = result_type;
        if ((pnext->type & TYPE_MASK) == TYPE_STRUCT) {
                pnext = result_type->left;
        }
        for(idx = 0; idx < out->rhs; idx++) {
                struct triple *expr;
                param = pnext;
                pnext = 0;
                if (param && ((param->type & TYPE_MASK) == TYPE_PRODUCT)) {
                        pnext = param->right;
                        param = param->left;
                }
                if (param && ((param->type & TYPE_MASK) == TYPE_VOID)) {
                        param = 0;
                }
                if (param) {
                        if (registers_of(state, param) != 1) {
                                error(state, state->main_function,
                                        "Result: %d %s requires multiple registers",
                                        idx, param->field_ident->name);
                        }
                        expr = read_expr(state, call);
                        if ((result_type->type & TYPE_MASK) == TYPE_STRUCT) {
                                expr = deref_field(state, expr, param->field_ident);
                        }
                } else {
                        expr = triple(state, OP_UNKNOWNVAL, &int_type, 0, 0);
                }
                flatten(state, out, expr);
                RHS(out, idx) = expr;
                use_triple(expr, out);
        }

        /* Allocate a dummy containing function */
        func = triple(state, OP_LIST, 
                new_type(TYPE_FUNCTION, &void_type, &void_type), 0, 0);
        func->type->type_ident = lookup(state, "", 0);
        RHS(func, 0) = state->first;
        func->u.cval = 1;

        /* See which functions are called, and how often */
        mark_live_functions(state);
        inline_functions(state, func);
        walk_functions(state, insert_function, end);

        if (start->next != end) {
                jmp = flatten(state, start, branch(state, end, 0));
        }

        /* OK now the functions have been joined. */
        state->functions_joined = 1;

        /* Done now cleanup */
        state->file = file.prev;
        state->function = 0;
}

/*
 * Data structurs for optimation.
 */


static int do_use_block(
        struct block *used, struct block_set **head, struct block *user, 
        int front)
{
        struct block_set **ptr, *new;
        if (!used)
                return 0;
        if (!user)
                return 0;
        ptr = head;
        while(*ptr) {
                if ((*ptr)->member == user) {
                        return 0;
                }
                ptr = &(*ptr)->next;
        }
        new = xcmalloc(sizeof(*new), "block_set");
        new->member = user;
        if (front) {
                new->next = *head;
                *head = new;
        }
        else {
                new->next = 0;
                *ptr = new;
        }
        return 1;
}
static int do_unuse_block(
        struct block *used, struct block_set **head, struct block *unuser)
{
        struct block_set *use, **ptr;
        int count;
        count = 0;
        ptr = head;
        while(*ptr) {
                use = *ptr;
                if (use->member == unuser) {
                        *ptr = use->next;
                        memset(use, -1, sizeof(*use));
                        xfree(use);
                        count += 1;
                }
                else {
                        ptr = &use->next;
                }
        }
        return count;
}

static void use_block(struct block *used, struct block *user)
{
        int count;
        /* Append new to the head of the list, print_block
         * depends on this.
         */
        count = do_use_block(used, &used->use, user, 1); 
        used->users += count;
}
static void unuse_block(struct block *used, struct block *unuser)
{
        int count;
        count = do_unuse_block(used, &used->use, unuser); 
        used->users -= count;
}

static void add_block_edge(struct block *block, struct block *edge, int front)
{
        int count;
        count = do_use_block(block, &block->edges, edge, front);
        block->edge_count += count;
}

static void remove_block_edge(struct block *block, struct block *edge)
{
        int count;
        count = do_unuse_block(block, &block->edges, edge);
        block->edge_count -= count;
}

static void idom_block(struct block *idom, struct block *user)
{
        do_use_block(idom, &idom->idominates, user, 0);
}

static void unidom_block(struct block *idom, struct block *unuser)
{
        do_unuse_block(idom, &idom->idominates, unuser);
}

static void domf_block(struct block *block, struct block *domf)
{
        do_use_block(block, &block->domfrontier, domf, 0);
}

static void undomf_block(struct block *block, struct block *undomf)
{
        do_unuse_block(block, &block->domfrontier, undomf);
}

static void ipdom_block(struct block *ipdom, struct block *user)
{
        do_use_block(ipdom, &ipdom->ipdominates, user, 0);
}

static void unipdom_block(struct block *ipdom, struct block *unuser)
{
        do_unuse_block(ipdom, &ipdom->ipdominates, unuser);
}

static void ipdomf_block(struct block *block, struct block *ipdomf)
{
        do_use_block(block, &block->ipdomfrontier, ipdomf, 0);
}

static void unipdomf_block(struct block *block, struct block *unipdomf)
{
        do_unuse_block(block, &block->ipdomfrontier, unipdomf);
}

static int walk_triples(
        struct compile_state *state, 
        int (*cb)(struct compile_state *state, struct triple *ptr, void *arg),
        void *arg)
{
        struct triple *ptr;
        int result;
        ptr = state->first;
        do {
                result = cb(state, ptr, arg);
                if (ptr->next->prev != ptr) {
                        internal_error(state, ptr->next, "bad prev");
                }
                ptr = ptr->next;
        } while((result == 0) && (ptr != state->first));
        return result;
}

#define PRINT_LIST 1
static int do_print_triple(struct compile_state *state, struct triple *ins, void *arg)
{
        FILE *fp = arg;
        int op;
        op = ins->op;
        if (op == OP_LIST) {
#if !PRINT_LIST
                return 0;
#endif
        }
        if ((op == OP_LABEL) && (ins->use)) {
                fprintf(fp, "\n%p:\n", ins);
        }
        display_triple(fp, ins);

        if (triple_is_branch(state, ins) && ins->use && 
                (ins->op != OP_RET) && (ins->op != OP_FCALL)) {
                internal_error(state, ins, "branch used?");
        }
        if (triple_is_branch(state, ins)) {
                fprintf(fp, "\n");
        }
        return 0;
}

static void print_triples(struct compile_state *state)
{
        if (state->compiler->debug & DEBUG_TRIPLES) {
                FILE *fp = state->dbgout;
                fprintf(fp, "--------------- triples ---------------\n");
                walk_triples(state, do_print_triple, fp);
                fprintf(fp, "\n");
        }
}

struct cf_block {
        struct block *block;
};
static void find_cf_blocks(struct cf_block *cf, struct block *block)
{
        struct block_set *edge;
        if (!block || (cf[block->vertex].block == block)) {
                return;
        }
        cf[block->vertex].block = block;
        for(edge = block->edges; edge; edge = edge->next) {
                find_cf_blocks(cf, edge->member);
        }
}

static void print_control_flow(struct compile_state *state,
        FILE *fp, struct basic_blocks *bb)
{
        struct cf_block *cf;
        int i;
        fprintf(fp, "\ncontrol flow\n");
        cf = xcmalloc(sizeof(*cf) * (bb->last_vertex + 1), "cf_block");
        find_cf_blocks(cf, bb->first_block);

        for(i = 1; i <= bb->last_vertex; i++) {
                struct block *block;
                struct block_set *edge;
                block = cf[i].block;
                if (!block)
                        continue;
                fprintf(fp, "(%p) %d:", block, block->vertex);
                for(edge = block->edges; edge; edge = edge->next) {
                        fprintf(fp, " %d", edge->member->vertex);
                }
                fprintf(fp, "\n");
        }

        xfree(cf);
}

static void free_basic_block(struct compile_state *state, struct block *block)
{
        struct block_set *edge, *entry;
        struct block *child;
        if (!block) {
                return;
        }
        if (block->vertex == -1) {
                return;
        }
        block->vertex = -1;
        for(edge = block->edges; edge; edge = edge->next) {
                if (edge->member) {
                        unuse_block(edge->member, block);
                }
        }
        if (block->idom) {
                unidom_block(block->idom, block);
        }
        block->idom = 0;
        if (block->ipdom) {
                unipdom_block(block->ipdom, block);
        }
        block->ipdom = 0;
        while((entry = block->use)) {
                child = entry->member;
                unuse_block(block, child);
                if (child && (child->vertex != -1)) {
                        for(edge = child->edges; edge; edge = edge->next) {
                                edge->member = 0;
                        }
                }
        }
        while((entry = block->idominates)) {
                child = entry->member;
                unidom_block(block, child);
                if (child && (child->vertex != -1)) {
                        child->idom = 0;
                }
        }
        while((entry = block->domfrontier)) {
                child = entry->member;
                undomf_block(block, child);
        }
        while((entry = block->ipdominates)) {
                child = entry->member;
                unipdom_block(block, child);
                if (child && (child->vertex != -1)) {
                        child->ipdom = 0;
                }
        }
        while((entry = block->ipdomfrontier)) {
                child = entry->member;
                unipdomf_block(block, child);
        }
        if (block->users != 0) {
                internal_error(state, 0, "block still has users");
        }
        while((edge = block->edges)) {
                child = edge->member;
                remove_block_edge(block, child);
                
                if (child && (child->vertex != -1)) {
                        free_basic_block(state, child);
                }
        }
        memset(block, -1, sizeof(*block));
        xfree(block);
}

static void free_basic_blocks(struct compile_state *state, 
        struct basic_blocks *bb)
{
        struct triple *first, *ins;
        free_basic_block(state, bb->first_block);
        bb->last_vertex = 0;
        bb->first_block = bb->last_block = 0;
        first = bb->first;
        ins = first;
        do {
                if (triple_stores_block(state, ins)) {
                        ins->u.block = 0;
                }
                ins = ins->next;
        } while(ins != first);
        
}

static struct block *basic_block(struct compile_state *state, 
        struct basic_blocks *bb, struct triple *first)
{
        struct block *block;
        struct triple *ptr;
        if (!triple_is_label(state, first)) {
                internal_error(state, first, "block does not start with a label");
        }
        /* See if this basic block has already been setup */
        if (first->u.block != 0) {
                return first->u.block;
        }
        /* Allocate another basic block structure */
        bb->last_vertex += 1;
        block = xcmalloc(sizeof(*block), "block");
        block->first = block->last = first;
        block->vertex = bb->last_vertex;
        ptr = first;
        do {
                if ((ptr != first) && triple_is_label(state, ptr) && (ptr->use)) { 
                        break;
                }
                block->last = ptr;
                /* If ptr->u is not used remember where the baic block is */
                if (triple_stores_block(state, ptr)) {
                        ptr->u.block = block;
                }
                if (triple_is_branch(state, ptr)) {
                        break;
                }
                ptr = ptr->next;
        } while (ptr != bb->first);
        if ((ptr == bb->first) ||
                ((ptr->next == bb->first) && (
                        triple_is_end(state, ptr) || 
                        triple_is_ret(state, ptr))))
        {
                /* The block has no outflowing edges */
        }
        else if (triple_is_label(state, ptr)) {
                struct block *next;
                next = basic_block(state, bb, ptr);
                add_block_edge(block, next, 0);
                use_block(next, block);
        }
        else if (triple_is_branch(state, ptr)) {
                struct triple **expr, *first;
                struct block *child;
                /* Find the branch targets.
                 * I special case the first branch as that magically
                 * avoids some difficult cases for the register allocator.
                 */
                expr = triple_edge_targ(state, ptr, 0);
                if (!expr) {
                        internal_error(state, ptr, "branch without targets");
                }
                first = *expr;
                expr = triple_edge_targ(state, ptr, expr);
                for(; expr; expr = triple_edge_targ(state, ptr, expr)) {
                        if (!*expr) continue;
                        child = basic_block(state, bb, *expr);
                        use_block(child, block);
                        add_block_edge(block, child, 0);
                }
                if (first) {
                        child = basic_block(state, bb, first);
                        use_block(child, block);
                        add_block_edge(block, child, 1);

                        /* Be certain the return block of a call is
                         * in a basic block.  When it is not find
                         * start of the block, insert a label if
                         * necessary and build the basic block.
                         * Then add a fake edge from the start block
                         * to the return block of the function.
                         */
                        if (state->functions_joined && triple_is_call(state, ptr)
                                && !block_of_triple(state, MISC(ptr, 0))) {
                                struct block *tail;
                                struct triple *start;
                                start = triple_to_block_start(state, MISC(ptr, 0));
                                if (!triple_is_label(state, start)) {
                                        start = pre_triple(state,
                                                start, OP_LABEL, &void_type, 0, 0);
                                }
                                tail = basic_block(state, bb, start);
                                add_block_edge(child, tail, 0);
                                use_block(tail, child);
                        }
                }
        }
        else {
                internal_error(state, 0, "Bad basic block split");
        }
#if 0
{
        struct block_set *edge;
        FILE *fp = state->errout;
        fprintf(fp, "basic_block: %10p [%2d] ( %10p - %10p )",
                block, block->vertex, 
                block->first, block->last);
        for(edge = block->edges; edge; edge = edge->next) {
                fprintf(fp, " %10p [%2d]",
                        edge->member ? edge->member->first : 0,
                        edge->member ? edge->member->vertex : -1);
        }
        fprintf(fp, "\n");
}
#endif
        return block;
}


static void walk_blocks(struct compile_state *state, struct basic_blocks *bb,
        void (*cb)(struct compile_state *state, struct block *block, void *arg),
        void *arg)
{
        struct triple *ptr, *first;
        struct block *last_block;
        last_block = 0;
        first = bb->first;
        ptr = first;
        do {
                if (triple_stores_block(state, ptr)) {
                        struct block *block;
                        block = ptr->u.block;
                        if (block && (block != last_block)) {
                                cb(state, block, arg);
                        }
                        last_block = block;
                }
                ptr = ptr->next;
        } while(ptr != first);
}

static void print_block(
        struct compile_state *state, struct block *block, void *arg)
{
        struct block_set *user, *edge;
        struct triple *ptr;
        FILE *fp = arg;

        fprintf(fp, "\nblock: %p (%d) ",
                block, 
                block->vertex);

        for(edge = block->edges; edge; edge = edge->next) {
                fprintf(fp, " %p<-%p",
                        edge->member,
                        (edge->member && edge->member->use)?
                        edge->member->use->member : 0);
        }
        fprintf(fp, "\n");
        if (block->first->op == OP_LABEL) {
                fprintf(fp, "%p:\n", block->first);
        }
        for(ptr = block->first; ; ) {
                display_triple(fp, ptr);
                if (ptr == block->last)
                        break;
                ptr = ptr->next;
                if (ptr == block->first) {
                        internal_error(state, 0, "missing block last?");
                }
        }
        fprintf(fp, "users %d: ", block->users);
        for(user = block->use; user; user = user->next) {
                fprintf(fp, "%p (%d) ", 
                        user->member,
                        user->member->vertex);
        }
        fprintf(fp,"\n\n");
}


static void romcc_print_blocks(struct compile_state *state, FILE *fp)
{
        fprintf(fp, "--------------- blocks ---------------\n");
        walk_blocks(state, &state->bb, print_block, fp);
}
static void print_blocks(struct compile_state *state, const char *func, FILE *fp)
{
        if (state->compiler->debug & DEBUG_BASIC_BLOCKS) {
                fprintf(fp, "After %s\n", func);
                romcc_print_blocks(state, fp);
                if (state->compiler->debug & DEBUG_FDOMINATORS) {
                        print_dominators(state, fp, &state->bb);
                        print_dominance_frontiers(state, fp, &state->bb);
                }
                print_control_flow(state, fp, &state->bb);
        }
}

static void prune_nonblock_triples(struct compile_state *state, 
        struct basic_blocks *bb)
{
        struct block *block;
        struct triple *first, *ins, *next;
        /* Delete the triples not in a basic block */
        block = 0;
        first = bb->first;
        ins = first;
        do {
                next = ins->next;
                if (ins->op == OP_LABEL) {
                        block = ins->u.block;
                }
                if (!block) {
                        struct triple_set *use;
                        for(use = ins->use; use; use = use->next) {
                                struct block *block;
                                block = block_of_triple(state, use->member);
                                if (block != 0) {
                                        internal_error(state, ins, "pruning used ins?");
                                }
                        }
                        release_triple(state, ins);
                }
                if (block && block->last == ins) {
                        block = 0;
                }
                ins = next;
        } while(ins != first);
}

static void setup_basic_blocks(struct compile_state *state, 
        struct basic_blocks *bb)
{
        if (!triple_stores_block(state, bb->first)) {
                internal_error(state, 0, "ins will not store block?");
        }
        /* Initialize the state */
        bb->first_block = bb->last_block = 0;
        bb->last_vertex = 0;
        free_basic_blocks(state, bb);

        /* Find the basic blocks */
        bb->first_block = basic_block(state, bb, bb->first);

        /* Be certain the last instruction of a function, or the
         * entire program is in a basic block.  When it is not find 
         * the start of the block, insert a label if necessary and build 
         * basic block.  Then add a fake edge from the start block
         * to the final block.
         */
        if (!block_of_triple(state, bb->first->prev)) {
                struct triple *start;
                struct block *tail;
                start = triple_to_block_start(state, bb->first->prev);
                if (!triple_is_label(state, start)) {
                        start = pre_triple(state,
                                start, OP_LABEL, &void_type, 0, 0);
                }
                tail = basic_block(state, bb, start);
                add_block_edge(bb->first_block, tail, 0);
                use_block(tail, bb->first_block);
        }
        
        /* Find the last basic block.
         */
        bb->last_block = block_of_triple(state, bb->first->prev);

        /* Delete the triples not in a basic block */
        prune_nonblock_triples(state, bb);

#if 0
        /* If we are debugging print what I have just done */
        if (state->compiler->debug & DEBUG_BASIC_BLOCKS) {
                print_blocks(state, state->dbgout);
                print_control_flow(state, bb);
        }
#endif
}


struct sdom_block {
        struct block *block;
        struct sdom_block *sdominates;
        struct sdom_block *sdom_next;
        struct sdom_block *sdom;
        struct sdom_block *label;
        struct sdom_block *parent;
        struct sdom_block *ancestor;
        int vertex;
};


static void unsdom_block(struct sdom_block *block)
{
        struct sdom_block **ptr;
        if (!block->sdom_next) {
                return;
        }
        ptr = &block->sdom->sdominates;
        while(*ptr) {
                if ((*ptr) == block) {
                        *ptr = block->sdom_next;
                        return;
                }
                ptr = &(*ptr)->sdom_next;
        }
}

static void sdom_block(struct sdom_block *sdom, struct sdom_block *block)
{
        unsdom_block(block);
        block->sdom = sdom;
        block->sdom_next = sdom->sdominates;
        sdom->sdominates = block;
}



static int initialize_sdblock(struct sdom_block *sd,
        struct block *parent, struct block *block, int vertex)
{
        struct block_set *edge;
        if (!block || (sd[block->vertex].block == block)) {
                return vertex;
        }
        vertex += 1;
        /* Renumber the blocks in a convinient fashion */
        block->vertex = vertex;
        sd[vertex].block    = block;
        sd[vertex].sdom     = &sd[vertex];
        sd[vertex].label    = &sd[vertex];
        sd[vertex].parent   = parent? &sd[parent->vertex] : 0;
        sd[vertex].ancestor = 0;
        sd[vertex].vertex   = vertex;
        for(edge = block->edges; edge; edge = edge->next) {
                vertex = initialize_sdblock(sd, block, edge->member, vertex);
        }
        return vertex;
}

static int initialize_spdblock(
        struct compile_state *state, struct sdom_block *sd,
        struct block *parent, struct block *block, int vertex)
{
        struct block_set *user;
        if (!block || (sd[block->vertex].block == block)) {
                return vertex;
        }
        vertex += 1;
        /* Renumber the blocks in a convinient fashion */
        block->vertex = vertex;
        sd[vertex].block    = block;
        sd[vertex].sdom     = &sd[vertex];
        sd[vertex].label    = &sd[vertex];
        sd[vertex].parent   = parent? &sd[parent->vertex] : 0;
        sd[vertex].ancestor = 0;
        sd[vertex].vertex   = vertex;
        for(user = block->use; user; user = user->next) {
                vertex = initialize_spdblock(state, sd, block, user->member, vertex);
        }
        return vertex;
}

static int setup_spdblocks(struct compile_state *state, 
        struct basic_blocks *bb, struct sdom_block *sd)
{
        struct block *block;
        int vertex;
        /* Setup as many sdpblocks as possible without using fake edges */
        vertex = initialize_spdblock(state, sd, 0, bb->last_block, 0);

        /* Walk through the graph and find unconnected blocks.  Add a
         * fake edge from the unconnected blocks to the end of the
         * graph. 
         */
        block = bb->first_block->last->next->u.block;
        for(; block && block != bb->first_block; block = block->last->next->u.block) {
                if (sd[block->vertex].block == block) {
                        continue;
                }
#if DEBUG_SDP_BLOCKS
                {
                        FILE *fp = state->errout;
                        fprintf(fp, "Adding %d\n", vertex +1);
                }
#endif
                add_block_edge(block, bb->last_block, 0);
                use_block(bb->last_block, block);

                vertex = initialize_spdblock(state, sd, bb->last_block, block, vertex);
        }
        return vertex;
}

static void compress_ancestors(struct sdom_block *v)
{
        /* This procedure assumes ancestor(v) != 0 */
        /* if (ancestor(ancestor(v)) != 0) {
         *      compress(ancestor(ancestor(v)));
         *      if (semi(label(ancestor(v))) < semi(label(v))) {
         *              label(v) = label(ancestor(v));
         *      }
         *      ancestor(v) = ancestor(ancestor(v));
         * }
         */
        if (!v->ancestor) {
                return;
        }
        if (v->ancestor->ancestor) {
                compress_ancestors(v->ancestor->ancestor);
                if (v->ancestor->label->sdom->vertex < v->label->sdom->vertex) {
                        v->label = v->ancestor->label;
                }
                v->ancestor = v->ancestor->ancestor;
        }
}

static void compute_sdom(struct compile_state *state, 
        struct basic_blocks *bb, struct sdom_block *sd)
{
        int i;
        /* // step 2 
         *  for each v <= pred(w) {
         *      u = EVAL(v);
         *      if (semi[u] < semi[w] { 
         *              semi[w] = semi[u]; 
         *      } 
         * }
         * add w to bucket(vertex(semi[w]));
         * LINK(parent(w), w);
         *
         * // step 3
         * for each v <= bucket(parent(w)) {
         *      delete v from bucket(parent(w));
         *      u = EVAL(v);
         *      dom(v) = (semi[u] < semi[v]) ? u : parent(w);
         * }
         */
        for(i = bb->last_vertex; i >= 2; i--) {
                struct sdom_block *v, *parent, *next;
                struct block_set *user;
                struct block *block;
                block = sd[i].block;
                parent = sd[i].parent;
                /* Step 2 */
                for(user = block->use; user; user = user->next) {
                        struct sdom_block *v, *u;
                        v = &sd[user->member->vertex];
                        u = !(v->ancestor)? v : (compress_ancestors(v), v->label);
                        if (u->sdom->vertex < sd[i].sdom->vertex) {
                                sd[i].sdom = u->sdom;
                        }
                }
                sdom_block(sd[i].sdom, &sd[i]);
                sd[i].ancestor = parent;
                /* Step 3 */
                for(v = parent->sdominates; v; v = next) {
                        struct sdom_block *u;
                        next = v->sdom_next;
                        unsdom_block(v);
                        u = (!v->ancestor) ? v : (compress_ancestors(v), v->label);
                        v->block->idom = (u->sdom->vertex < v->sdom->vertex)? 
                                u->block : parent->block;
                }
        }
}

static void compute_spdom(struct compile_state *state, 
        struct basic_blocks *bb, struct sdom_block *sd)
{
        int i;
        /* // step 2 
         *  for each v <= pred(w) {
         *      u = EVAL(v);
         *      if (semi[u] < semi[w] { 
         *              semi[w] = semi[u]; 
         *      } 
         * }
         * add w to bucket(vertex(semi[w]));
         * LINK(parent(w), w);
         *
         * // step 3
         * for each v <= bucket(parent(w)) {
         *      delete v from bucket(parent(w));
         *      u = EVAL(v);
         *      dom(v) = (semi[u] < semi[v]) ? u : parent(w);
         * }
         */
        for(i = bb->last_vertex; i >= 2; i--) {
                struct sdom_block *u, *v, *parent, *next;
                struct block_set *edge;
                struct block *block;
                block = sd[i].block;
                parent = sd[i].parent;
                /* Step 2 */
                for(edge = block->edges; edge; edge = edge->next) {
                        v = &sd[edge->member->vertex];
                        u = !(v->ancestor)? v : (compress_ancestors(v), v->label);
                        if (u->sdom->vertex < sd[i].sdom->vertex) {
                                sd[i].sdom = u->sdom;
                        }
                }
                sdom_block(sd[i].sdom, &sd[i]);
                sd[i].ancestor = parent;
                /* Step 3 */
                for(v = parent->sdominates; v; v = next) {
                        struct sdom_block *u;
                        next = v->sdom_next;
                        unsdom_block(v);
                        u = (!v->ancestor) ? v : (compress_ancestors(v), v->label);
                        v->block->ipdom = (u->sdom->vertex < v->sdom->vertex)? 
                                u->block : parent->block;
                }
        }
}

static void compute_idom(struct compile_state *state, 
        struct basic_blocks *bb, struct sdom_block *sd)
{
        int i;
        for(i = 2; i <= bb->last_vertex; i++) {
                struct block *block;
                block = sd[i].block;
                if (block->idom->vertex != sd[i].sdom->vertex) {
                        block->idom = block->idom->idom;
                }
                idom_block(block->idom, block);
        }
        sd[1].block->idom = 0;
}

static void compute_ipdom(struct compile_state *state, 
        struct basic_blocks *bb, struct sdom_block *sd)
{
        int i;
        for(i = 2; i <= bb->last_vertex; i++) {
                struct block *block;
                block = sd[i].block;
                if (block->ipdom->vertex != sd[i].sdom->vertex) {
                        block->ipdom = block->ipdom->ipdom;
                }
                ipdom_block(block->ipdom, block);
        }
        sd[1].block->ipdom = 0;
}

        /* Theorem 1:
         *   Every vertex of a flowgraph G = (V, E, r) except r has
         *   a unique immediate dominator.  
         *   The edges {(idom(w), w) |w <= V - {r}} form a directed tree
         *   rooted at r, called the dominator tree of G, such that 
         *   v dominates w if and only if v is a proper ancestor of w in
         *   the dominator tree.
         */
        /* Lemma 1:  
         *   If v and w are vertices of G such that v <= w,
         *   than any path from v to w must contain a common ancestor
         *   of v and w in T.
         */
        /* Lemma 2:  For any vertex w != r, idom(w) -> w */
        /* Lemma 3:  For any vertex w != r, sdom(w) -> w */
        /* Lemma 4:  For any vertex w != r, idom(w) -> sdom(w) */
        /* Theorem 2:
         *   Let w != r.  Suppose every u for which sdom(w) -> u -> w satisfies
         *   sdom(u) >= sdom(w).  Then idom(w) = sdom(w).
         */
        /* Theorem 3:
         *   Let w != r and let u be a vertex for which sdom(u) is 
         *   minimum amoung vertices u satisfying sdom(w) -> u -> w.
         *   Then sdom(u) <= sdom(w) and idom(u) = idom(w).
         */
        /* Lemma 5:  Let vertices v,w satisfy v -> w.
         *           Then v -> idom(w) or idom(w) -> idom(v)
         */

static void find_immediate_dominators(struct compile_state *state,
        struct basic_blocks *bb)
{
        struct sdom_block *sd;
        /* w->sdom = min{v| there is a path v = v0,v1,...,vk = w such that:
         *           vi > w for (1 <= i <= k - 1}
         */
        /* Theorem 4:
         *   For any vertex w != r.
         *   sdom(w) = min(
         *                 {v|(v,w) <= E  and v < w } U 
         *                 {sdom(u) | u > w and there is an edge (v, w) such that u -> v})
         */
        /* Corollary 1:
         *   Let w != r and let u be a vertex for which sdom(u) is 
         *   minimum amoung vertices u satisfying sdom(w) -> u -> w.
         *   Then:
         *                   { sdom(w) if sdom(w) = sdom(u),
         *        idom(w) = {
         *                   { idom(u) otherwise
         */
        /* The algorithm consists of the following 4 steps.
         * Step 1.  Carry out a depth-first search of the problem graph.  
         *    Number the vertices from 1 to N as they are reached during
         *    the search.  Initialize the variables used in succeeding steps.
         * Step 2.  Compute the semidominators of all vertices by applying
         *    theorem 4.   Carry out the computation vertex by vertex in
         *    decreasing order by number.
         * Step 3.  Implicitly define the immediate dominator of each vertex
         *    by applying Corollary 1.
         * Step 4.  Explicitly define the immediate dominator of each vertex,
         *    carrying out the computation vertex by vertex in increasing order
         *    by number.
         */
        /* Step 1 initialize the basic block information */
        sd = xcmalloc(sizeof(*sd) * (bb->last_vertex + 1), "sdom_state");
        initialize_sdblock(sd, 0, bb->first_block, 0);
#if 0
        sd[1].size  = 0;
        sd[1].label = 0;
        sd[1].sdom  = 0;
#endif
        /* Step 2 compute the semidominators */
        /* Step 3 implicitly define the immediate dominator of each vertex */
        compute_sdom(state, bb, sd);
        /* Step 4 explicitly define the immediate dominator of each vertex */
        compute_idom(state, bb, sd);
        xfree(sd);
}

static void find_post_dominators(struct compile_state *state,
        struct basic_blocks *bb)
{
        struct sdom_block *sd;
        int vertex;
        /* Step 1 initialize the basic block information */
        sd = xcmalloc(sizeof(*sd) * (bb->last_vertex + 1), "sdom_state");

        vertex = setup_spdblocks(state, bb, sd);
        if (vertex != bb->last_vertex) {
                internal_error(state, 0, "missing %d blocks",
                        bb->last_vertex - vertex);
        }

        /* Step 2 compute the semidominators */
        /* Step 3 implicitly define the immediate dominator of each vertex */
        compute_spdom(state, bb, sd);
        /* Step 4 explicitly define the immediate dominator of each vertex */
        compute_ipdom(state, bb, sd);
        xfree(sd);
}



static void find_block_domf(struct compile_state *state, struct block *block)
{
        struct block *child;
        struct block_set *user, *edge;
        if (block->domfrontier != 0) {
                internal_error(state, block->first, "domfrontier present?");
        }
        for(user = block->idominates; user; user = user->next) {
                child = user->member;
                if (child->idom != block) {
                        internal_error(state, block->first, "bad idom");
                }
                find_block_domf(state, child);
        }
        for(edge = block->edges; edge; edge = edge->next) {
                if (edge->member->idom != block) {
                        domf_block(block, edge->member);
                }
        }
        for(user = block->idominates; user; user = user->next) {
                struct block_set *frontier;
                child = user->member;
                for(frontier = child->domfrontier; frontier; frontier = frontier->next) {
                        if (frontier->member->idom != block) {
                                domf_block(block, frontier->member);
                        }
                }
        }
}

static void find_block_ipdomf(struct compile_state *state, struct block *block)
{
        struct block *child;
        struct block_set *user;
        if (block->ipdomfrontier != 0) {
                internal_error(state, block->first, "ipdomfrontier present?");
        }
        for(user = block->ipdominates; user; user = user->next) {
                child = user->member;
                if (child->ipdom != block) {
                        internal_error(state, block->first, "bad ipdom");
                }
                find_block_ipdomf(state, child);
        }
        for(user = block->use; user; user = user->next) {
                if (user->member->ipdom != block) {
                        ipdomf_block(block, user->member);
                }
        }
        for(user = block->ipdominates; user; user = user->next) {
                struct block_set *frontier;
                child = user->member;
                for(frontier = child->ipdomfrontier; frontier; frontier = frontier->next) {
                        if (frontier->member->ipdom != block) {
                                ipdomf_block(block, frontier->member);
                        }
                }
        }
}

static void print_dominated(
        struct compile_state *state, struct block *block, void *arg)
{
        struct block_set *user;
        FILE *fp = arg;

        fprintf(fp, "%d:", block->vertex);
        for(user = block->idominates; user; user = user->next) {
                fprintf(fp, " %d", user->member->vertex);
                if (user->member->idom != block) {
                        internal_error(state, user->member->first, "bad idom");
                }
        }
        fprintf(fp,"\n");
}

static void print_dominated2(
        struct compile_state *state, FILE *fp, int depth, struct block *block)
{
        struct block_set *user;
        struct triple *ins;
        struct occurance *ptr, *ptr2;
        const char *filename1, *filename2;
        int equal_filenames;
        int i;
        for(i = 0; i < depth; i++) {
                fprintf(fp, "   ");
        }
        fprintf(fp, "%3d: %p (%p - %p) @", 
                block->vertex, block, block->first, block->last);
        ins = block->first;
        while(ins != block->last && (ins->occurance->line == 0)) {
                ins = ins->next;
        }
        ptr = ins->occurance;
        ptr2 = block->last->occurance;
        filename1 = ptr->filename? ptr->filename : "";
        filename2 = ptr2->filename? ptr2->filename : "";
        equal_filenames = (strcmp(filename1, filename2) == 0);
        if ((ptr == ptr2) || (equal_filenames && ptr->line == ptr2->line)) {
                fprintf(fp, " %s:%d", ptr->filename, ptr->line);
        } else if (equal_filenames) {
                fprintf(fp, " %s:(%d - %d)",
                        ptr->filename, ptr->line, ptr2->line);
        } else {
                fprintf(fp, " (%s:%d - %s:%d)",
                        ptr->filename, ptr->line,
                        ptr2->filename, ptr2->line);
        }
        fprintf(fp, "\n");
        for(user = block->idominates; user; user = user->next) {
                print_dominated2(state, fp, depth + 1, user->member);
        }
}

static void print_dominators(struct compile_state *state, FILE *fp, struct basic_blocks *bb)
{
        fprintf(fp, "\ndominates\n");
        walk_blocks(state, bb, print_dominated, fp);
        fprintf(fp, "dominates\n");
        print_dominated2(state, fp, 0, bb->first_block);
}


static int print_frontiers(
        struct compile_state *state, FILE *fp, struct block *block, int vertex)
{
        struct block_set *user, *edge;

        if (!block || (block->vertex != vertex + 1)) {
                return vertex;
        }
        vertex += 1;

        fprintf(fp, "%d:", block->vertex);
        for(user = block->domfrontier; user; user = user->next) {
                fprintf(fp, " %d", user->member->vertex);
        }
        fprintf(fp, "\n");
        
        for(edge = block->edges; edge; edge = edge->next) {
                vertex = print_frontiers(state, fp, edge->member, vertex);
        }
        return vertex;
}
static void print_dominance_frontiers(struct compile_state *state,
        FILE *fp, struct basic_blocks *bb)
{
        fprintf(fp, "\ndominance frontiers\n");
        print_frontiers(state, fp, bb->first_block, 0);
        
}

static void analyze_idominators(struct compile_state *state, struct basic_blocks *bb)
{
        /* Find the immediate dominators */
        find_immediate_dominators(state, bb);
        /* Find the dominance frontiers */
        find_block_domf(state, bb->first_block);
        /* If debuging print the print what I have just found */
        if (state->compiler->debug & DEBUG_FDOMINATORS) {
                print_dominators(state, state->dbgout, bb);
                print_dominance_frontiers(state, state->dbgout, bb);
                print_control_flow(state, state->dbgout, bb);
        }
}


static void print_ipdominated(
        struct compile_state *state, struct block *block, void *arg)
{
        struct block_set *user;
        FILE *fp = arg;

        fprintf(fp, "%d:", block->vertex);
        for(user = block->ipdominates; user; user = user->next) {
                fprintf(fp, " %d", user->member->vertex);
                if (user->member->ipdom != block) {
                        internal_error(state, user->member->first, "bad ipdom");
                }
        }
        fprintf(fp, "\n");
}

static void print_ipdominators(struct compile_state *state, FILE *fp,
        struct basic_blocks *bb)
{
        fprintf(fp, "\nipdominates\n");
        walk_blocks(state, bb, print_ipdominated, fp);
}

static int print_pfrontiers(
        struct compile_state *state, FILE *fp, struct block *block, int vertex)
{
        struct block_set *user;

        if (!block || (block->vertex != vertex + 1)) {
                return vertex;
        }
        vertex += 1;

        fprintf(fp, "%d:", block->vertex);
        for(user = block->ipdomfrontier; user; user = user->next) {
                fprintf(fp, " %d", user->member->vertex);
        }
        fprintf(fp, "\n");
        for(user = block->use; user; user = user->next) {
                vertex = print_pfrontiers(state, fp, user->member, vertex);
        }
        return vertex;
}
static void print_ipdominance_frontiers(struct compile_state *state,
        FILE *fp, struct basic_blocks *bb)
{
        fprintf(fp, "\nipdominance frontiers\n");
        print_pfrontiers(state, fp, bb->last_block, 0);
        
}

static void analyze_ipdominators(struct compile_state *state,
        struct basic_blocks *bb)
{
        /* Find the post dominators */
        find_post_dominators(state, bb);
        /* Find the control dependencies (post dominance frontiers) */
        find_block_ipdomf(state, bb->last_block);
        /* If debuging print the print what I have just found */
        if (state->compiler->debug & DEBUG_RDOMINATORS) {
                print_ipdominators(state, state->dbgout, bb);
                print_ipdominance_frontiers(state, state->dbgout, bb);
                print_control_flow(state, state->dbgout, bb);
        }
}

static int bdominates(struct compile_state *state,
        struct block *dom, struct block *sub)
{
        while(sub && (sub != dom)) {
                sub = sub->idom;
        }
        return sub == dom;
}

static int tdominates(struct compile_state *state,
        struct triple *dom, struct triple *sub)
{
        struct block *bdom, *bsub;
        int result;
        bdom = block_of_triple(state, dom);
        bsub = block_of_triple(state, sub);
        if (bdom != bsub) {
                result = bdominates(state, bdom, bsub);
        } 
        else {
                struct triple *ins;
                if (!bdom || !bsub) {
                        internal_error(state, dom, "huh?");
                }
                ins = sub;
                while((ins != bsub->first) && (ins != dom)) {
                        ins = ins->prev;
                }
                result = (ins == dom);
        }
        return result;
}

static void analyze_basic_blocks(
        struct compile_state *state, struct basic_blocks *bb)
{
        setup_basic_blocks(state, bb);
        analyze_idominators(state, bb);
        analyze_ipdominators(state, bb);
}

static void insert_phi_operations(struct compile_state *state)
{
        size_t size;
        struct triple *first;
        int *has_already, *work;
        struct block *work_list, **work_list_tail;
        int iter;
        struct triple *var, *vnext;

        size = sizeof(int) * (state->bb.last_vertex + 1);
        has_already = xcmalloc(size, "has_already");
        work =        xcmalloc(size, "work");
        iter = 0;

        first = state->first;
        for(var = first->next; var != first ; var = vnext) {
                struct block *block;
                struct triple_set *user, *unext;
                vnext = var->next;

                if (!triple_is_auto_var(state, var) || !var->use) {
                        continue;
                }
                        
                iter += 1;
                work_list = 0;
                work_list_tail = &work_list;
                for(user = var->use; user; user = unext) {
                        unext = user->next;
                        if (MISC(var, 0) == user->member) {
                                continue;
                        }
                        if (user->member->op == OP_READ) {
                                continue;
                        }
                        if (user->member->op != OP_WRITE) {
                                internal_error(state, user->member, 
                                        "bad variable access");
                        }
                        block = user->member->u.block;
                        if (!block) {
                                warning(state, user->member, "dead code");
                                release_triple(state, user->member);
                                continue;
                        }
                        if (work[block->vertex] >= iter) {
                                continue;
                        }
                        work[block->vertex] = iter;
                        *work_list_tail = block;
                        block->work_next = 0;
                        work_list_tail = &block->work_next;
                }
                for(block = work_list; block; block = block->work_next) {
                        struct block_set *df;
                        for(df = block->domfrontier; df; df = df->next) {
                                struct triple *phi;
                                struct block *front;
                                int in_edges;
                                front = df->member;

                                if (has_already[front->vertex] >= iter) {
                                        continue;
                                }
                                /* Count how many edges flow into this block */
                                in_edges = front->users;
                                /* Insert a phi function for this variable */
                                get_occurance(var->occurance);
                                phi = alloc_triple(
                                        state, OP_PHI, var->type, -1, in_edges, 
                                        var->occurance);
                                phi->u.block = front;
                                MISC(phi, 0) = var;
                                use_triple(var, phi);
#if 1
                                if (phi->rhs != in_edges) {
                                        internal_error(state, phi, "phi->rhs: %d != in_edges: %d",
                                                phi->rhs, in_edges);
                                }
#endif
                                /* Insert the phi functions immediately after the label */
                                insert_triple(state, front->first->next, phi);
                                if (front->first == front->last) {
                                        front->last = front->first->next;
                                }
                                has_already[front->vertex] = iter;
                                transform_to_arch_instruction(state, phi);

                                /* If necessary plan to visit the basic block */
                                if (work[front->vertex] >= iter) {
                                        continue;
                                }
                                work[front->vertex] = iter;
                                *work_list_tail = front;
                                front->work_next = 0;
                                work_list_tail = &front->work_next;
                        }
                }
        }
        xfree(has_already);
        xfree(work);
}


struct stack {
        struct triple_set *top;
        unsigned orig_id;
};

static int count_auto_vars(struct compile_state *state)
{
        struct triple *first, *ins;
        int auto_vars = 0;
        first = state->first;
        ins = first;
        do {
                if (triple_is_auto_var(state, ins)) {
                        auto_vars += 1;
                }
                ins = ins->next;
        } while(ins != first);
        return auto_vars;
}

static void number_auto_vars(struct compile_state *state, struct stack *stacks)
{
        struct triple *first, *ins;
        int auto_vars = 0;
        first = state->first;
        ins = first;
        do {
                if (triple_is_auto_var(state, ins)) {
                        auto_vars += 1;
                        stacks[auto_vars].orig_id = ins->id;
                        ins->id = auto_vars;
                }
                ins = ins->next;
        } while(ins != first);
}

static void restore_auto_vars(struct compile_state *state, struct stack *stacks)
{
        struct triple *first, *ins;
        first = state->first;
        ins = first;
        do {
                if (triple_is_auto_var(state, ins)) {
                        ins->id = stacks[ins->id].orig_id;
                }
                ins = ins->next;
        } while(ins != first);
}

static struct triple *peek_triple(struct stack *stacks, struct triple *var)
{
        struct triple_set *head;
        struct triple *top_val;
        top_val = 0;
        head = stacks[var->id].top;
        if (head) {
                top_val = head->member;
        }
        return top_val;
}

static void push_triple(struct stack *stacks, struct triple *var, struct triple *val)
{
        struct triple_set *new;
        /* Append new to the head of the list,
         * it's the only sensible behavoir for a stack.
         */
        new = xcmalloc(sizeof(*new), "triple_set");
        new->member = val;
        new->next   = stacks[var->id].top;
        stacks[var->id].top = new;
}

static void pop_triple(struct stack *stacks, struct triple *var, struct triple *oldval)
{
        struct triple_set *set, **ptr;
        ptr = &stacks[var->id].top;
        while(*ptr) {
                set = *ptr;
                if (set->member == oldval) {
                        *ptr = set->next;
                        xfree(set);
                        /* Only free one occurance from the stack */
                        return;
                }
                else {
                        ptr = &set->next;
                }
        }
}

/*
 * C(V)
 * S(V)
 */
static void fixup_block_phi_variables(
        struct compile_state *state, struct stack *stacks, struct block *parent, struct block *block)
{
        struct block_set *set;
        struct triple *ptr;
        int edge;
        if (!parent || !block)
                return;
        /* Find the edge I am coming in on */
        edge = 0;
        for(set = block->use; set; set = set->next, edge++) {
                if (set->member == parent) {
                        break;
                }
        }
        if (!set) {
                internal_error(state, 0, "phi input is not on a control predecessor");
        }
        for(ptr = block->first; ; ptr = ptr->next) {
                if (ptr->op == OP_PHI) {
                        struct triple *var, *val, **slot;
                        var = MISC(ptr, 0);
                        if (!var) {
                                internal_error(state, ptr, "no var???");
                        }
                        /* Find the current value of the variable */
                        val = peek_triple(stacks, var);
                        if (val && ((val->op == OP_WRITE) || (val->op == OP_READ))) {
                                internal_error(state, val, "bad value in phi");
                        }
                        if (edge >= ptr->rhs) {
                                internal_error(state, ptr, "edges > phi rhs");
                        }
                        slot = &RHS(ptr, edge);
                        if ((*slot != 0) && (*slot != val)) {
                                internal_error(state, ptr, "phi already bound on this edge");
                        }
                        *slot = val;
                        use_triple(val, ptr);
                }
                if (ptr == block->last) {
                        break;
                }
        }
}


static void rename_block_variables(
        struct compile_state *state, struct stack *stacks, struct block *block)
{
        struct block_set *user, *edge;
        struct triple *ptr, *next, *last;
        int done;
        if (!block)
                return;
        last = block->first;
        done = 0;
        for(ptr = block->first; !done; ptr = next) {
                next = ptr->next;
                if (ptr == block->last) {
                        done = 1;
                }
                /* RHS(A) */
                if (ptr->op == OP_READ) {
                        struct triple *var, *val;
                        var = RHS(ptr, 0);
                        if (!triple_is_auto_var(state, var)) {
                                internal_error(state, ptr, "read of non auto var!");
                        }
                        unuse_triple(var, ptr);
                        /* Find the current value of the variable */
                        val = peek_triple(stacks, var);
                        if (!val) {
                                /* Let the optimizer at variables that are not initially
                                 * set.  But give it a bogus value so things seem to
                                 * work by accident.  This is useful for bitfields because
                                 * setting them always involves a read-modify-write.
                                 */
                                if (TYPE_ARITHMETIC(ptr->type->type)) {
                                        val = pre_triple(state, ptr, OP_INTCONST, ptr->type, 0, 0);
                                        val->u.cval = 0xdeadbeaf;
                                } else {
                                        val = pre_triple(state, ptr, OP_UNKNOWNVAL, ptr->type, 0, 0);
                                }
                        }
                        if (!val) {
                                error(state, ptr, "variable used without being set");
                        }
                        if ((val->op == OP_WRITE) || (val->op == OP_READ)) {
                                internal_error(state, val, "bad value in read");
                        }
                        propogate_use(state, ptr, val);
                        release_triple(state, ptr);
                        continue;
                }
                /* LHS(A) */
                if (ptr->op == OP_WRITE) {
                        struct triple *var, *val, *tval;
                        var = MISC(ptr, 0);
                        if (!triple_is_auto_var(state, var)) {
                                internal_error(state, ptr, "write to non auto var!");
                        }
                        tval = val = RHS(ptr, 0);
                        if ((val->op == OP_WRITE) || (val->op == OP_READ) ||
                                triple_is_auto_var(state, val)) {
                                internal_error(state, ptr, "bad value in write");
                        }
                        /* Insert a cast if the types differ */
                        if (!is_subset_type(ptr->type, val->type)) {
                                if (val->op == OP_INTCONST) {
                                        tval = pre_triple(state, ptr, OP_INTCONST, ptr->type, 0, 0);
                                        tval->u.cval = val->u.cval;
                                }
                                else {
                                        tval = pre_triple(state, ptr, OP_CONVERT, ptr->type, val, 0);
                                        use_triple(val, tval);
                                }
                                transform_to_arch_instruction(state, tval);
                                unuse_triple(val, ptr);
                                RHS(ptr, 0) = tval;
                                use_triple(tval, ptr);
                        }
                        propogate_use(state, ptr, tval);
                        unuse_triple(var, ptr);
                        /* Push OP_WRITE ptr->right onto a stack of variable uses */
                        push_triple(stacks, var, tval);
                }
                if (ptr->op == OP_PHI) {
                        struct triple *var;
                        var = MISC(ptr, 0);
                        if (!triple_is_auto_var(state, var)) {
                                internal_error(state, ptr, "phi references non auto var!");
                        }
                        /* Push OP_PHI onto a stack of variable uses */
                        push_triple(stacks, var, ptr);
                }
                last = ptr;
        }
        block->last = last;

        /* Fixup PHI functions in the cf successors */
        for(edge = block->edges; edge; edge = edge->next) {
                fixup_block_phi_variables(state, stacks, block, edge->member);
        }
        /* rename variables in the dominated nodes */
        for(user = block->idominates; user; user = user->next) {
                rename_block_variables(state, stacks, user->member);
        }
        /* pop the renamed variable stack */
        last = block->first;
        done = 0;
        for(ptr = block->first; !done ; ptr = next) {
                next = ptr->next;
                if (ptr == block->last) {
                        done = 1;
                }
                if (ptr->op == OP_WRITE) {
                        struct triple *var;
                        var = MISC(ptr, 0);
                        /* Pop OP_WRITE ptr->right from the stack of variable uses */
                        pop_triple(stacks, var, RHS(ptr, 0));
                        release_triple(state, ptr);
                        continue;
                }
                if (ptr->op == OP_PHI) {
                        struct triple *var;
                        var = MISC(ptr, 0);
                        /* Pop OP_WRITE ptr->right from the stack of variable uses */
                        pop_triple(stacks, var, ptr);
                }
                last = ptr;
        }
        block->last = last;
}

static void rename_variables(struct compile_state *state)
{
        struct stack *stacks;
        int auto_vars;

        /* Allocate stacks for the Variables */
        auto_vars = count_auto_vars(state);
        stacks = xcmalloc(sizeof(stacks[0])*(auto_vars + 1), "auto var stacks");

        /* Give each auto_var a stack */
        number_auto_vars(state, stacks);

        /* Rename the variables */
        rename_block_variables(state, stacks, state->bb.first_block);

        /* Remove the stacks from the auto_vars */
        restore_auto_vars(state, stacks);
        xfree(stacks);
}

static void prune_block_variables(struct compile_state *state,
        struct block *block)
{
        struct block_set *user;
        struct triple *next, *ptr;
        int done;

        done = 0;
        for(ptr = block->first; !done; ptr = next) {
                /* Be extremely careful I am deleting the list
                 * as I walk trhough it.
                 */
                next = ptr->next;
                if (ptr == block->last) {
                        done = 1;
                }
                if (triple_is_auto_var(state, ptr)) {
                        struct triple_set *user, *next;
                        for(user = ptr->use; user; user = next) {
                                struct triple *use;
                                next = user->next;
                                use = user->member;
                                if (MISC(ptr, 0) == user->member) {
                                        continue;
                                }
                                if (use->op != OP_PHI) {
                                        internal_error(state, use, "decl still used");
                                }
                                if (MISC(use, 0) != ptr) {
                                        internal_error(state, use, "bad phi use of decl");
                                }
                                unuse_triple(ptr, use);
                                MISC(use, 0) = 0;
                        }
                        if ((ptr->u.cval == 0) && (MISC(ptr, 0)->lhs == 1)) {
                                /* Delete the adecl */
                                release_triple(state, MISC(ptr, 0));
                                /* And the piece */
                                release_triple(state, ptr);
                        }
                        continue;
                }
        }
        for(user = block->idominates; user; user = user->next) {
                prune_block_variables(state, user->member);
        }
}

struct phi_triple {
        struct triple *phi;
        unsigned orig_id;
        int alive;
};

static void keep_phi(struct compile_state *state, struct phi_triple *live, struct triple *phi)
{
        struct triple **slot;
        int zrhs, i;
        if (live[phi->id].alive) {
                return;
        }
        live[phi->id].alive = 1;
        zrhs = phi->rhs;
        slot = &RHS(phi, 0);
        for(i = 0; i < zrhs; i++) {
                struct triple *used;
                used = slot[i];
                if (used && (used->op == OP_PHI)) {
                        keep_phi(state, live, used);
                }
        }
}

static void prune_unused_phis(struct compile_state *state)
{
        struct triple *first, *phi;
        struct phi_triple *live;
        int phis, i;
        
        /* Find the first instruction */
        first = state->first;

        /* Count how many phi functions I need to process */
        phis = 0;
        for(phi = first->next; phi != first; phi = phi->next) {
                if (phi->op == OP_PHI) {
                        phis += 1;
                }
        }
        
        /* Mark them all dead */
        live = xcmalloc(sizeof(*live) * (phis + 1), "phi_triple");
        phis = 0;
        for(phi = first->next; phi != first; phi = phi->next) {
                if (phi->op != OP_PHI) {
                        continue;
                }
                live[phis].alive   = 0;
                live[phis].orig_id = phi->id;
                live[phis].phi     = phi;
                phi->id = phis;
                phis += 1;
        }
        
        /* Mark phis alive that are used by non phis */
        for(i = 0; i < phis; i++) {
                struct triple_set *set;
                for(set = live[i].phi->use; !live[i].alive && set; set = set->next) {
                        if (set->member->op != OP_PHI) {
                                keep_phi(state, live, live[i].phi);
                                break;
                        }
                }
        }

        /* Delete the extraneous phis */
        for(i = 0; i < phis; i++) {
                struct triple **slot;
                int zrhs, j;
                if (!live[i].alive) {
                        release_triple(state, live[i].phi);
                        continue;
                }
                phi = live[i].phi;
                slot = &RHS(phi, 0);
                zrhs = phi->rhs;
                for(j = 0; j < zrhs; j++) {
                        if(!slot[j]) {
                                struct triple *unknown;
                                get_occurance(phi->occurance);
                                unknown = flatten(state, state->global_pool,
                                        alloc_triple(state, OP_UNKNOWNVAL,
                                                phi->type, 0, 0, phi->occurance));
                                slot[j] = unknown;
                                use_triple(unknown, phi);
                                transform_to_arch_instruction(state, unknown);
#if 0                           
                                warning(state, phi, "variable not set at index %d on all paths to use", j);
#endif
                        }
                }
        }
        xfree(live);
}

static void transform_to_ssa_form(struct compile_state *state)
{
        insert_phi_operations(state);
        rename_variables(state);

        prune_block_variables(state, state->bb.first_block);
        prune_unused_phis(state);

        print_blocks(state, __func__, state->dbgout);
}


static void clear_vertex(
        struct compile_state *state, struct block *block, void *arg)
{
        /* Clear the current blocks vertex and the vertex of all
         * of the current blocks neighbors in case there are malformed
         * blocks with now instructions at this point.
         */
        struct block_set *user, *edge;
        block->vertex = 0;
        for(edge = block->edges; edge; edge = edge->next) {
                edge->member->vertex = 0;
        }
        for(user = block->use; user; user = user->next) {
                user->member->vertex = 0;
        }
}

static void mark_live_block(
        struct compile_state *state, struct block *block, int *next_vertex)
{
        /* See if this is a block that has not been marked */
        if (block->vertex != 0) {
                return;
        }
        block->vertex = *next_vertex;
        *next_vertex += 1;
        if (triple_is_branch(state, block->last)) {
                struct triple **targ;
                targ = triple_edge_targ(state, block->last, 0);
                for(; targ; targ = triple_edge_targ(state, block->last, targ)) {
                        if (!*targ) {
                                continue;
                        }
                        if (!triple_stores_block(state, *targ)) {
                                internal_error(state, 0, "bad targ");
                        }
                        mark_live_block(state, (*targ)->u.block, next_vertex);
                }
                /* Ensure the last block of a function remains alive */
                if (triple_is_call(state, block->last)) {
                        mark_live_block(state, MISC(block->last, 0)->u.block, next_vertex);
                }
        }
        else if (block->last->next != state->first) {
                struct triple *ins;
                ins = block->last->next;
                if (!triple_stores_block(state, ins)) {
                        internal_error(state, 0, "bad block start");
                }
                mark_live_block(state, ins->u.block, next_vertex);
        }
}

static void transform_from_ssa_form(struct compile_state *state)
{
        /* To get out of ssa form we insert moves on the incoming
         * edges to blocks containting phi functions.
         */
        struct triple *first;
        struct triple *phi, *var, *next;
        int next_vertex;

        /* Walk the control flow to see which blocks remain alive */
        walk_blocks(state, &state->bb, clear_vertex, 0);
        next_vertex = 1;
        mark_live_block(state, state->bb.first_block, &next_vertex);

        /* Walk all of the operations to find the phi functions */
        first = state->first;
        for(phi = first->next; phi != first ; phi = next) {
                struct block_set *set;
                struct block *block;
                struct triple **slot;
                struct triple *var;
                struct triple_set *use, *use_next;
                int edge, writers, readers;
                next = phi->next;
                if (phi->op != OP_PHI) {
                        continue;
                }

                block = phi->u.block;
                slot  = &RHS(phi, 0);

                /* If this phi is in a dead block just forget it */
                if (block->vertex == 0) {
                        release_triple(state, phi);
                        continue;
                }

                /* Forget uses from code in dead blocks */
                for(use = phi->use; use; use = use_next) {
                        struct block *ublock;
                        struct triple **expr;
                        use_next = use->next;
                        ublock = block_of_triple(state, use->member);
                        if ((use->member == phi) || (ublock->vertex != 0)) {
                                continue;
                        }
                        expr = triple_rhs(state, use->member, 0);
                        for(; expr; expr = triple_rhs(state, use->member, expr)) {
                                if (*expr == phi) {
                                        *expr = 0;
                                }
                        }
                        unuse_triple(phi, use->member);
                }
                /* A variable to replace the phi function */
                if (registers_of(state, phi->type) != 1) {
                        internal_error(state, phi, "phi->type does not fit in a single register!");
                }
                var = post_triple(state, phi, OP_ADECL, phi->type, 0, 0);
                var = var->next; /* point at the var */
                        
                /* Replaces use of phi with var */
                propogate_use(state, phi, var);

                /* Count the readers */
                readers = 0;
                for(use = var->use; use; use = use->next) {
                        if (use->member != MISC(var, 0)) {
                                readers++;
                        }
                }

                /* Walk all of the incoming edges/blocks and insert moves.
                 */
                writers = 0;
                for(edge = 0, set = block->use; set; set = set->next, edge++) {
                        struct block *eblock, *vblock;
                        struct triple *move;
                        struct triple *val, *base;
                        eblock = set->member;
                        val = slot[edge];
                        slot[edge] = 0;
                        unuse_triple(val, phi);
                        vblock = block_of_triple(state, val);

                        /* If we don't have a value that belongs in an OP_WRITE
                         * continue on.
                         */
                        if (!val || (val == &unknown_triple) || (val == phi)
                                || (vblock && (vblock->vertex == 0))) {
                                continue;
                        }
                        /* If the value should never occur error */
                        if (!vblock) {
                                internal_error(state, val, "no vblock?");
                                continue;
                        }

                        /* If the value occurs in a dead block see if a replacement
                         * block can be found.
                         */
                        while(eblock && (eblock->vertex == 0)) {
                                eblock = eblock->idom;
                        }
                        /* If not continue on with the next value. */
                        if (!eblock || (eblock->vertex == 0)) {
                                continue;
                        }

                        /* If we have an empty incoming block ignore it. */
                        if (!eblock->first) {
                                internal_error(state, 0, "empty block?");
                        }
                        
                        /* Make certain the write is placed in the edge block... */
                        /* Walk through the edge block backwards to find an
                         * appropriate location for the OP_WRITE.
                         */
                        for(base = eblock->last; base != eblock->first; base = base->prev) {
                                struct triple **expr;
                                if (base->op == OP_PIECE) {
                                        base = MISC(base, 0);
                                }
                                if ((base == var) || (base == val)) {
                                        goto out;
                                }
                                expr = triple_lhs(state, base, 0);
                                for(; expr; expr = triple_lhs(state, base, expr)) {
                                        if ((*expr) == val) {
                                                goto out;
                                        }
                                }
                                expr = triple_rhs(state, base, 0);
                                for(; expr; expr = triple_rhs(state, base, expr)) {
                                        if ((*expr) == var) {
                                                goto out;
                                        }
                                }
                        }
                out:
                        if (triple_is_branch(state, base)) {
                                internal_error(state, base,
                                        "Could not insert write to phi");
                        }
                        move = post_triple(state, base, OP_WRITE, var->type, val, var);
                        use_triple(val, move);
                        use_triple(var, move);
                        writers++;
                }
                if (!writers && readers) {
                        internal_error(state, var, "no value written to in use phi?");
                }
                /* If var is not used free it */
                if (!writers) {
                        release_triple(state, MISC(var, 0));
                        release_triple(state, var);
                }
                /* Release the phi function */
                release_triple(state, phi);
        }
        
        /* Walk all of the operations to find the adecls */
        for(var = first->next; var != first ; var = var->next) {
                struct triple_set *use, *use_next;
                if (!triple_is_auto_var(state, var)) {
                        continue;
                }

                /* Walk through all of the rhs uses of var and
                 * replace them with read of var.
                 */
                for(use = var->use; use; use = use_next) {
                        struct triple *read, *user;
                        struct triple **slot;
                        int zrhs, i, used;
                        use_next = use->next;
                        user = use->member;
                        
                        /* Generate a read of var */
                        read = pre_triple(state, user, OP_READ, var->type, var, 0);
                        use_triple(var, read);

                        /* Find the rhs uses and see if they need to be replaced */
                        used = 0;
                        zrhs = user->rhs;
                        slot = &RHS(user, 0);
                        for(i = 0; i < zrhs; i++) {
                                if (slot[i] == var) {
                                        slot[i] = read;
                                        used = 1;
                                }
                        }
                        /* If we did use it cleanup the uses */
                        if (used) {
                                unuse_triple(var, user);
                                use_triple(read, user);
                        } 
                        /* If we didn't use it release the extra triple */
                        else {
                                release_triple(state, read);
                        }
                }
        }
}

#define HI() if (state->compiler->debug & DEBUG_REBUILD_SSA_FORM) { \
        FILE *fp = state->dbgout; \
        fprintf(fp, "@ %s:%d\n", __FILE__, __LINE__); romcc_print_blocks(state, fp); \
        } 

static void rebuild_ssa_form(struct compile_state *state)
{
HI();
        transform_from_ssa_form(state);
HI();
        state->bb.first = state->first;
        free_basic_blocks(state, &state->bb);
        analyze_basic_blocks(state, &state->bb);
HI();
        insert_phi_operations(state);
HI();
        rename_variables(state);
HI();
        
        prune_block_variables(state, state->bb.first_block);
HI();
        prune_unused_phis(state);
HI();
}
#undef HI

/* 
 * Register conflict resolution
 * =========================================================
 */

static struct reg_info find_def_color(
        struct compile_state *state, struct triple *def)
{
        struct triple_set *set;
        struct reg_info info;
        info.reg = REG_UNSET;
        info.regcm = 0;
        if (!triple_is_def(state, def)) {
                return info;
        }
        info = arch_reg_lhs(state, def, 0);
        if (info.reg >= MAX_REGISTERS) {
                info.reg = REG_UNSET;
        }
        for(set = def->use; set; set = set->next) {
                struct reg_info tinfo;
                int i;
                i = find_rhs_use(state, set->member, def);
                if (i < 0) {
                        continue;
                }
                tinfo = arch_reg_rhs(state, set->member, i);
                if (tinfo.reg >= MAX_REGISTERS) {
                        tinfo.reg = REG_UNSET;
                }
                if ((tinfo.reg != REG_UNSET) && 
                        (info.reg != REG_UNSET) &&
                        (tinfo.reg != info.reg)) {
                        internal_error(state, def, "register conflict");
                }
                if ((info.regcm & tinfo.regcm) == 0) {
                        internal_error(state, def, "regcm conflict %x & %x == 0",
                                info.regcm, tinfo.regcm);
                }
                if (info.reg == REG_UNSET) {
                        info.reg = tinfo.reg;
                }
                info.regcm &= tinfo.regcm;
        }
        if (info.reg >= MAX_REGISTERS) {
                internal_error(state, def, "register out of range");
        }
        return info;
}

static struct reg_info find_lhs_pre_color(
        struct compile_state *state, struct triple *ins, int index)
{
        struct reg_info info;
        int zlhs, zrhs, i;
        zrhs = ins->rhs;
        zlhs = ins->lhs;
        if (!zlhs && triple_is_def(state, ins)) {
                zlhs = 1;
        }
        if (index >= zlhs) {
                internal_error(state, ins, "Bad lhs %d", index);
        }
        info = arch_reg_lhs(state, ins, index);
        for(i = 0; i < zrhs; i++) {
                struct reg_info rinfo;
                rinfo = arch_reg_rhs(state, ins, i);
                if ((info.reg == rinfo.reg) &&
                        (rinfo.reg >= MAX_REGISTERS)) {
                        struct reg_info tinfo;
                        tinfo = find_lhs_pre_color(state, RHS(ins, index), 0);
                        info.reg = tinfo.reg;
                        info.regcm &= tinfo.regcm;
                        break;
                }
        }
        if (info.reg >= MAX_REGISTERS) {
                info.reg = REG_UNSET;
        }
        return info;
}

static struct reg_info find_rhs_post_color(
        struct compile_state *state, struct triple *ins, int index);

static struct reg_info find_lhs_post_color(
        struct compile_state *state, struct triple *ins, int index)
{
        struct triple_set *set;
        struct reg_info info;
        struct triple *lhs;
#if DEBUG_TRIPLE_COLOR
        fprintf(state->errout, "find_lhs_post_color(%p, %d)\n",
                ins, index);
#endif
        if ((index == 0) && triple_is_def(state, ins)) {
                lhs = ins;
        }
        else if (index < ins->lhs) {
                lhs = LHS(ins, index);
        }
        else {
                internal_error(state, ins, "Bad lhs %d", index);
                lhs = 0;
        }
        info = arch_reg_lhs(state, ins, index);
        if (info.reg >= MAX_REGISTERS) {
                info.reg = REG_UNSET;
        }
        for(set = lhs->use; set; set = set->next) {
                struct reg_info rinfo;
                struct triple *user;
                int zrhs, i;
                user = set->member;
                zrhs = user->rhs;
                for(i = 0; i < zrhs; i++) {
                        if (RHS(user, i) != lhs) {
                                continue;
                        }
                        rinfo = find_rhs_post_color(state, user, i);
                        if ((info.reg != REG_UNSET) &&
                                (rinfo.reg != REG_UNSET) &&
                                (info.reg != rinfo.reg)) {
                                internal_error(state, ins, "register conflict");
                        }
                        if ((info.regcm & rinfo.regcm) == 0) {
                                internal_error(state, ins, "regcm conflict %x & %x == 0",
                                        info.regcm, rinfo.regcm);
                        }
                        if (info.reg == REG_UNSET) {
                                info.reg = rinfo.reg;
                        }
                        info.regcm &= rinfo.regcm;
                }
        }
#if DEBUG_TRIPLE_COLOR
        fprintf(state->errout, "find_lhs_post_color(%p, %d) -> ( %d, %x)\n",
                ins, index, info.reg, info.regcm);
#endif
        return info;
}

static struct reg_info find_rhs_post_color(
        struct compile_state *state, struct triple *ins, int index)
{
        struct reg_info info, rinfo;
        int zlhs, i;
#if DEBUG_TRIPLE_COLOR
        fprintf(state->errout, "find_rhs_post_color(%p, %d)\n",
                ins, index);
#endif
        rinfo = arch_reg_rhs(state, ins, index);
        zlhs = ins->lhs;
        if (!zlhs && triple_is_def(state, ins)) {
                zlhs = 1;
        }
        info = rinfo;
        if (info.reg >= MAX_REGISTERS) {
                info.reg = REG_UNSET;
        }
        for(i = 0; i < zlhs; i++) {
                struct reg_info linfo;
                linfo = arch_reg_lhs(state, ins, i);
                if ((linfo.reg == rinfo.reg) &&
                        (linfo.reg >= MAX_REGISTERS)) {
                        struct reg_info tinfo;
                        tinfo = find_lhs_post_color(state, ins, i);
                        if (tinfo.reg >= MAX_REGISTERS) {
                                tinfo.reg = REG_UNSET;
                        }
                        info.regcm &= linfo.regcm;
                        info.regcm &= tinfo.regcm;
                        if (info.reg != REG_UNSET) {
                                internal_error(state, ins, "register conflict");
                        }
                        if (info.regcm == 0) {
                                internal_error(state, ins, "regcm conflict");
                        }
                        info.reg = tinfo.reg;
                }
        }
#if DEBUG_TRIPLE_COLOR
        fprintf(state->errout, "find_rhs_post_color(%p, %d) -> ( %d, %x)\n",
                ins, index, info.reg, info.regcm);
#endif
        return info;
}

static struct reg_info find_lhs_color(
        struct compile_state *state, struct triple *ins, int index)
{
        struct reg_info pre, post, info;
#if DEBUG_TRIPLE_COLOR
        fprintf(state->errout, "find_lhs_color(%p, %d)\n",
                ins, index);
#endif
        pre = find_lhs_pre_color(state, ins, index);
        post = find_lhs_post_color(state, ins, index);
        if ((pre.reg != post.reg) &&
                (pre.reg != REG_UNSET) &&
                (post.reg != REG_UNSET)) {
                internal_error(state, ins, "register conflict");
        }
        info.regcm = pre.regcm & post.regcm;
        info.reg = pre.reg;
        if (info.reg == REG_UNSET) {
                info.reg = post.reg;
        }
#if DEBUG_TRIPLE_COLOR
        fprintf(state->errout, "find_lhs_color(%p, %d) -> ( %d, %x) ... (%d, %x) (%d, %x)\n",
                ins, index, info.reg, info.regcm,
                pre.reg, pre.regcm, post.reg, post.regcm);
#endif
        return info;
}

static struct triple *post_copy(struct compile_state *state, struct triple *ins)
{
        struct triple_set *entry, *next;
        struct triple *out;
        struct reg_info info, rinfo;

        info = arch_reg_lhs(state, ins, 0);
        out = post_triple(state, ins, OP_COPY, ins->type, ins, 0);
        use_triple(RHS(out, 0), out);
        /* Get the users of ins to use out instead */
        for(entry = ins->use; entry; entry = next) {
                int i;
                next = entry->next;
                if (entry->member == out) {
                        continue;
                }
                i = find_rhs_use(state, entry->member, ins);
                if (i < 0) {
                        continue;
                }
                rinfo = arch_reg_rhs(state, entry->member, i);
                if ((info.reg == REG_UNNEEDED) && (rinfo.reg == REG_UNNEEDED)) {
                        continue;
                }
                replace_rhs_use(state, ins, out, entry->member);
        }
        transform_to_arch_instruction(state, out);
        return out;
}

static struct triple *typed_pre_copy(
        struct compile_state *state, struct type *type, struct triple *ins, int index)
{
        /* Carefully insert enough operations so that I can
         * enter any operation with a GPR32.
         */
        struct triple *in;
        struct triple **expr;
        unsigned classes;
        struct reg_info info;
        int op;
        if (ins->op == OP_PHI) {
                internal_error(state, ins, "pre_copy on a phi?");
        }
        classes = arch_type_to_regcm(state, type);
        info = arch_reg_rhs(state, ins, index);
        expr = &RHS(ins, index);
        if ((info.regcm & classes) == 0) {
                FILE *fp = state->errout;
                fprintf(fp, "src_type: ");
                name_of(fp, ins->type);
                fprintf(fp, "\ndst_type: ");
                name_of(fp, type);
                fprintf(fp, "\n");
                internal_error(state, ins, "pre_copy with no register classes");
        }
        op = OP_COPY;
        if (!equiv_types(type, (*expr)->type)) {
                op = OP_CONVERT;
        }
        in = pre_triple(state, ins, op, type, *expr, 0);
        unuse_triple(*expr, ins);
        *expr = in;
        use_triple(RHS(in, 0), in);
        use_triple(in, ins);
        transform_to_arch_instruction(state, in);
        return in;
        
}
static struct triple *pre_copy(
        struct compile_state *state, struct triple *ins, int index)
{
        return typed_pre_copy(state, RHS(ins, index)->type, ins, index);
}


static void insert_copies_to_phi(struct compile_state *state)
{
        /* To get out of ssa form we insert moves on the incoming
         * edges to blocks containting phi functions.
         */
        struct triple *first;
        struct triple *phi;

        /* Walk all of the operations to find the phi functions */
        first = state->first;
        for(phi = first->next; phi != first ; phi = phi->next) {
                struct block_set *set;
                struct block *block;
                struct triple **slot, *copy;
                int edge;
                if (phi->op != OP_PHI) {
                        continue;
                }
                phi->id |= TRIPLE_FLAG_POST_SPLIT;
                block = phi->u.block;
                slot  = &RHS(phi, 0);
                /* Phi's that feed into mandatory live range joins
                 * cause nasty complications.  Insert a copy of
                 * the phi value so I never have to deal with
                 * that in the rest of the code.
                 */
                copy = post_copy(state, phi);
                copy->id |= TRIPLE_FLAG_PRE_SPLIT;
                /* Walk all of the incoming edges/blocks and insert moves.
                 */
                for(edge = 0, set = block->use; set; set = set->next, edge++) {
                        struct block *eblock;
                        struct triple *move;
                        struct triple *val;
                        struct triple *ptr;
                        eblock = set->member;
                        val = slot[edge];

                        if (val == phi) {
                                continue;
                        }

                        get_occurance(val->occurance);
                        move = build_triple(state, OP_COPY, val->type, val, 0,
                                val->occurance);
                        move->u.block = eblock;
                        move->id |= TRIPLE_FLAG_PRE_SPLIT;
                        use_triple(val, move);
                        
                        slot[edge] = move;
                        unuse_triple(val, phi);
                        use_triple(move, phi);

                        /* Walk up the dominator tree until I have found the appropriate block */
                        while(eblock && !tdominates(state, val, eblock->last)) {
                                eblock = eblock->idom;
                        }
                        if (!eblock) {
                                internal_error(state, phi, "Cannot find block dominated by %p",
                                        val);
                        }

                        /* Walk through the block backwards to find
                         * an appropriate location for the OP_COPY.
                         */
                        for(ptr = eblock->last; ptr != eblock->first; ptr = ptr->prev) {
                                struct triple **expr;
                                if (ptr->op == OP_PIECE) {
                                        ptr = MISC(ptr, 0);
                                }
                                if ((ptr == phi) || (ptr == val)) {
                                        goto out;
                                }
                                expr = triple_lhs(state, ptr, 0);
                                for(;expr; expr = triple_lhs(state, ptr, expr)) {
                                        if ((*expr) == val) {
                                                goto out;
                                        }
                                }
                                expr = triple_rhs(state, ptr, 0);
                                for(;expr; expr = triple_rhs(state, ptr, expr)) {
                                        if ((*expr) == phi) {
                                                goto out;
                                        }
                                }
                        }
                out:
                        if (triple_is_branch(state, ptr)) {
                                internal_error(state, ptr,
                                        "Could not insert write to phi");
                        }
                        insert_triple(state, after_lhs(state, ptr), move);
                        if (eblock->last == after_lhs(state, ptr)->prev) {
                                eblock->last = move;
                        }
                        transform_to_arch_instruction(state, move);
                }
        }
        print_blocks(state, __func__, state->dbgout);
}

struct triple_reg_set;
struct reg_block;


static int do_triple_set(struct triple_reg_set **head, 
        struct triple *member, struct triple *new_member)
{
        struct triple_reg_set **ptr, *new;
        if (!member)
                return 0;
        ptr = head;
        while(*ptr) {
                if ((*ptr)->member == member) {
                        return 0;
                }
                ptr = &(*ptr)->next;
        }
        new = xcmalloc(sizeof(*new), "triple_set");
        new->member = member;
        new->new    = new_member;
        new->next   = *head;
        *head       = new;
        return 1;
}

static void do_triple_unset(struct triple_reg_set **head, struct triple *member)
{
        struct triple_reg_set *entry, **ptr;
        ptr = head;
        while(*ptr) {
                entry = *ptr;
                if (entry->member == member) {
                        *ptr = entry->next;
                        xfree(entry);
                        return;
                }
                else {
                        ptr = &entry->next;
                }
        }
}

static int in_triple(struct reg_block *rb, struct triple *in)
{
        return do_triple_set(&rb->in, in, 0);
}
static void unin_triple(struct reg_block *rb, struct triple *unin)
{
        do_triple_unset(&rb->in, unin);
}

static int out_triple(struct reg_block *rb, struct triple *out)
{
        return do_triple_set(&rb->out, out, 0);
}
static void unout_triple(struct reg_block *rb, struct triple *unout)
{
        do_triple_unset(&rb->out, unout);
}

static int initialize_regblock(struct reg_block *blocks,
        struct block *block, int vertex)
{
        struct block_set *user;
        if (!block || (blocks[block->vertex].block == block)) {
                return vertex;
        }
        vertex += 1;
        /* Renumber the blocks in a convinient fashion */
        block->vertex = vertex;
        blocks[vertex].block    = block;
        blocks[vertex].vertex   = vertex;
        for(user = block->use; user; user = user->next) {
                vertex = initialize_regblock(blocks, user->member, vertex);
        }
        return vertex;
}

static struct triple *part_to_piece(struct compile_state *state, struct triple *ins)
{
/* Part to piece is a best attempt and it cannot be correct all by
 * itself.  If various values are read as different sizes in different
 * parts of the code this function cannot work.  Or rather it cannot
 * work in conjunction with compute_variable_liftimes.  As the
 * analysis will get confused.
 */
        struct triple *base;
        unsigned reg;
        if (!is_lvalue(state, ins)) {
                return ins;
        }
        base = 0;
        reg = 0;
        while(ins && triple_is_part(state, ins) && (ins->op != OP_PIECE)) {
                base = MISC(ins, 0);
                switch(ins->op) {
                case OP_INDEX:
                        reg += index_reg_offset(state, base->type, ins->u.cval)/REG_SIZEOF_REG;
                        break;
                case OP_DOT:
                        reg += field_reg_offset(state, base->type, ins->u.field)/REG_SIZEOF_REG;
                        break;
                default:
                        internal_error(state, ins, "unhandled part");
                        break;
                }
                ins = base;
        }
        if (base) {
                if (reg > base->lhs) {
                        internal_error(state, base, "part out of range?");
                }
                ins = LHS(base, reg);
        }
        return ins;
}

static int this_def(struct compile_state *state, 
        struct triple *ins, struct triple *other)
{
        if (ins == other) {
                return 1;
        }
        if (ins->op == OP_WRITE) {
                ins = part_to_piece(state, MISC(ins, 0));
        }
        return ins == other;
}

static int phi_in(struct compile_state *state, struct reg_block *blocks,
        struct reg_block *rb, struct block *suc)
{
        /* Read the conditional input set of a successor block
         * (i.e. the input to the phi nodes) and place it in the
         * current blocks output set.
         */
        struct block_set *set;
        struct triple *ptr;
        int edge;
        int done, change;
        change = 0;
        /* Find the edge I am coming in on */
        for(edge = 0, set = suc->use; set; set = set->next, edge++) {
                if (set->member == rb->block) {
                        break;
                }
        }
        if (!set) {
                internal_error(state, 0, "Not coming on a control edge?");
        }
        for(done = 0, ptr = suc->first; !done; ptr = ptr->next) {
                struct triple **slot, *expr, *ptr2;
                int out_change, done2;
                done = (ptr == suc->last);
                if (ptr->op != OP_PHI) {
                        continue;
                }
                slot = &RHS(ptr, 0);
                expr = slot[edge];
                out_change = out_triple(rb, expr);
                if (!out_change) {
                        continue;
                }
                /* If we don't define the variable also plast it
                 * in the current blocks input set.
                 */
                ptr2 = rb->block->first;
                for(done2 = 0; !done2; ptr2 = ptr2->next) {
                        if (this_def(state, ptr2, expr)) {
                                break;
                        }
                        done2 = (ptr2 == rb->block->last);
                }
                if (!done2) {
                        continue;
                }
                change |= in_triple(rb, expr);
        }
        return change;
}

static int reg_in(struct compile_state *state, struct reg_block *blocks,
        struct reg_block *rb, struct block *suc)
{
        struct triple_reg_set *in_set;
        int change;
        change = 0;
        /* Read the input set of a successor block
         * and place it in the current blocks output set.
         */
        in_set = blocks[suc->vertex].in;
        for(; in_set; in_set = in_set->next) {
                int out_change, done;
                struct triple *first, *last, *ptr;
                out_change = out_triple(rb, in_set->member);
                if (!out_change) {
                        continue;
                }
                /* If we don't define the variable also place it
                 * in the current blocks input set.
                 */
                first = rb->block->first;
                last = rb->block->last;
                done = 0;
                for(ptr = first; !done; ptr = ptr->next) {
                        if (this_def(state, ptr, in_set->member)) {
                                break;
                        }
                        done = (ptr == last);
                }
                if (!done) {
                        continue;
                }
                change |= in_triple(rb, in_set->member);
        }
        change |= phi_in(state, blocks, rb, suc);
        return change;
}

static int use_in(struct compile_state *state, struct reg_block *rb)
{
        /* Find the variables we use but don't define and add
         * it to the current blocks input set.
         */
#warning "FIXME is this O(N^2) algorithm bad?"
        struct block *block;
        struct triple *ptr;
        int done;
        int change;
        block = rb->block;
        change = 0;
        for(done = 0, ptr = block->last; !done; ptr = ptr->prev) {
                struct triple **expr;
                done = (ptr == block->first);
                /* The variable a phi function uses depends on the
                 * control flow, and is handled in phi_in, not
                 * here.
                 */
                if (ptr->op == OP_PHI) {
                        continue;
                }
                expr = triple_rhs(state, ptr, 0);
                for(;expr; expr = triple_rhs(state, ptr, expr)) {
                        struct triple *rhs, *test;
                        int tdone;
                        rhs = part_to_piece(state, *expr);
                        if (!rhs) {
                                continue;
                        }

                        /* See if rhs is defined in this block.
                         * A write counts as a definition.
                         */
                        for(tdone = 0, test = ptr; !tdone; test = test->prev) {
                                tdone = (test == block->first);
                                if (this_def(state, test, rhs)) {
                                        rhs = 0;
                                        break;
                                }
                        }
                        /* If I still have a valid rhs add it to in */
                        change |= in_triple(rb, rhs);
                }
        }
        return change;
}

static struct reg_block *compute_variable_lifetimes(
        struct compile_state *state, struct basic_blocks *bb)
{
        struct reg_block *blocks;
        int change;
        blocks = xcmalloc(
                sizeof(*blocks)*(bb->last_vertex + 1), "reg_block");
        initialize_regblock(blocks, bb->last_block, 0);
        do {
                int i;
                change = 0;
                for(i = 1; i <= bb->last_vertex; i++) {
                        struct block_set *edge;
                        struct reg_block *rb;
                        rb = &blocks[i];
                        /* Add the all successor's input set to in */
                        for(edge = rb->block->edges; edge; edge = edge->next) {
                                change |= reg_in(state, blocks, rb, edge->member);
                        }
                        /* Add use to in... */
                        change |= use_in(state, rb);
                }
        } while(change);
        return blocks;
}

static void free_variable_lifetimes(struct compile_state *state, 
        struct basic_blocks *bb, struct reg_block *blocks)
{
        int i;
        /* free in_set && out_set on each block */
        for(i = 1; i <= bb->last_vertex; i++) {
                struct triple_reg_set *entry, *next;
                struct reg_block *rb;
                rb = &blocks[i];
                for(entry = rb->in; entry ; entry = next) {
                        next = entry->next;
                        do_triple_unset(&rb->in, entry->member);
                }
                for(entry = rb->out; entry; entry = next) {
                        next = entry->next;
                        do_triple_unset(&rb->out, entry->member);
                }
        }
        xfree(blocks);

}

typedef void (*wvl_cb_t)(
        struct compile_state *state, 
        struct reg_block *blocks, struct triple_reg_set *live, 
        struct reg_block *rb, struct triple *ins, void *arg);

static void walk_variable_lifetimes(struct compile_state *state,
        struct basic_blocks *bb, struct reg_block *blocks, 
        wvl_cb_t cb, void *arg)
{
        int i;
        
        for(i = 1; i <= state->bb.last_vertex; i++) {
                struct triple_reg_set *live;
                struct triple_reg_set *entry, *next;
                struct triple *ptr, *prev;
                struct reg_block *rb;
                struct block *block;
                int done;

                /* Get the blocks */
                rb = &blocks[i];
                block = rb->block;

                /* Copy out into live */
                live = 0;
                for(entry = rb->out; entry; entry = next) {
                        next = entry->next;
                        do_triple_set(&live, entry->member, entry->new);
                }
                /* Walk through the basic block calculating live */
                for(done = 0, ptr = block->last; !done; ptr = prev) {
                        struct triple **expr;

                        prev = ptr->prev;
                        done = (ptr == block->first);

                        /* Ensure the current definition is in live */
                        if (triple_is_def(state, ptr)) {
                                do_triple_set(&live, ptr, 0);
                        }

                        /* Inform the callback function of what is
                         * going on.
                         */
                         cb(state, blocks, live, rb, ptr, arg);
                        
                        /* Remove the current definition from live */
                        do_triple_unset(&live, ptr);

                        /* Add the current uses to live.
                         *
                         * It is safe to skip phi functions because they do
                         * not have any block local uses, and the block
                         * output sets already properly account for what
                         * control flow depedent uses phi functions do have.
                         */
                        if (ptr->op == OP_PHI) {
                                continue;
                        }
                        expr = triple_rhs(state, ptr, 0);
                        for(;expr; expr = triple_rhs(state, ptr, expr)) {
                                /* If the triple is not a definition skip it. */
                                if (!*expr || !triple_is_def(state, *expr)) {
                                        continue;
                                }
                                do_triple_set(&live, *expr, 0);
                        }
                }
                /* Free live */
                for(entry = live; entry; entry = next) {
                        next = entry->next;
                        do_triple_unset(&live, entry->member);
                }
        }
}

struct print_live_variable_info {
        struct reg_block *rb;
        FILE *fp;
};
static void print_live_variables_block(
        struct compile_state *state, struct block *block, void *arg)

{
        struct print_live_variable_info *info = arg;
        struct block_set *edge;
        FILE *fp = info->fp;
        struct reg_block *rb;
        struct triple *ptr;
        int phi_present;
        int done;
        rb = &info->rb[block->vertex];

        fprintf(fp, "\nblock: %p (%d),",
                block,  block->vertex);
        for(edge = block->edges; edge; edge = edge->next) {
                fprintf(fp, " %p<-%p",
                        edge->member, 
                        edge->member && edge->member->use?edge->member->use->member : 0);
        }
        fprintf(fp, "\n");
        if (rb->in) {
                struct triple_reg_set *in_set;
                fprintf(fp, "        in:");
                for(in_set = rb->in; in_set; in_set = in_set->next) {
                        fprintf(fp, " %-10p", in_set->member);
                }
                fprintf(fp, "\n");
        }
        phi_present = 0;
        for(done = 0, ptr = block->first; !done; ptr = ptr->next) {
                done = (ptr == block->last);
                if (ptr->op == OP_PHI) {
                        phi_present = 1;
                        break;
                }
        }
        if (phi_present) {
                int edge;
                for(edge = 0; edge < block->users; edge++) {
                        fprintf(fp, "     in(%d):", edge);
                        for(done = 0, ptr = block->first; !done; ptr = ptr->next) {
                                struct triple **slot;
                                done = (ptr == block->last);
                                if (ptr->op != OP_PHI) {
                                        continue;
                                }
                                slot = &RHS(ptr, 0);
                                fprintf(fp, " %-10p", slot[edge]);
                        }
                        fprintf(fp, "\n");
                }
        }
        if (block->first->op == OP_LABEL) {
                fprintf(fp, "%p:\n", block->first);
        }
        for(done = 0, ptr = block->first; !done; ptr = ptr->next) {
                done = (ptr == block->last);
                display_triple(fp, ptr);
        }
        if (rb->out) {
                struct triple_reg_set *out_set;
                fprintf(fp, "       out:");
                for(out_set = rb->out; out_set; out_set = out_set->next) {
                        fprintf(fp, " %-10p", out_set->member);
                }
                fprintf(fp, "\n");
        }
        fprintf(fp, "\n");
}

static void print_live_variables(struct compile_state *state, 
        struct basic_blocks *bb, struct reg_block *rb, FILE *fp)
{
        struct print_live_variable_info info;
        info.rb = rb;
        info.fp = fp;
        fprintf(fp, "\nlive variables by block\n");
        walk_blocks(state, bb, print_live_variables_block, &info);

}


static int count_triples(struct compile_state *state)
{
        struct triple *first, *ins;
        int triples = 0;
        first = state->first;
        ins = first;
        do {
                triples++;
                ins = ins->next;
        } while (ins != first);
        return triples;
}


struct dead_triple {
        struct triple *triple;
        struct dead_triple *work_next;
        struct block *block;
        int old_id;
        int flags;
#define TRIPLE_FLAG_ALIVE 1
#define TRIPLE_FLAG_FREE  1
};

static void print_dead_triples(struct compile_state *state, 
        struct dead_triple *dtriple)
{
        struct triple *first, *ins;
        struct dead_triple *dt;
        FILE *fp;
        if (!(state->compiler->debug & DEBUG_TRIPLES)) {
                return;
        }
        fp = state->dbgout;
        fprintf(fp, "--------------- dtriples ---------------\n");
        first = state->first;
        ins = first;
        do {
                dt = &dtriple[ins->id];
                if ((ins->op == OP_LABEL) && (ins->use)) {
                        fprintf(fp, "\n%p:\n", ins);
                }
                fprintf(fp, "%c", 
                        (dt->flags & TRIPLE_FLAG_ALIVE)?' ': '-');
                display_triple(fp, ins);
                if (triple_is_branch(state, ins)) {
                        fprintf(fp, "\n");
                }
                ins = ins->next;
        } while(ins != first);
        fprintf(fp, "\n");
}


static void awaken(
        struct compile_state *state,
        struct dead_triple *dtriple, struct triple **expr,
        struct dead_triple ***work_list_tail)
{
        struct triple *triple;
        struct dead_triple *dt;
        if (!expr) {
                return;
        }
        triple = *expr;
        if (!triple) {
                return;
        }
        if (triple->id <= 0)  {
                internal_error(state, triple, "bad triple id: %d",
                        triple->id);
        }
        if (triple->op == OP_NOOP) {
                internal_error(state, triple, "awakening noop?");
                return;
        }
        dt = &dtriple[triple->id];
        if (!(dt->flags & TRIPLE_FLAG_ALIVE)) {
                dt->flags |= TRIPLE_FLAG_ALIVE;
                if (!dt->work_next) {
                        **work_list_tail = dt;
                        *work_list_tail = &dt->work_next;
                }
        }
}

static void eliminate_inefectual_code(struct compile_state *state)
{
        struct block *block;
        struct dead_triple *dtriple, *work_list, **work_list_tail, *dt;
        int triples, i;
        struct triple *first, *final, *ins;

        if (!(state->compiler->flags & COMPILER_ELIMINATE_INEFECTUAL_CODE)) {
                return;
        }

        /* Setup the work list */
        work_list = 0;
        work_list_tail = &work_list;

        first = state->first;
        final = state->first->prev;

        /* Count how many triples I have */
        triples = count_triples(state);

        /* Now put then in an array and mark all of the triples dead */
        dtriple = xcmalloc(sizeof(*dtriple) * (triples + 1), "dtriples");
        
        ins = first;
        i = 1;
        block = 0;
        do {
                dtriple[i].triple = ins;
                dtriple[i].block  = block_of_triple(state, ins);
                dtriple[i].flags  = 0;
                dtriple[i].old_id = ins->id;
                ins->id = i;
                /* See if it is an operation we always keep */
                if (!triple_is_pure(state, ins, dtriple[i].old_id)) {
                        awaken(state, dtriple, &ins, &work_list_tail);
                }
                i++;
                ins = ins->next;
        } while(ins != first);
        while(work_list) {
                struct block *block;
                struct dead_triple *dt;
                struct block_set *user;
                struct triple **expr;
                dt = work_list;
                work_list = dt->work_next;
                if (!work_list) {
                        work_list_tail = &work_list;
                }
                /* Make certain the block the current instruction is in lives */
                block = block_of_triple(state, dt->triple);
                awaken(state, dtriple, &block->first, &work_list_tail);
                if (triple_is_branch(state, block->last)) {
                        awaken(state, dtriple, &block->last, &work_list_tail);
                } else {
                        awaken(state, dtriple, &block->last->next, &work_list_tail);
                }

                /* Wake up the data depencencies of this triple */
                expr = 0;
                do {
                        expr = triple_rhs(state, dt->triple, expr);
                        awaken(state, dtriple, expr, &work_list_tail);
                } while(expr);
                do {
                        expr = triple_lhs(state, dt->triple, expr);
                        awaken(state, dtriple, expr, &work_list_tail);
                } while(expr);
                do {
                        expr = triple_misc(state, dt->triple, expr);
                        awaken(state, dtriple, expr, &work_list_tail);
                } while(expr);
                /* Wake up the forward control dependencies */
                do {
                        expr = triple_targ(state, dt->triple, expr);
                        awaken(state, dtriple, expr, &work_list_tail);
                } while(expr);
                /* Wake up the reverse control dependencies of this triple */
                for(user = dt->block->ipdomfrontier; user; user = user->next) {
                        struct triple *last;
                        last = user->member->last;
                        while((last->op == OP_NOOP) && (last != user->member->first)) {
                                internal_warning(state, last, "awakening noop?");
                                last = last->prev;
                        }
                        awaken(state, dtriple, &last, &work_list_tail);
                }
        }
        print_dead_triples(state, dtriple);
        for(dt = &dtriple[1]; dt <= &dtriple[triples]; dt++) {
                if ((dt->triple->op == OP_NOOP) && 
                        (dt->flags & TRIPLE_FLAG_ALIVE)) {
                        internal_error(state, dt->triple, "noop effective?");
                }
                dt->triple->id = dt->old_id;    /* Restore the color */
                if (!(dt->flags & TRIPLE_FLAG_ALIVE)) {
                        release_triple(state, dt->triple);
                }
        }
        xfree(dtriple);

        rebuild_ssa_form(state);

        print_blocks(state, __func__, state->dbgout);
}


static void insert_mandatory_copies(struct compile_state *state)
{
        struct triple *ins, *first;

        /* The object is with a minimum of inserted copies,
         * to resolve in fundamental register conflicts between
         * register value producers and consumers.
         * Theoretically we may be greater than minimal when we
         * are inserting copies before instructions but that
         * case should be rare.
         */
        first = state->first;
        ins = first;
        do {
                struct triple_set *entry, *next;
                struct triple *tmp;
                struct reg_info info;
                unsigned reg, regcm;
                int do_post_copy, do_pre_copy;
                tmp = 0;
                if (!triple_is_def(state, ins)) {
                        goto next;
                }
                /* Find the architecture specific color information */
                info = find_lhs_pre_color(state, ins, 0);
                if (info.reg >= MAX_REGISTERS) {
                        info.reg = REG_UNSET;
                }

                reg = REG_UNSET;
                regcm = arch_type_to_regcm(state, ins->type);
                do_post_copy = do_pre_copy = 0;

                /* Walk through the uses of ins and check for conflicts */
                for(entry = ins->use; entry; entry = next) {
                        struct reg_info rinfo;
                        int i;
                        next = entry->next;
                        i = find_rhs_use(state, entry->member, ins);
                        if (i < 0) {
                                continue;
                        }
                        
                        /* Find the users color requirements */
                        rinfo = arch_reg_rhs(state, entry->member, i);
                        if (rinfo.reg >= MAX_REGISTERS) {
                                rinfo.reg = REG_UNSET;
                        }
                        
                        /* See if I need a pre_copy */
                        if (rinfo.reg != REG_UNSET) {
                                if ((reg != REG_UNSET) && (reg != rinfo.reg)) {
                                        do_pre_copy = 1;
                                }
                                reg = rinfo.reg;
                        }
                        regcm &= rinfo.regcm;
                        regcm = arch_regcm_normalize(state, regcm);
                        if (regcm == 0) {
                                do_pre_copy = 1;
                        }
                        /* Always use pre_copies for constants.
                         * They do not take up any registers until a
                         * copy places them in one.
                         */
                        if ((info.reg == REG_UNNEEDED) && 
                                (rinfo.reg != REG_UNNEEDED)) {
                                do_pre_copy = 1;
                        }
                }
                do_post_copy =
                        !do_pre_copy &&
                        (((info.reg != REG_UNSET) && 
                                (reg != REG_UNSET) &&
                                (info.reg != reg)) ||
                        ((info.regcm & regcm) == 0));

                reg = info.reg;
                regcm = info.regcm;
                /* Walk through the uses of ins and do a pre_copy or see if a post_copy is warranted */
                for(entry = ins->use; entry; entry = next) {
                        struct reg_info rinfo;
                        int i;
                        next = entry->next;
                        i = find_rhs_use(state, entry->member, ins);
                        if (i < 0) {
                                continue;
                        }
                        
                        /* Find the users color requirements */
                        rinfo = arch_reg_rhs(state, entry->member, i);
                        if (rinfo.reg >= MAX_REGISTERS) {
                                rinfo.reg = REG_UNSET;
                        }

                        /* Now see if it is time to do the pre_copy */
                        if (rinfo.reg != REG_UNSET) {
                                if (((reg != REG_UNSET) && (reg != rinfo.reg)) ||
                                        ((regcm & rinfo.regcm) == 0) ||
                                        /* Don't let a mandatory coalesce sneak
                                         * into a operation that is marked to prevent
                                         * coalescing.
                                         */
                                        ((reg != REG_UNNEEDED) &&
                                        ((ins->id & TRIPLE_FLAG_POST_SPLIT) ||
                                        (entry->member->id & TRIPLE_FLAG_PRE_SPLIT)))
                                        ) {
                                        if (do_pre_copy) {
                                                struct triple *user;
                                                user = entry->member;
                                                if (RHS(user, i) != ins) {
                                                        internal_error(state, user, "bad rhs");
                                                }
                                                tmp = pre_copy(state, user, i);
                                                tmp->id |= TRIPLE_FLAG_PRE_SPLIT;
                                                continue;
                                        } else {
                                                do_post_copy = 1;
                                        }
                                }
                                reg = rinfo.reg;
                        }
                        if ((regcm & rinfo.regcm) == 0) {
                                if (do_pre_copy) {
                                        struct triple *user;
                                        user = entry->member;
                                        if (RHS(user, i) != ins) {
                                                internal_error(state, user, "bad rhs");
                                        }
                                        tmp = pre_copy(state, user, i);
                                        tmp->id |= TRIPLE_FLAG_PRE_SPLIT;
                                        continue;
                                } else {
                                        do_post_copy = 1;
                                }
                        }
                        regcm &= rinfo.regcm;
                        
                }
                if (do_post_copy) {
                        struct reg_info pre, post;
                        tmp = post_copy(state, ins);
                        tmp->id |= TRIPLE_FLAG_PRE_SPLIT;
                        pre = arch_reg_lhs(state, ins, 0);
                        post = arch_reg_lhs(state, tmp, 0);
                        if ((pre.reg == post.reg) && (pre.regcm == post.regcm)) {
                                internal_error(state, tmp, "useless copy");
                        }
                }
        next:
                ins = ins->next;
        } while(ins != first);

        print_blocks(state, __func__, state->dbgout);
}


struct live_range_edge;
struct live_range_def;
struct live_range {
        struct live_range_edge *edges;
        struct live_range_def *defs;
/* Note. The list pointed to by defs is kept in order.
 * That is baring splits in the flow control
 * defs dominates defs->next wich dominates defs->next->next
 * etc.
 */
        unsigned color;
        unsigned classes;
        unsigned degree;
        unsigned length;
        struct live_range *group_next, **group_prev;
};

struct live_range_edge {
        struct live_range_edge *next;
        struct live_range *node;
};

struct live_range_def {
        struct live_range_def *next;
        struct live_range_def *prev;
        struct live_range *lr;
        struct triple *def;
        unsigned orig_id;
};

#define LRE_HASH_SIZE 2048
struct lre_hash {
        struct lre_hash *next;
        struct live_range *left;
        struct live_range *right;
};


struct reg_state {
        struct lre_hash *hash[LRE_HASH_SIZE];
        struct reg_block *blocks;
        struct live_range_def *lrd;
        struct live_range *lr;
        struct live_range *low, **low_tail;
        struct live_range *high, **high_tail;
        unsigned defs;
        unsigned ranges;
        int passes, max_passes;
};


struct print_interference_block_info {
        struct reg_state *rstate;
        FILE *fp;
        int need_edges;
};
static void print_interference_block(
        struct compile_state *state, struct block *block, void *arg)

{
        struct print_interference_block_info *info = arg;
        struct reg_state *rstate = info->rstate;
        struct block_set *edge;
        FILE *fp = info->fp;
        struct reg_block *rb;
        struct triple *ptr;
        int phi_present;
        int done;
        rb = &rstate->blocks[block->vertex];

        fprintf(fp, "\nblock: %p (%d),",
                block,  block->vertex);
        for(edge = block->edges; edge; edge = edge->next) {
                fprintf(fp, " %p<-%p",
                        edge->member, 
                        edge->member && edge->member->use?edge->member->use->member : 0);
        }
        fprintf(fp, "\n");
        if (rb->in) {
                struct triple_reg_set *in_set;
                fprintf(fp, "        in:");
                for(in_set = rb->in; in_set; in_set = in_set->next) {
                        fprintf(fp, " %-10p", in_set->member);
                }
                fprintf(fp, "\n");
        }
        phi_present = 0;
        for(done = 0, ptr = block->first; !done; ptr = ptr->next) {
                done = (ptr == block->last);
                if (ptr->op == OP_PHI) {
                        phi_present = 1;
                        break;
                }
        }
        if (phi_present) {
                int edge;
                for(edge = 0; edge < block->users; edge++) {
                        fprintf(fp, "     in(%d):", edge);
                        for(done = 0, ptr = block->first; !done; ptr = ptr->next) {
                                struct triple **slot;
                                done = (ptr == block->last);
                                if (ptr->op != OP_PHI) {
                                        continue;
                                }
                                slot = &RHS(ptr, 0);
                                fprintf(fp, " %-10p", slot[edge]);
                        }
                        fprintf(fp, "\n");
                }
        }
        if (block->first->op == OP_LABEL) {
                fprintf(fp, "%p:\n", block->first);
        }
        for(done = 0, ptr = block->first; !done; ptr = ptr->next) {
                struct live_range *lr;
                unsigned id;
                int op;
                op = ptr->op;
                done = (ptr == block->last);
                lr = rstate->lrd[ptr->id].lr;
                
                id = ptr->id;
                ptr->id = rstate->lrd[id].orig_id;
                SET_REG(ptr->id, lr->color);
                display_triple(fp, ptr);
                ptr->id = id;

                if (triple_is_def(state, ptr) && (lr->defs == 0)) {
                        internal_error(state, ptr, "lr has no defs!");
                }
                if (info->need_edges) {
                        if (lr->defs) {
                                struct live_range_def *lrd;
                                fprintf(fp, "       range:");
                                lrd = lr->defs;
                                do {
                                        fprintf(fp, " %-10p", lrd->def);
                                        lrd = lrd->next;
                                } while(lrd != lr->defs);
                                fprintf(fp, "\n");
                        }
                        if (lr->edges > 0) {
                                struct live_range_edge *edge;
                                fprintf(fp, "       edges:");
                                for(edge = lr->edges; edge; edge = edge->next) {
                                        struct live_range_def *lrd;
                                        lrd = edge->node->defs;
                                        do {
                                                fprintf(fp, " %-10p", lrd->def);
                                                lrd = lrd->next;
                                        } while(lrd != edge->node->defs);
                                        fprintf(fp, "|");
                                }
                                fprintf(fp, "\n");
                        }
                }
                /* Do a bunch of sanity checks */
                valid_ins(state, ptr);
                if ((ptr->id < 0) || (ptr->id > rstate->defs)) {
                        internal_error(state, ptr, "Invalid triple id: %d",
                                ptr->id);
                }
        }
        if (rb->out) {
                struct triple_reg_set *out_set;
                fprintf(fp, "       out:");
                for(out_set = rb->out; out_set; out_set = out_set->next) {
                        fprintf(fp, " %-10p", out_set->member);
                }
                fprintf(fp, "\n");
        }
        fprintf(fp, "\n");
}

static void print_interference_blocks(
        struct compile_state *state, struct reg_state *rstate, FILE *fp, int need_edges)
{
        struct print_interference_block_info info;
        info.rstate = rstate;
        info.fp = fp;
        info.need_edges = need_edges;
        fprintf(fp, "\nlive variables by block\n");
        walk_blocks(state, &state->bb, print_interference_block, &info);

}

static unsigned regc_max_size(struct compile_state *state, int classes)
{
        unsigned max_size;
        int i;
        max_size = 0;
        for(i = 0; i < MAX_REGC; i++) {
                if (classes & (1 << i)) {
                        unsigned size;
                        size = arch_regc_size(state, i);
                        if (size > max_size) {
                                max_size = size;
                        }
                }
        }
        return max_size;
}

static int reg_is_reg(struct compile_state *state, int reg1, int reg2)
{
        unsigned equivs[MAX_REG_EQUIVS];
        int i;
        if ((reg1 < 0) || (reg1 >= MAX_REGISTERS)) {
                internal_error(state, 0, "invalid register");
        }
        if ((reg2 < 0) || (reg2 >= MAX_REGISTERS)) {
                internal_error(state, 0, "invalid register");
        }
        arch_reg_equivs(state, equivs, reg1);
        for(i = 0; (i < MAX_REG_EQUIVS) && equivs[i] != REG_UNSET; i++) {
                if (equivs[i] == reg2) {
                        return 1;
                }
        }
        return 0;
}

static void reg_fill_used(struct compile_state *state, char *used, int reg)
{
        unsigned equivs[MAX_REG_EQUIVS];
        int i;
        if (reg == REG_UNNEEDED) {
                return;
        }
        arch_reg_equivs(state, equivs, reg);
        for(i = 0; (i < MAX_REG_EQUIVS) && equivs[i] != REG_UNSET; i++) {
                used[equivs[i]] = 1;
        }
        return;
}

static void reg_inc_used(struct compile_state *state, char *used, int reg)
{
        unsigned equivs[MAX_REG_EQUIVS];
        int i;
        if (reg == REG_UNNEEDED) {
                return;
        }
        arch_reg_equivs(state, equivs, reg);
        for(i = 0; (i < MAX_REG_EQUIVS) && equivs[i] != REG_UNSET; i++) {
                used[equivs[i]] += 1;
        }
        return;
}

static unsigned int hash_live_edge(
        struct live_range *left, struct live_range *right)
{
        unsigned int hash, val;
        unsigned long lval, rval;
        lval = ((unsigned long)left)/sizeof(struct live_range);
        rval = ((unsigned long)right)/sizeof(struct live_range);
        hash = 0;
        while(lval) {
                val = lval & 0xff;
                lval >>= 8;
                hash = (hash *263) + val;
        }
        while(rval) {
                val = rval & 0xff;
                rval >>= 8;
                hash = (hash *263) + val;
        }
        hash = hash & (LRE_HASH_SIZE - 1);
        return hash;
}

static struct lre_hash **lre_probe(struct reg_state *rstate,
        struct live_range *left, struct live_range *right)
{
        struct lre_hash **ptr;
        unsigned int index;
        /* Ensure left <= right */
        if (left > right) {
                struct live_range *tmp;
                tmp = left;
                left = right;
                right = tmp;
        }
        index = hash_live_edge(left, right);
        
        ptr = &rstate->hash[index];
        while(*ptr) {
                if (((*ptr)->left == left) && ((*ptr)->right == right)) {
                        break;
                }
                ptr = &(*ptr)->next;
        }
        return ptr;
}

static int interfere(struct reg_state *rstate,
        struct live_range *left, struct live_range *right)
{
        struct lre_hash **ptr;
        ptr = lre_probe(rstate, left, right);
        return ptr && *ptr;
}

static void add_live_edge(struct reg_state *rstate, 
        struct live_range *left, struct live_range *right)
{
        /* FIXME the memory allocation overhead is noticeable here... */
        struct lre_hash **ptr, *new_hash;
        struct live_range_edge *edge;

        if (left == right) {
                return;
        }
        if ((left == &rstate->lr[0]) || (right == &rstate->lr[0])) {
                return;
        }
        /* Ensure left <= right */
        if (left > right) {
                struct live_range *tmp;
                tmp = left;
                left = right;
                right = tmp;
        }
        ptr = lre_probe(rstate, left, right);
        if (*ptr) {
                return;
        }
#if 0
        fprintf(state->errout, "new_live_edge(%p, %p)\n",
                left, right);
#endif
        new_hash = xmalloc(sizeof(*new_hash), "lre_hash");
        new_hash->next  = *ptr;
        new_hash->left  = left;
        new_hash->right = right;
        *ptr = new_hash;

        edge = xmalloc(sizeof(*edge), "live_range_edge");
        edge->next   = left->edges;
        edge->node   = right;
        left->edges  = edge;
        left->degree += 1;
        
        edge = xmalloc(sizeof(*edge), "live_range_edge");
        edge->next    = right->edges;
        edge->node    = left;
        right->edges  = edge;
        right->degree += 1;
}

static void remove_live_edge(struct reg_state *rstate,
        struct live_range *left, struct live_range *right)
{
        struct live_range_edge *edge, **ptr;
        struct lre_hash **hptr, *entry;
        hptr = lre_probe(rstate, left, right);
        if (!hptr || !*hptr) {
                return;
        }
        entry = *hptr;
        *hptr = entry->next;
        xfree(entry);

        for(ptr = &left->edges; *ptr; ptr = &(*ptr)->next) {
                edge = *ptr;
                if (edge->node == right) {
                        *ptr = edge->next;
                        memset(edge, 0, sizeof(*edge));
                        xfree(edge);
                        right->degree--;
                        break;
                }
        }
        for(ptr = &right->edges; *ptr; ptr = &(*ptr)->next) {
                edge = *ptr;
                if (edge->node == left) {
                        *ptr = edge->next;
                        memset(edge, 0, sizeof(*edge));
                        xfree(edge);
                        left->degree--;
                        break;
                }
        }
}

static void remove_live_edges(struct reg_state *rstate, struct live_range *range)
{
        struct live_range_edge *edge, *next;
        for(edge = range->edges; edge; edge = next) {
                next = edge->next;
                remove_live_edge(rstate, range, edge->node);
        }
}

static void transfer_live_edges(struct reg_state *rstate, 
        struct live_range *dest, struct live_range *src)
{
        struct live_range_edge *edge, *next;
        for(edge = src->edges; edge; edge = next) {
                struct live_range *other;
                next = edge->next;
                other = edge->node;
                remove_live_edge(rstate, src, other);
                add_live_edge(rstate, dest, other);
        }
}


/* Interference graph...
 * 
 * new(n) --- Return a graph with n nodes but no edges.
 * add(g,x,y) --- Return a graph including g with an between x and y
 * interfere(g, x, y) --- Return true if there exists an edge between the nodes
 *                x and y in the graph g
 * degree(g, x) --- Return the degree of the node x in the graph g
 * neighbors(g, x, f) --- Apply function f to each neighbor of node x in the graph g
 *
 * Implement with a hash table && a set of adjcency vectors.
 * The hash table supports constant time implementations of add and interfere.
 * The adjacency vectors support an efficient implementation of neighbors.
 */

/* 
 *     +---------------------------------------------------+
 *     |         +--------------+                          |
 *     v         v              |                          |
 * renumber -> build graph -> colalesce -> spill_costs -> simplify -> select 
 *
 * -- In simplify implment optimistic coloring... (No backtracking)
 * -- Implement Rematerialization it is the only form of spilling we can perform
 *    Essentially this means dropping a constant from a register because
 *    we can regenerate it later.
 *
 * --- Very conservative colalescing (don't colalesce just mark the opportunities)
 *     coalesce at phi points...
 * --- Bias coloring if at all possible do the coalesing a compile time.
 *
 *
 */

static void different_colored(
        struct compile_state *state, struct reg_state *rstate, 
        struct triple *parent, struct triple *ins)
{
        struct live_range *lr;
        struct triple **expr;
        lr = rstate->lrd[ins->id].lr;
        expr = triple_rhs(state, ins, 0);
        for(;expr; expr = triple_rhs(state, ins, expr)) {
                struct live_range *lr2;
                if (!*expr || (*expr == parent) || (*expr == ins)) {
                        continue;
                }
                lr2 = rstate->lrd[(*expr)->id].lr;
                if (lr->color == lr2->color) {
                        internal_error(state, ins, "live range too big");
                }
        }
}


static struct live_range *coalesce_ranges(
        struct compile_state *state, struct reg_state *rstate,
        struct live_range *lr1, struct live_range *lr2)
{
        struct live_range_def *head, *mid1, *mid2, *end, *lrd;
        unsigned color;
        unsigned classes;
        if (lr1 == lr2) {
                return lr1;
        }
        if (!lr1->defs || !lr2->defs) {
                internal_error(state, 0,
                        "cannot coalese dead live ranges");
        }
        if ((lr1->color == REG_UNNEEDED) ||
                (lr2->color == REG_UNNEEDED)) {
                internal_error(state, 0, 
                        "cannot coalesce live ranges without a possible color");
        }
        if ((lr1->color != lr2->color) &&
                (lr1->color != REG_UNSET) &&
                (lr2->color != REG_UNSET)) {
                internal_error(state, lr1->defs->def, 
                        "cannot coalesce live ranges of different colors");
        }
        color = lr1->color;
        if (color == REG_UNSET) {
                color = lr2->color;
        }
        classes = lr1->classes & lr2->classes;
        if (!classes) {
                internal_error(state, lr1->defs->def,
                        "cannot coalesce live ranges with dissimilar register classes");
        }
        if (state->compiler->debug & DEBUG_COALESCING) {
                FILE *fp = state->errout;
                fprintf(fp, "coalescing:");
                lrd = lr1->defs;
                do {
                        fprintf(fp, " %p", lrd->def);
                        lrd = lrd->next;
                } while(lrd != lr1->defs);
                fprintf(fp, " |");
                lrd = lr2->defs;
                do {
                        fprintf(fp, " %p", lrd->def);
                        lrd = lrd->next;
                } while(lrd != lr2->defs);
                fprintf(fp, "\n");
        }
        /* If there is a clear dominate live range put it in lr1,
         * For purposes of this test phi functions are
         * considered dominated by the definitions that feed into
         * them. 
         */
        if ((lr1->defs->prev->def->op == OP_PHI) ||
                ((lr2->defs->prev->def->op != OP_PHI) &&
                tdominates(state, lr2->defs->def, lr1->defs->def))) {
                struct live_range *tmp;
                tmp = lr1;
                lr1 = lr2;
                lr2 = tmp;
        }
#if 0
        if (lr1->defs->orig_id  & TRIPLE_FLAG_POST_SPLIT) {
                fprintf(state->errout, "lr1 post\n");
        }
        if (lr1->defs->orig_id & TRIPLE_FLAG_PRE_SPLIT) {
                fprintf(state->errout, "lr1 pre\n");
        }
        if (lr2->defs->orig_id  & TRIPLE_FLAG_POST_SPLIT) {
                fprintf(state->errout, "lr2 post\n");
        }
        if (lr2->defs->orig_id & TRIPLE_FLAG_PRE_SPLIT) {
                fprintf(state->errout, "lr2 pre\n");
        }
#endif
#if 0
        fprintf(state->errout, "coalesce color1(%p): %3d color2(%p) %3d\n",
                lr1->defs->def,
                lr1->color,
                lr2->defs->def,
                lr2->color);
#endif
        
        /* Append lr2 onto lr1 */
#warning "FIXME should this be a merge instead of a splice?"
        /* This FIXME item applies to the correctness of live_range_end 
         * and to the necessity of making multiple passes of coalesce_live_ranges.
         * A failure to find some coalesce opportunities in coaleace_live_ranges
         * does not impact the correct of the compiler just the efficiency with
         * which registers are allocated.
         */
        head = lr1->defs;
        mid1 = lr1->defs->prev;
        mid2 = lr2->defs;
        end  = lr2->defs->prev;
        
        head->prev = end;
        end->next  = head;

        mid1->next = mid2;
        mid2->prev = mid1;

        /* Fixup the live range in the added live range defs */
        lrd = head;
        do {
                lrd->lr = lr1;
                lrd = lrd->next;
        } while(lrd != head);

        /* Mark lr2 as free. */
        lr2->defs = 0;
        lr2->color = REG_UNNEEDED;
        lr2->classes = 0;

        if (!lr1->defs) {
                internal_error(state, 0, "lr1->defs == 0 ?");
        }

        lr1->color   = color;
        lr1->classes = classes;

        /* Keep the graph in sync by transfering the edges from lr2 to lr1 */
        transfer_live_edges(rstate, lr1, lr2);

        return lr1;
}

static struct live_range_def *live_range_head(
        struct compile_state *state, struct live_range *lr,
        struct live_range_def *last)
{
        struct live_range_def *result;
        result = 0;
        if (last == 0) {
                result = lr->defs;
        }
        else if (!tdominates(state, lr->defs->def, last->next->def)) {
                result = last->next;
        }
        return result;
}

static struct live_range_def *live_range_end(
        struct compile_state *state, struct live_range *lr,
        struct live_range_def *last)
{
        struct live_range_def *result;
        result = 0;
        if (last == 0) {
                result = lr->defs->prev;
        }
        else if (!tdominates(state, last->prev->def, lr->defs->prev->def)) {
                result = last->prev;
        }
        return result;
}


static void initialize_live_ranges(
        struct compile_state *state, struct reg_state *rstate)
{
        struct triple *ins, *first;
        size_t count, size;
        int i, j;

        first = state->first;
        /* First count how many instructions I have.
         */
        count = count_triples(state);
        /* Potentially I need one live range definitions for each
         * instruction.
         */
        rstate->defs = count;
        /* Potentially I need one live range for each instruction
         * plus an extra for the dummy live range.
         */
        rstate->ranges = count + 1;
        size = sizeof(rstate->lrd[0]) * rstate->defs;
        rstate->lrd = xcmalloc(size, "live_range_def");
        size = sizeof(rstate->lr[0]) * rstate->ranges;
        rstate->lr  = xcmalloc(size, "live_range");

        /* Setup the dummy live range */
        rstate->lr[0].classes = 0;
        rstate->lr[0].color = REG_UNSET;
        rstate->lr[0].defs = 0;
        i = j = 0;
        ins = first;
        do {
                /* If the triple is a variable give it a live range */
                if (triple_is_def(state, ins)) {
                        struct reg_info info;
                        /* Find the architecture specific color information */
                        info = find_def_color(state, ins);
                        i++;
                        rstate->lr[i].defs    = &rstate->lrd[j];
                        rstate->lr[i].color   = info.reg;
                        rstate->lr[i].classes = info.regcm;
                        rstate->lr[i].degree  = 0;
                        rstate->lrd[j].lr = &rstate->lr[i];
                } 
                /* Otherwise give the triple the dummy live range. */
                else {
                        rstate->lrd[j].lr = &rstate->lr[0];
                }

                /* Initalize the live_range_def */
                rstate->lrd[j].next    = &rstate->lrd[j];
                rstate->lrd[j].prev    = &rstate->lrd[j];
                rstate->lrd[j].def     = ins;
                rstate->lrd[j].orig_id = ins->id;
                ins->id = j;

                j++;
                ins = ins->next;
        } while(ins != first);
        rstate->ranges = i;

        /* Make a second pass to handle achitecture specific register
         * constraints.
         */
        ins = first;
        do {
                int zlhs, zrhs, i, j;
                if (ins->id > rstate->defs) {
                        internal_error(state, ins, "bad id");
                }
                
                /* Walk through the template of ins and coalesce live ranges */
                zlhs = ins->lhs;
                if ((zlhs == 0) && triple_is_def(state, ins)) {
                        zlhs = 1;
                }
                zrhs = ins->rhs;

                if (state->compiler->debug & DEBUG_COALESCING2) {
                        fprintf(state->errout, "mandatory coalesce: %p %d %d\n",
                                ins, zlhs, zrhs);
                }

                for(i = 0; i < zlhs; i++) {
                        struct reg_info linfo;
                        struct live_range_def *lhs;
                        linfo = arch_reg_lhs(state, ins, i);
                        if (linfo.reg < MAX_REGISTERS) {
                                continue;
                        }
                        if (triple_is_def(state, ins)) {
                                lhs = &rstate->lrd[ins->id];
                        } else {
                                lhs = &rstate->lrd[LHS(ins, i)->id];
                        }

                        if (state->compiler->debug & DEBUG_COALESCING2) {
                                fprintf(state->errout, "coalesce lhs(%d): %p %d\n",
                                        i, lhs, linfo.reg);
                        }

                        for(j = 0; j < zrhs; j++) {
                                struct reg_info rinfo;
                                struct live_range_def *rhs;
                                rinfo = arch_reg_rhs(state, ins, j);
                                if (rinfo.reg < MAX_REGISTERS) {
                                        continue;
                                }
                                rhs = &rstate->lrd[RHS(ins, j)->id];

                                if (state->compiler->debug & DEBUG_COALESCING2) {
                                        fprintf(state->errout, "coalesce rhs(%d): %p %d\n",
                                                j, rhs, rinfo.reg);
                                }

                                if (rinfo.reg == linfo.reg) {
                                        coalesce_ranges(state, rstate, 
                                                lhs->lr, rhs->lr);
                                }
                        }
                }
                ins = ins->next;
        } while(ins != first);
}

static void graph_ins(
        struct compile_state *state, 
        struct reg_block *blocks, struct triple_reg_set *live, 
        struct reg_block *rb, struct triple *ins, void *arg)
{
        struct reg_state *rstate = arg;
        struct live_range *def;
        struct triple_reg_set *entry;

        /* If the triple is not a definition
         * we do not have a definition to add to
         * the interference graph.
         */
        if (!triple_is_def(state, ins)) {
                return;
        }
        def = rstate->lrd[ins->id].lr;
        
        /* Create an edge between ins and everything that is
         * alive, unless the live_range cannot share
         * a physical register with ins.
         */
        for(entry = live; entry; entry = entry->next) {
                struct live_range *lr;
                if ((entry->member->id < 0) || (entry->member->id > rstate->defs)) {
                        internal_error(state, 0, "bad entry?");
                }
                lr = rstate->lrd[entry->member->id].lr;
                if (def == lr) {
                        continue;
                }
                if (!arch_regcm_intersect(def->classes, lr->classes)) {
                        continue;
                }
                add_live_edge(rstate, def, lr);
        }
        return;
}

static struct live_range *get_verify_live_range(
        struct compile_state *state, struct reg_state *rstate, struct triple *ins)
{
        struct live_range *lr;
        struct live_range_def *lrd;
        int ins_found;
        if ((ins->id < 0) || (ins->id > rstate->defs)) {
                internal_error(state, ins, "bad ins?");
        }
        lr = rstate->lrd[ins->id].lr;
        ins_found = 0;
        lrd = lr->defs;
        do {
                if (lrd->def == ins) {
                        ins_found = 1;
                }
                lrd = lrd->next;
        } while(lrd != lr->defs);
        if (!ins_found) {
                internal_error(state, ins, "ins not in live range");
        }
        return lr;
}

static void verify_graph_ins(
        struct compile_state *state, 
        struct reg_block *blocks, struct triple_reg_set *live, 
        struct reg_block *rb, struct triple *ins, void *arg)
{
        struct reg_state *rstate = arg;
        struct triple_reg_set *entry1, *entry2;


        /* Compare live against edges and make certain the code is working */
        for(entry1 = live; entry1; entry1 = entry1->next) {
                struct live_range *lr1;
                lr1 = get_verify_live_range(state, rstate, entry1->member);
                for(entry2 = live; entry2; entry2 = entry2->next) {
                        struct live_range *lr2;
                        struct live_range_edge *edge2;
                        int lr1_found;
                        int lr2_degree;
                        if (entry2 == entry1) {
                                continue;
                        }
                        lr2 = get_verify_live_range(state, rstate, entry2->member);
                        if (lr1 == lr2) {
                                internal_error(state, entry2->member, 
                                        "live range with 2 values simultaneously alive");
                        }
                        if (!arch_regcm_intersect(lr1->classes, lr2->classes)) {
                                continue;
                        }
                        if (!interfere(rstate, lr1, lr2)) {
                                internal_error(state, entry2->member, 
                                        "edges don't interfere?");
                        }
                                
                        lr1_found = 0;
                        lr2_degree = 0;
                        for(edge2 = lr2->edges; edge2; edge2 = edge2->next) {
                                lr2_degree++;
                                if (edge2->node == lr1) {
                                        lr1_found = 1;
                                }
                        }
                        if (lr2_degree != lr2->degree) {
                                internal_error(state, entry2->member,
                                        "computed degree: %d does not match reported degree: %d\n",
                                        lr2_degree, lr2->degree);
                        }
                        if (!lr1_found) {
                                internal_error(state, entry2->member, "missing edge");
                        }
                }
        }
        return;
}


static void print_interference_ins(
        struct compile_state *state, 
        struct reg_block *blocks, struct triple_reg_set *live, 
        struct reg_block *rb, struct triple *ins, void *arg)
{
        struct reg_state *rstate = arg;
        struct live_range *lr;
        unsigned id;
        FILE *fp = state->dbgout;

        lr = rstate->lrd[ins->id].lr;
        id = ins->id;
        ins->id = rstate->lrd[id].orig_id;
        SET_REG(ins->id, lr->color);
        display_triple(state->dbgout, ins);
        ins->id = id;

        if (lr->defs) {
                struct live_range_def *lrd;
                fprintf(fp, "       range:");
                lrd = lr->defs;
                do {
                        fprintf(fp, " %-10p", lrd->def);
                        lrd = lrd->next;
                } while(lrd != lr->defs);
                fprintf(fp, "\n");
        }
        if (live) {
                struct triple_reg_set *entry;
                fprintf(fp, "        live:");
                for(entry = live; entry; entry = entry->next) {
                        fprintf(fp, " %-10p", entry->member);
                }
                fprintf(fp, "\n");
        }
        if (lr->edges) {
                struct live_range_edge *entry;
                fprintf(fp, "       edges:");
                for(entry = lr->edges; entry; entry = entry->next) {
                        struct live_range_def *lrd;
                        lrd = entry->node->defs;
                        do {
                                fprintf(fp, " %-10p", lrd->def);
                                lrd = lrd->next;
                        } while(lrd != entry->node->defs);
                        fprintf(fp, "|");
                }
                fprintf(fp, "\n");
        }
        if (triple_is_branch(state, ins)) {
                fprintf(fp, "\n");
        }
        return;
}

static int coalesce_live_ranges(
        struct compile_state *state, struct reg_state *rstate)
{
        /* At the point where a value is moved from one
         * register to another that value requires two
         * registers, thus increasing register pressure.
         * Live range coaleescing reduces the register
         * pressure by keeping a value in one register
         * longer.
         *
         * In the case of a phi function all paths leading
         * into it must be allocated to the same register
         * otherwise the phi function may not be removed.
         *
         * Forcing a value to stay in a single register
         * for an extended period of time does have
         * limitations when applied to non homogenous
         * register pool.  
         *
         * The two cases I have identified are:
         * 1) Two forced register assignments may
         *    collide.
         * 2) Registers may go unused because they
         *    are only good for storing the value
         *    and not manipulating it.
         *
         * Because of this I need to split live ranges,
         * even outside of the context of coalesced live
         * ranges.  The need to split live ranges does
         * impose some constraints on live range coalescing.
         *
         * - Live ranges may not be coalesced across phi
         *   functions.  This creates a 2 headed live
         *   range that cannot be sanely split.
         *
         * - phi functions (coalesced in initialize_live_ranges) 
         *   are handled as pre split live ranges so we will
         *   never attempt to split them.
         */
        int coalesced;
        int i;

        coalesced = 0;
        for(i = 0; i <= rstate->ranges; i++) {
                struct live_range *lr1;
                struct live_range_def *lrd1;
                lr1 = &rstate->lr[i];
                if (!lr1->defs) {
                        continue;
                }
                lrd1 = live_range_end(state, lr1, 0);
                for(; lrd1; lrd1 = live_range_end(state, lr1, lrd1)) {
                        struct triple_set *set;
                        if (lrd1->def->op != OP_COPY) {
                                continue;
                        }
                        /* Skip copies that are the result of a live range split. */
                        if (lrd1->orig_id & TRIPLE_FLAG_POST_SPLIT) {
                                continue;
                        }
                        for(set = lrd1->def->use; set; set = set->next) {
                                struct live_range_def *lrd2;
                                struct live_range *lr2, *res;

                                lrd2 = &rstate->lrd[set->member->id];

                                /* Don't coalesce with instructions
                                 * that are the result of a live range
                                 * split.
                                 */
                                if (lrd2->orig_id & TRIPLE_FLAG_PRE_SPLIT) {
                                        continue;
                                }
                                lr2 = rstate->lrd[set->member->id].lr;
                                if (lr1 == lr2) {
                                        continue;
                                }
                                if ((lr1->color != lr2->color) &&
                                        (lr1->color != REG_UNSET) &&
                                        (lr2->color != REG_UNSET)) {
                                        continue;
                                }
                                if ((lr1->classes & lr2->classes) == 0) {
                                        continue;
                                }
                                
                                if (interfere(rstate, lr1, lr2)) {
                                        continue;
                                }

                                res = coalesce_ranges(state, rstate, lr1, lr2);
                                coalesced += 1;
                                if (res != lr1) {
                                        goto next;
                                }
                        }
                }
        next:
                ;
        }
        return coalesced;
}


static void fix_coalesce_conflicts(struct compile_state *state,
        struct reg_block *blocks, struct triple_reg_set *live,
        struct reg_block *rb, struct triple *ins, void *arg)
{
        int *conflicts = arg;
        int zlhs, zrhs, i, j;

        /* See if we have a mandatory coalesce operation between
         * a lhs and a rhs value.  If so and the rhs value is also
         * alive then this triple needs to be pre copied.  Otherwise
         * we would have two definitions in the same live range simultaneously
         * alive.
         */
        zlhs = ins->lhs;
        if ((zlhs == 0) && triple_is_def(state, ins)) {
                zlhs = 1;
        }
        zrhs = ins->rhs;
        for(i = 0; i < zlhs; i++) {
                struct reg_info linfo;
                linfo = arch_reg_lhs(state, ins, i);
                if (linfo.reg < MAX_REGISTERS) {
                        continue;
                }
                for(j = 0; j < zrhs; j++) {
                        struct reg_info rinfo;
                        struct triple *rhs;
                        struct triple_reg_set *set;
                        int found;
                        found = 0;
                        rinfo = arch_reg_rhs(state, ins, j);
                        if (rinfo.reg != linfo.reg) {
                                continue;
                        }
                        rhs = RHS(ins, j);
                        for(set = live; set && !found; set = set->next) {
                                if (set->member == rhs) {
                                        found = 1;
                                }
                        }
                        if (found) {
                                struct triple *copy;
                                copy = pre_copy(state, ins, j);
                                copy->id |= TRIPLE_FLAG_PRE_SPLIT;
                                (*conflicts)++;
                        }
                }
        }
        return;
}

static int correct_coalesce_conflicts(
        struct compile_state *state, struct reg_block *blocks)
{
        int conflicts;
        conflicts = 0;
        walk_variable_lifetimes(state, &state->bb, blocks, 
                fix_coalesce_conflicts, &conflicts);
        return conflicts;
}

static void replace_set_use(struct compile_state *state,
        struct triple_reg_set *head, struct triple *orig, struct triple *new)
{
        struct triple_reg_set *set;
        for(set = head; set; set = set->next) {
                if (set->member == orig) {
                        set->member = new;
                }
        }
}

static void replace_block_use(struct compile_state *state, 
        struct reg_block *blocks, struct triple *orig, struct triple *new)
{
        int i;
#warning "WISHLIST visit just those blocks that need it *"
        for(i = 1; i <= state->bb.last_vertex; i++) {
                struct reg_block *rb;
                rb = &blocks[i];
                replace_set_use(state, rb->in, orig, new);
                replace_set_use(state, rb->out, orig, new);
        }
}

static void color_instructions(struct compile_state *state)
{
        struct triple *ins, *first;
        first = state->first;
        ins = first;
        do {
                if (triple_is_def(state, ins)) {
                        struct reg_info info;
                        info = find_lhs_color(state, ins, 0);
                        if (info.reg >= MAX_REGISTERS) {
                                info.reg = REG_UNSET;
                        }
                        SET_INFO(ins->id, info);
                }
                ins = ins->next;
        } while(ins != first);
}

static struct reg_info read_lhs_color(
        struct compile_state *state, struct triple *ins, int index)
{
        struct reg_info info;
        if ((index == 0) && triple_is_def(state, ins)) {
                info.reg   = ID_REG(ins->id);
                info.regcm = ID_REGCM(ins->id);
        }
        else if (index < ins->lhs) {
                info = read_lhs_color(state, LHS(ins, index), 0);
        }
        else {
                internal_error(state, ins, "Bad lhs %d", index);
                info.reg = REG_UNSET;
                info.regcm = 0;
        }
        return info;
}

static struct triple *resolve_tangle(
        struct compile_state *state, struct triple *tangle)
{
        struct reg_info info, uinfo;
        struct triple_set *set, *next;
        struct triple *copy;

#warning "WISHLIST recalculate all affected instructions colors"
        info = find_lhs_color(state, tangle, 0);
        for(set = tangle->use; set; set = next) {
                struct triple *user;
                int i, zrhs;
                next = set->next;
                user = set->member;
                zrhs = user->rhs;
                for(i = 0; i < zrhs; i++) {
                        if (RHS(user, i) != tangle) {
                                continue;
                        }
                        uinfo = find_rhs_post_color(state, user, i);
                        if (uinfo.reg == info.reg) {
                                copy = pre_copy(state, user, i);
                                copy->id |= TRIPLE_FLAG_PRE_SPLIT;
                                SET_INFO(copy->id, uinfo);
                        }
                }
        }
        copy = 0;
        uinfo = find_lhs_pre_color(state, tangle, 0);
        if (uinfo.reg == info.reg) {
                struct reg_info linfo;
                copy = post_copy(state, tangle);
                copy->id |= TRIPLE_FLAG_PRE_SPLIT;
                linfo = find_lhs_color(state, copy, 0);
                SET_INFO(copy->id, linfo);
        }
        info = find_lhs_color(state, tangle, 0);
        SET_INFO(tangle->id, info);
        
        return copy;
}


static void fix_tangles(struct compile_state *state,
        struct reg_block *blocks, struct triple_reg_set *live,
        struct reg_block *rb, struct triple *ins, void *arg)
{
        int *tangles = arg;
        struct triple *tangle;
        do {
                char used[MAX_REGISTERS];
                struct triple_reg_set *set;
                tangle = 0;

                /* Find out which registers have multiple uses at this point */
                memset(used, 0, sizeof(used));
                for(set = live; set; set = set->next) {
                        struct reg_info info;
                        info = read_lhs_color(state, set->member, 0);
                        if (info.reg == REG_UNSET) {
                                continue;
                        }
                        reg_inc_used(state, used, info.reg);
                }
                
                /* Now find the least dominated definition of a register in
                 * conflict I have seen so far.
                 */
                for(set = live; set; set = set->next) {
                        struct reg_info info;
                        info = read_lhs_color(state, set->member, 0);
                        if (used[info.reg] < 2) {
                                continue;
                        }
                        /* Changing copies that feed into phi functions
                         * is incorrect.
                         */
                        if (set->member->use && 
                                (set->member->use->member->op == OP_PHI)) {
                                continue;
                        }
                        if (!tangle || tdominates(state, set->member, tangle)) {
                                tangle = set->member;
                        }
                }
                /* If I have found a tangle resolve it */
                if (tangle) {
                        struct triple *post_copy;
                        (*tangles)++;
                        post_copy = resolve_tangle(state, tangle);
                        if (post_copy) {
                                replace_block_use(state, blocks, tangle, post_copy);
                        }
                        if (post_copy && (tangle != ins)) {
                                replace_set_use(state, live, tangle, post_copy);
                        }
                }
        } while(tangle);
        return;
}

static int correct_tangles(
        struct compile_state *state, struct reg_block *blocks)
{
        int tangles;
        tangles = 0;
        color_instructions(state);
        walk_variable_lifetimes(state, &state->bb, blocks, 
                fix_tangles, &tangles);
        return tangles;
}


static void ids_from_rstate(struct compile_state *state, struct reg_state *rstate);
static void cleanup_rstate(struct compile_state *state, struct reg_state *rstate);

struct triple *find_constrained_def(
        struct compile_state *state, struct live_range *range, struct triple *constrained)
{
        struct live_range_def *lrd, *lrd_next;
        lrd_next = range->defs;
        do {
                struct reg_info info;
                unsigned regcm;

                lrd = lrd_next;
                lrd_next = lrd->next;

                regcm = arch_type_to_regcm(state, lrd->def->type);
                info = find_lhs_color(state, lrd->def, 0);
                regcm      = arch_regcm_reg_normalize(state, regcm);
                info.regcm = arch_regcm_reg_normalize(state, info.regcm);
                /* If the 2 register class masks are equal then
                 * the current register class is not constrained.
                 */
                if (regcm == info.regcm) {
                        continue;
                }
                
                /* If there is just one use.
                 * That use cannot accept a larger register class.
                 * There are no intervening definitions except
                 * definitions that feed into that use.
                 * Then a triple is not constrained.
                 * FIXME handle this case!
                 */
#warning "FIXME ignore cases that cannot be fixed (a definition followed by a use)"
                

                /* Of the constrained live ranges deal with the
                 * least dominated one first.
                 */
                if (state->compiler->debug & DEBUG_RANGE_CONFLICTS) {
                        fprintf(state->errout, "canidate: %p %-8s regcm: %x %x\n",
                                lrd->def, tops(lrd->def->op), regcm, info.regcm);
                }
                if (!constrained || 
                        tdominates(state, lrd->def, constrained))
                {
                        constrained = lrd->def;
                }
        } while(lrd_next != range->defs);
        return constrained;
}

static int split_constrained_ranges(
        struct compile_state *state, struct reg_state *rstate, 
        struct live_range *range)
{
        /* Walk through the edges in conflict and our current live
         * range, and find definitions that are more severly constrained
         * than they type of data they contain require.
         * 
         * Then pick one of those ranges and relax the constraints.
         */
        struct live_range_edge *edge;
        struct triple *constrained;

        constrained = 0;
        for(edge = range->edges; edge; edge = edge->next) {
                constrained = find_constrained_def(state, edge->node, constrained);
        }
#warning "FIXME should I call find_constrained_def here only if no previous constrained def was found?"
        if (!constrained) {
                constrained = find_constrained_def(state, range, constrained);
        }

        if (state->compiler->debug & DEBUG_RANGE_CONFLICTS) {
                fprintf(state->errout, "constrained: ");
                display_triple(state->errout, constrained);
        }
        if (constrained) {
                ids_from_rstate(state, rstate);
                cleanup_rstate(state, rstate);
                resolve_tangle(state, constrained);
        }
        return !!constrained;
}
        
static int split_ranges(
        struct compile_state *state, struct reg_state *rstate,
        char *used, struct live_range *range)
{
        int split;
        if (state->compiler->debug & DEBUG_RANGE_CONFLICTS) {
                fprintf(state->errout, "split_ranges %d %s %p\n", 
                        rstate->passes, tops(range->defs->def->op), range->defs->def);
        }
        if ((range->color == REG_UNNEEDED) ||
                (rstate->passes >= rstate->max_passes)) {
                return 0;
        }
        split = split_constrained_ranges(state, rstate, range);

        /* Ideally I would split the live range that will not be used
         * for the longest period of time in hopes that this will 
         * (a) allow me to spill a register or
         * (b) allow me to place a value in another register.
         *
         * So far I don't have a test case for this, the resolving
         * of mandatory constraints has solved all of my
         * know issues.  So I have choosen not to write any
         * code until I cat get a better feel for cases where
         * it would be useful to have.
         *
         */
#warning "WISHLIST implement live range splitting..."
        
        if (!split && (state->compiler->debug & DEBUG_RANGE_CONFLICTS2)) {
                FILE *fp = state->errout;
                print_interference_blocks(state, rstate, fp, 0);
                print_dominators(state, fp, &state->bb);
        }
        return split;
}

static FILE *cgdebug_fp(struct compile_state *state)
{
        FILE *fp;
        fp = 0;
        if (!fp && (state->compiler->debug & DEBUG_COLOR_GRAPH2)) {
                fp = state->errout;
        }
        if (!fp && (state->compiler->debug & DEBUG_COLOR_GRAPH)) {
                fp = state->dbgout;
        }
        return fp;
}

static void cgdebug_printf(struct compile_state *state, const char *fmt, ...)
{
        FILE *fp;
        fp = cgdebug_fp(state);
        if (fp) {
                va_list args;
                va_start(args, fmt);
                vfprintf(fp, fmt, args);
                va_end(args);
        }
}

static void cgdebug_flush(struct compile_state *state)
{
        FILE *fp;
        fp = cgdebug_fp(state);
        if (fp) {
                fflush(fp);
        }
}

static void cgdebug_loc(struct compile_state *state, struct triple *ins)
{
        FILE *fp;
        fp = cgdebug_fp(state);
        if (fp) {
                loc(fp, state, ins);
        }
}

static int select_free_color(struct compile_state *state, 
        struct reg_state *rstate, struct live_range *range)
{
        struct triple_set *entry;
        struct live_range_def *lrd;
        struct live_range_def *phi;
        struct live_range_edge *edge;
        char used[MAX_REGISTERS];
        struct triple **expr;

        /* Instead of doing just the trivial color select here I try
         * a few extra things because a good color selection will help reduce
         * copies.
         */

        /* Find the registers currently in use */
        memset(used, 0, sizeof(used));
        for(edge = range->edges; edge; edge = edge->next) {
                if (edge->node->color == REG_UNSET) {
                        continue;
                }
                reg_fill_used(state, used, edge->node->color);
        }

        if (state->compiler->debug & DEBUG_COLOR_GRAPH2) {
                int i;
                i = 0;
                for(edge = range->edges; edge; edge = edge->next) {
                        i++;
                }
                cgdebug_printf(state, "\n%s edges: %d", 
                        tops(range->defs->def->op), i);
                cgdebug_loc(state, range->defs->def);
                cgdebug_printf(state, "\n");
                for(i = 0; i < MAX_REGISTERS; i++) {
                        if (used[i]) {
                                cgdebug_printf(state, "used: %s\n",
                                        arch_reg_str(i));
                        }
                }
        }       

        /* If a color is already assigned see if it will work */
        if (range->color != REG_UNSET) {
                struct live_range_def *lrd;
                if (!used[range->color]) {
                        return 1;
                }
                for(edge = range->edges; edge; edge = edge->next) {
                        if (edge->node->color != range->color) {
                                continue;
                        }
                        warning(state, edge->node->defs->def, "edge: ");
                        lrd = edge->node->defs;
                        do {
                                warning(state, lrd->def, " %p %s",
                                        lrd->def, tops(lrd->def->op));
                                lrd = lrd->next;
                        } while(lrd != edge->node->defs);
                }
                lrd = range->defs;
                warning(state, range->defs->def, "def: ");
                do {
                        warning(state, lrd->def, " %p %s",
                                lrd->def, tops(lrd->def->op));
                        lrd = lrd->next;
                } while(lrd != range->defs);
                internal_error(state, range->defs->def,
                        "live range with already used color %s",
                        arch_reg_str(range->color));
        }

        /* If I feed into an expression reuse it's color.
         * This should help remove copies in the case of 2 register instructions
         * and phi functions.
         */
        phi = 0;
        lrd = live_range_end(state, range, 0);
        for(; (range->color == REG_UNSET) && lrd ; lrd = live_range_end(state, range, lrd)) {
                entry = lrd->def->use;
                for(;(range->color == REG_UNSET) && entry; entry = entry->next) {
                        struct live_range_def *insd;
                        unsigned regcm;
                        insd = &rstate->lrd[entry->member->id];
                        if (insd->lr->defs == 0) {
                                continue;
                        }
                        if (!phi && (insd->def->op == OP_PHI) &&
                                !interfere(rstate, range, insd->lr)) {
                                phi = insd;
                        }
                        if (insd->lr->color == REG_UNSET) {
                                continue;
                        }
                        regcm = insd->lr->classes;
                        if (((regcm & range->classes) == 0) ||
                                (used[insd->lr->color])) {
                                continue;
                        }
                        if (interfere(rstate, range, insd->lr)) {
                                continue;
                        }
                        range->color = insd->lr->color;
                }
        }
        /* If I feed into a phi function reuse it's color or the color
         * of something else that feeds into the phi function.
         */
        if (phi) {
                if (phi->lr->color != REG_UNSET) {
                        if (used[phi->lr->color]) {
                                range->color = phi->lr->color;
                        }
                }
                else {
                        expr = triple_rhs(state, phi->def, 0);
                        for(; expr; expr = triple_rhs(state, phi->def, expr)) {
                                struct live_range *lr;
                                unsigned regcm;
                                if (!*expr) {
                                        continue;
                                }
                                lr = rstate->lrd[(*expr)->id].lr;
                                if (lr->color == REG_UNSET) {
                                        continue;
                                }
                                regcm = lr->classes;
                                if (((regcm & range->classes) == 0) ||
                                        (used[lr->color])) {
                                        continue;
                                }
                                if (interfere(rstate, range, lr)) {
                                        continue;
                                }
                                range->color = lr->color;
                        }
                }
        }
        /* If I don't interfere with a rhs node reuse it's color */
        lrd = live_range_head(state, range, 0);
        for(; (range->color == REG_UNSET) && lrd ; lrd = live_range_head(state, range, lrd)) {
                expr = triple_rhs(state, lrd->def, 0);
                for(; expr; expr = triple_rhs(state, lrd->def, expr)) {
                        struct live_range *lr;
                        unsigned regcm;
                        if (!*expr) {
                                continue;
                        }
                        lr = rstate->lrd[(*expr)->id].lr;
                        if (lr->color == REG_UNSET) {
                                continue;
                        }
                        regcm = lr->classes;
                        if (((regcm & range->classes) == 0) ||
                                (used[lr->color])) {
                                continue;
                        }
                        if (interfere(rstate, range, lr)) {
                                continue;
                        }
                        range->color = lr->color;
                        break;
                }
        }
        /* If I have not opportunitically picked a useful color
         * pick the first color that is free.
         */
        if (range->color == REG_UNSET) {
                range->color = 
                        arch_select_free_register(state, used, range->classes);
        }
        if (range->color == REG_UNSET) {
                struct live_range_def *lrd;
                int i;
                if (split_ranges(state, rstate, used, range)) {
                        return 0;
                }
                for(edge = range->edges; edge; edge = edge->next) {
                        warning(state, edge->node->defs->def, "edge reg %s",
                                arch_reg_str(edge->node->color));
                        lrd = edge->node->defs;
                        do {
                                warning(state, lrd->def, " %s %p",
                                        tops(lrd->def->op), lrd->def);
                                lrd = lrd->next;
                        } while(lrd != edge->node->defs);
                }
                warning(state, range->defs->def, "range: ");
                lrd = range->defs;
                do {
                        warning(state, lrd->def, " %s %p",
                                tops(lrd->def->op), lrd->def);
                        lrd = lrd->next;
                } while(lrd != range->defs);
                        
                warning(state, range->defs->def, "classes: %x",
                        range->classes);
                for(i = 0; i < MAX_REGISTERS; i++) {
                        if (used[i]) {
                                warning(state, range->defs->def, "used: %s",
                                        arch_reg_str(i));
                        }
                }
                error(state, range->defs->def, "too few registers");
        }
        range->classes &= arch_reg_regcm(state, range->color);
        if ((range->color == REG_UNSET) || (range->classes == 0)) {
                internal_error(state, range->defs->def, "select_free_color did not?");
        }
        return 1;
}

static int color_graph(struct compile_state *state, struct reg_state *rstate)
{
        int colored;
        struct live_range_edge *edge;
        struct live_range *range;
        if (rstate->low) {
                cgdebug_printf(state, "Lo: ");
                range = rstate->low;
                if (*range->group_prev != range) {
                        internal_error(state, 0, "lo: *prev != range?");
                }
                *range->group_prev = range->group_next;
                if (range->group_next) {
                        range->group_next->group_prev = range->group_prev;
                }
                if (&range->group_next == rstate->low_tail) {
                        rstate->low_tail = range->group_prev;
                }
                if (rstate->low == range) {
                        internal_error(state, 0, "low: next != prev?");
                }
        }
        else if (rstate->high) {
                cgdebug_printf(state, "Hi: ");
                range = rstate->high;
                if (*range->group_prev != range) {
                        internal_error(state, 0, "hi: *prev != range?");
                }
                *range->group_prev = range->group_next;
                if (range->group_next) {
                        range->group_next->group_prev = range->group_prev;
                }
                if (&range->group_next == rstate->high_tail) {
                        rstate->high_tail = range->group_prev;
                }
                if (rstate->high == range) {
                        internal_error(state, 0, "high: next != prev?");
                }
        }
        else {
                return 1;
        }
        cgdebug_printf(state, " %d\n", range - rstate->lr);
        range->group_prev = 0;
        for(edge = range->edges; edge; edge = edge->next) {
                struct live_range *node;
                node = edge->node;
                /* Move nodes from the high to the low list */
                if (node->group_prev && (node->color == REG_UNSET) &&
                        (node->degree == regc_max_size(state, node->classes))) {
                        if (*node->group_prev != node) {
                                internal_error(state, 0, "move: *prev != node?");
                        }
                        *node->group_prev = node->group_next;
                        if (node->group_next) {
                                node->group_next->group_prev = node->group_prev;
                        }
                        if (&node->group_next == rstate->high_tail) {
                                rstate->high_tail = node->group_prev;
                        }
                        cgdebug_printf(state, "Moving...%d to low\n", node - rstate->lr);
                        node->group_prev  = rstate->low_tail;
                        node->group_next  = 0;
                        *rstate->low_tail = node;
                        rstate->low_tail  = &node->group_next;
                        if (*node->group_prev != node) {
                                internal_error(state, 0, "move2: *prev != node?");
                        }
                }
                node->degree -= 1;
        }
        colored = color_graph(state, rstate);
        if (colored) {
                cgdebug_printf(state, "Coloring %d @", range - rstate->lr);
                cgdebug_loc(state, range->defs->def);
                cgdebug_flush(state);
                colored = select_free_color(state, rstate, range);
                if (colored) {
                        cgdebug_printf(state, " %s\n", arch_reg_str(range->color));
                }
        }
        return colored;
}

static void verify_colors(struct compile_state *state, struct reg_state *rstate)
{
        struct live_range *lr;
        struct live_range_edge *edge;
        struct triple *ins, *first;
        char used[MAX_REGISTERS];
        first = state->first;
        ins = first;
        do {
                if (triple_is_def(state, ins)) {
                        if ((ins->id < 0) || (ins->id > rstate->defs)) {
                                internal_error(state, ins, 
                                        "triple without a live range def");
                        }
                        lr = rstate->lrd[ins->id].lr;
                        if (lr->color == REG_UNSET) {
                                internal_error(state, ins,
                                        "triple without a color");
                        }
                        /* Find the registers used by the edges */
                        memset(used, 0, sizeof(used));
                        for(edge = lr->edges; edge; edge = edge->next) {
                                if (edge->node->color == REG_UNSET) {
                                        internal_error(state, 0,
                                                "live range without a color");
                        }
                                reg_fill_used(state, used, edge->node->color);
                        }
                        if (used[lr->color]) {
                                internal_error(state, ins,
                                        "triple with already used color");
                        }
                }
                ins = ins->next;
        } while(ins != first);
}

static void color_triples(struct compile_state *state, struct reg_state *rstate)
{
        struct live_range_def *lrd;
        struct live_range *lr;
        struct triple *first, *ins;
        first = state->first;
        ins = first;
        do {
                if ((ins->id < 0) || (ins->id > rstate->defs)) {
                        internal_error(state, ins, 
                                "triple without a live range");
                }
                lrd = &rstate->lrd[ins->id];
                lr = lrd->lr;
                ins->id = lrd->orig_id;
                SET_REG(ins->id, lr->color);
                ins = ins->next;
        } while (ins != first);
}

static struct live_range *merge_sort_lr(
        struct live_range *first, struct live_range *last)
{
        struct live_range *mid, *join, **join_tail, *pick;
        size_t size;
        size = (last - first) + 1;
        if (size >= 2) {
                mid = first + size/2;
                first = merge_sort_lr(first, mid -1);
                mid   = merge_sort_lr(mid, last);
                
                join = 0;
                join_tail = &join;
                /* merge the two lists */
                while(first && mid) {
                        if ((first->degree < mid->degree) ||
                                ((first->degree == mid->degree) &&
                                        (first->length < mid->length))) {
                                pick = first;
                                first = first->group_next;
                                if (first) {
                                        first->group_prev = 0;
                                }
                        }
                        else {
                                pick = mid;
                                mid = mid->group_next;
                                if (mid) {
                                        mid->group_prev = 0;
                                }
                        }
                        pick->group_next = 0;
                        pick->group_prev = join_tail;
                        *join_tail = pick;
                        join_tail = &pick->group_next;
                }
                /* Splice the remaining list */
                pick = (first)? first : mid;
                *join_tail = pick;
                if (pick) { 
                        pick->group_prev = join_tail;
                }
        }
        else {
                if (!first->defs) {
                        first = 0;
                }
                join = first;
        }
        return join;
}

static void ids_from_rstate(struct compile_state *state, 
        struct reg_state *rstate)
{
        struct triple *ins, *first;
        if (!rstate->defs) {
                return;
        }
        /* Display the graph if desired */
        if (state->compiler->debug & DEBUG_INTERFERENCE) {
                FILE *fp = state->dbgout;
                print_interference_blocks(state, rstate, fp, 0);
                print_control_flow(state, fp, &state->bb);
                fflush(fp);
        }
        first = state->first;
        ins = first;
        do {
                if (ins->id) {
                        struct live_range_def *lrd;
                        lrd = &rstate->lrd[ins->id];
                        ins->id = lrd->orig_id;
                }
                ins = ins->next;
        } while(ins != first);
}

static void cleanup_live_edges(struct reg_state *rstate)
{
        int i;
        /* Free the edges on each node */
        for(i = 1; i <= rstate->ranges; i++) {
                remove_live_edges(rstate, &rstate->lr[i]);
        }
}

static void cleanup_rstate(struct compile_state *state, struct reg_state *rstate)
{
        cleanup_live_edges(rstate);
        xfree(rstate->lrd);
        xfree(rstate->lr);

        /* Free the variable lifetime information */
        if (rstate->blocks) {
                free_variable_lifetimes(state, &state->bb, rstate->blocks);
        }
        rstate->defs = 0;
        rstate->ranges = 0;
        rstate->lrd = 0;
        rstate->lr = 0;
        rstate->blocks = 0;
}

static void verify_consistency(struct compile_state *state);
static void allocate_registers(struct compile_state *state)
{
        struct reg_state rstate;
        int colored;

        /* Clear out the reg_state */
        memset(&rstate, 0, sizeof(rstate));
        rstate.max_passes = state->compiler->max_allocation_passes;

        do {
                struct live_range **point, **next;
                int conflicts;
                int tangles;
                int coalesced;

                if (state->compiler->debug & DEBUG_RANGE_CONFLICTS) {
                        FILE *fp = state->errout;
                        fprintf(fp, "pass: %d\n", rstate.passes);
                        fflush(fp);
                }

                /* Restore ids */
                ids_from_rstate(state, &rstate);

                /* Cleanup the temporary data structures */
                cleanup_rstate(state, &rstate);

                /* Compute the variable lifetimes */
                rstate.blocks = compute_variable_lifetimes(state, &state->bb);

                /* Fix invalid mandatory live range coalesce conflicts */
                conflicts = correct_coalesce_conflicts(state, rstate.blocks);

                /* Fix two simultaneous uses of the same register.
                 * In a few pathlogical cases a partial untangle moves
                 * the tangle to a part of the graph we won't revisit.
                 * So we keep looping until we have no more tangle fixes
                 * to apply.
                 */
                do {
                        tangles = correct_tangles(state, rstate.blocks);
                } while(tangles);

                
                print_blocks(state, "resolve_tangles", state->dbgout);
                verify_consistency(state);
                
                /* Allocate and initialize the live ranges */
                initialize_live_ranges(state, &rstate);

                /* Note currently doing coalescing in a loop appears to 
                 * buys me nothing.  The code is left this way in case
                 * there is some value in it.  Or if a future bugfix
                 * yields some benefit.
                 */
                do {
                        if (state->compiler->debug & DEBUG_COALESCING) {
                                fprintf(state->errout, "coalescing\n");
                        }

                        /* Remove any previous live edge calculations */
                        cleanup_live_edges(&rstate);

                        /* Compute the interference graph */
                        walk_variable_lifetimes(
                                state, &state->bb, rstate.blocks, 
                                graph_ins, &rstate);
                        
                        /* Display the interference graph if desired */
                        if (state->compiler->debug & DEBUG_INTERFERENCE) {
                                print_interference_blocks(state, &rstate, state->dbgout, 1);
                                fprintf(state->dbgout, "\nlive variables by instruction\n");
                                walk_variable_lifetimes(
                                        state, &state->bb, rstate.blocks, 
                                        print_interference_ins, &rstate);
                        }
                        
                        coalesced = coalesce_live_ranges(state, &rstate);

                        if (state->compiler->debug & DEBUG_COALESCING) {
                                fprintf(state->errout, "coalesced: %d\n", coalesced);
                        }
                } while(coalesced);

#if DEBUG_CONSISTENCY > 1
# if 0
                fprintf(state->errout, "verify_graph_ins...\n");
# endif
                /* Verify the interference graph */
                walk_variable_lifetimes(
                        state, &state->bb, rstate.blocks, 
                        verify_graph_ins, &rstate);
# if 0
                fprintf(state->errout, "verify_graph_ins done\n");
#endif
#endif
                        
                /* Build the groups low and high.  But with the nodes
                 * first sorted by degree order.
                 */
                rstate.low_tail  = &rstate.low;
                rstate.high_tail = &rstate.high;
                rstate.high = merge_sort_lr(&rstate.lr[1], &rstate.lr[rstate.ranges]);
                if (rstate.high) {
                        rstate.high->group_prev = &rstate.high;
                }
                for(point = &rstate.high; *point; point = &(*point)->group_next)
                        ;
                rstate.high_tail = point;
                /* Walk through the high list and move everything that needs
                 * to be onto low.
                 */
                for(point = &rstate.high; *point; point = next) {
                        struct live_range *range;
                        next = &(*point)->group_next;
                        range = *point;
                        
                        /* If it has a low degree or it already has a color
                         * place the node in low.
                         */
                        if ((range->degree < regc_max_size(state, range->classes)) ||
                                (range->color != REG_UNSET)) {
                                cgdebug_printf(state, "Lo: %5d degree %5d%s\n", 
                                        range - rstate.lr, range->degree,
                                        (range->color != REG_UNSET) ? " (colored)": "");
                                *range->group_prev = range->group_next;
                                if (range->group_next) {
                                        range->group_next->group_prev = range->group_prev;
                                }
                                if (&range->group_next == rstate.high_tail) {
                                        rstate.high_tail = range->group_prev;
                                }
                                range->group_prev  = rstate.low_tail;
                                range->group_next  = 0;
                                *rstate.low_tail   = range;
                                rstate.low_tail    = &range->group_next;
                                next = point;
                        }
                        else {
                                cgdebug_printf(state, "hi: %5d degree %5d%s\n", 
                                        range - rstate.lr, range->degree,
                                        (range->color != REG_UNSET) ? " (colored)": "");
                        }
                }
                /* Color the live_ranges */
                colored = color_graph(state, &rstate);
                rstate.passes++;
        } while (!colored);

        /* Verify the graph was properly colored */
        verify_colors(state, &rstate);

        /* Move the colors from the graph to the triples */
        color_triples(state, &rstate);

        /* Cleanup the temporary data structures */
        cleanup_rstate(state, &rstate);

        /* Display the new graph */
        print_blocks(state, __func__, state->dbgout);
}

/* Sparce Conditional Constant Propogation
 * =========================================
 */
struct ssa_edge;
struct flow_block;
struct lattice_node {
        unsigned old_id;
        struct triple *def;
        struct ssa_edge *out;
        struct flow_block *fblock;
        struct triple *val;
        /* lattice high   val == def
         * lattice const  is_const(val)
         * lattice low    other
         */
};
struct ssa_edge {
        struct lattice_node *src;
        struct lattice_node *dst;
        struct ssa_edge *work_next;
        struct ssa_edge *work_prev;
        struct ssa_edge *out_next;
};
struct flow_edge {
        struct flow_block *src;
        struct flow_block *dst;
        struct flow_edge *work_next;
        struct flow_edge *work_prev;
        struct flow_edge *in_next;
        struct flow_edge *out_next;
        int executable;
};
#define MAX_FLOW_BLOCK_EDGES 3
struct flow_block {
        struct block *block;
        struct flow_edge *in;
        struct flow_edge *out;
        struct flow_edge *edges;
};

struct scc_state {
        int ins_count;
        struct lattice_node *lattice;
        struct ssa_edge     *ssa_edges;
        struct flow_block   *flow_blocks;
        struct flow_edge    *flow_work_list;
        struct ssa_edge     *ssa_work_list;
};


static int is_scc_const(struct compile_state *state, struct triple *ins)
{
        return ins && (triple_is_ubranch(state, ins) || is_const(ins));
}

static int is_lattice_hi(struct compile_state *state, struct lattice_node *lnode)
{
        return !is_scc_const(state, lnode->val) && (lnode->val == lnode->def);
}

static int is_lattice_const(struct compile_state *state, struct lattice_node *lnode)
{
        return is_scc_const(state, lnode->val);
}

static int is_lattice_lo(struct compile_state *state, struct lattice_node *lnode)
{
        return (lnode->val != lnode->def) && !is_scc_const(state, lnode->val);
}

static void scc_add_fedge(struct compile_state *state, struct scc_state *scc, 
        struct flow_edge *fedge)
{
        if (state->compiler->debug & DEBUG_SCC_TRANSFORM2) {
                fprintf(state->errout, "adding fedge: %p (%4d -> %5d)\n",
                        fedge,
                        fedge->src->block?fedge->src->block->last->id: 0,
                        fedge->dst->block?fedge->dst->block->first->id: 0);
        }
        if ((fedge == scc->flow_work_list) ||
                (fedge->work_next != fedge) ||
                (fedge->work_prev != fedge)) {

                if (state->compiler->debug & DEBUG_SCC_TRANSFORM2) {
                        fprintf(state->errout, "dupped fedge: %p\n",
                                fedge);
                }
                return;
        }
        if (!scc->flow_work_list) {
                scc->flow_work_list = fedge;
                fedge->work_next = fedge->work_prev = fedge;
        }
        else {
                struct flow_edge *ftail;
                ftail = scc->flow_work_list->work_prev;
                fedge->work_next = ftail->work_next;
                fedge->work_prev = ftail;
                fedge->work_next->work_prev = fedge;
                fedge->work_prev->work_next = fedge;
        }
}

static struct flow_edge *scc_next_fedge(
        struct compile_state *state, struct scc_state *scc)
{
        struct flow_edge *fedge;
        fedge = scc->flow_work_list;
        if (fedge) {
                fedge->work_next->work_prev = fedge->work_prev;
                fedge->work_prev->work_next = fedge->work_next;
                if (fedge->work_next != fedge) {
                        scc->flow_work_list = fedge->work_next;
                } else {
                        scc->flow_work_list = 0;
                }
                fedge->work_next = fedge->work_prev = fedge;
        }
        return fedge;
}

static void scc_add_sedge(struct compile_state *state, struct scc_state *scc,
        struct ssa_edge *sedge)
{
        if (state->compiler->debug & DEBUG_SCC_TRANSFORM2) {
                fprintf(state->errout, "adding sedge: %5d (%4d -> %5d)\n",
                        sedge - scc->ssa_edges,
                        sedge->src->def->id,
                        sedge->dst->def->id);
        }
        if ((sedge == scc->ssa_work_list) ||
                (sedge->work_next != sedge) ||
                (sedge->work_prev != sedge)) {

                if (state->compiler->debug & DEBUG_SCC_TRANSFORM2) {
                        fprintf(state->errout, "dupped sedge: %5d\n",
                                sedge - scc->ssa_edges);
                }
                return;
        }
        if (!scc->ssa_work_list) {
                scc->ssa_work_list = sedge;
                sedge->work_next = sedge->work_prev = sedge;
        }
        else {
                struct ssa_edge *stail;
                stail = scc->ssa_work_list->work_prev;
                sedge->work_next = stail->work_next;
                sedge->work_prev = stail;
                sedge->work_next->work_prev = sedge;
                sedge->work_prev->work_next = sedge;
        }
}

static struct ssa_edge *scc_next_sedge(
        struct compile_state *state, struct scc_state *scc)
{
        struct ssa_edge *sedge;
        sedge = scc->ssa_work_list;
        if (sedge) {
                sedge->work_next->work_prev = sedge->work_prev;
                sedge->work_prev->work_next = sedge->work_next;
                if (sedge->work_next != sedge) {
                        scc->ssa_work_list = sedge->work_next;
                } else {
                        scc->ssa_work_list = 0;
                }
                sedge->work_next = sedge->work_prev = sedge;
        }
        return sedge;
}

static void initialize_scc_state(
        struct compile_state *state, struct scc_state *scc)
{
        int ins_count, ssa_edge_count;
        int ins_index, ssa_edge_index, fblock_index;
        struct triple *first, *ins;
        struct block *block;
        struct flow_block *fblock;

        memset(scc, 0, sizeof(*scc));

        /* Inialize pass zero find out how much memory we need */
        first = state->first;
        ins = first;
        ins_count = ssa_edge_count = 0;
        do {
                struct triple_set *edge;
                ins_count += 1;
                for(edge = ins->use; edge; edge = edge->next) {
                        ssa_edge_count++;
                }
                ins = ins->next;
        } while(ins != first);
        if (state->compiler->debug & DEBUG_SCC_TRANSFORM) {
                fprintf(state->errout, "ins_count: %d ssa_edge_count: %d vertex_count: %d\n",
                        ins_count, ssa_edge_count, state->bb.last_vertex);
        }
        scc->ins_count   = ins_count;
        scc->lattice     = 
                xcmalloc(sizeof(*scc->lattice)*(ins_count + 1), "lattice");
        scc->ssa_edges   = 
                xcmalloc(sizeof(*scc->ssa_edges)*(ssa_edge_count + 1), "ssa_edges");
        scc->flow_blocks = 
                xcmalloc(sizeof(*scc->flow_blocks)*(state->bb.last_vertex + 1), 
                        "flow_blocks");

        /* Initialize pass one collect up the nodes */
        fblock = 0;
        block = 0;
        ins_index = ssa_edge_index = fblock_index = 0;
        ins = first;
        do {
                if ((ins->op == OP_LABEL) && (block != ins->u.block)) {
                        block = ins->u.block;
                        if (!block) {
                                internal_error(state, ins, "label without block");
                        }
                        fblock_index += 1;
                        block->vertex = fblock_index;
                        fblock = &scc->flow_blocks[fblock_index];
                        fblock->block = block;
                        fblock->edges = xcmalloc(sizeof(*fblock->edges)*block->edge_count,
                                "flow_edges");
                }
                {
                        struct lattice_node *lnode;
                        ins_index += 1;
                        lnode = &scc->lattice[ins_index];
                        lnode->def = ins;
                        lnode->out = 0;
                        lnode->fblock = fblock;
                        lnode->val = ins; /* LATTICE HIGH */
                        if (lnode->val->op == OP_UNKNOWNVAL) {
                                lnode->val = 0; /* LATTICE LOW by definition */
                        }
                        lnode->old_id = ins->id;
                        ins->id = ins_index;
                }
                ins = ins->next;
        } while(ins != first);
        /* Initialize pass two collect up the edges */
        block = 0;
        fblock = 0;
        ins = first;
        do {
                {
                        struct triple_set *edge;
                        struct ssa_edge **stail;
                        struct lattice_node *lnode;
                        lnode = &scc->lattice[ins->id];
                        lnode->out = 0;
                        stail = &lnode->out;
                        for(edge = ins->use; edge; edge = edge->next) {
                                struct ssa_edge *sedge;
                                ssa_edge_index += 1;
                                sedge = &scc->ssa_edges[ssa_edge_index];
                                *stail = sedge;
                                stail = &sedge->out_next;
                                sedge->src = lnode;
                                sedge->dst = &scc->lattice[edge->member->id];
                                sedge->work_next = sedge->work_prev = sedge;
                                sedge->out_next = 0;
                        }
                }
                if ((ins->op == OP_LABEL) && (block != ins->u.block)) {
                        struct flow_edge *fedge, **ftail;
                        struct block_set *bedge;
                        block = ins->u.block;
                        fblock = &scc->flow_blocks[block->vertex];
                        fblock->in = 0;
                        fblock->out = 0;
                        ftail = &fblock->out;

                        fedge = fblock->edges;
                        bedge = block->edges;
                        for(; bedge; bedge = bedge->next, fedge++) {
                                fedge->dst = &scc->flow_blocks[bedge->member->vertex];
                                if (fedge->dst->block != bedge->member) {
                                        internal_error(state, 0, "block mismatch");
                                }
                                *ftail = fedge;
                                ftail = &fedge->out_next;
                                fedge->out_next = 0;
                        }
                        for(fedge = fblock->out; fedge; fedge = fedge->out_next) {
                                fedge->src = fblock;
                                fedge->work_next = fedge->work_prev = fedge;
                                fedge->executable = 0;
                        }
                }
                ins = ins->next;
        } while (ins != first);
        block = 0;
        fblock = 0;
        ins = first;
        do {
                if ((ins->op  == OP_LABEL) && (block != ins->u.block)) {
                        struct flow_edge **ftail;
                        struct block_set *bedge;
                        block = ins->u.block;
                        fblock = &scc->flow_blocks[block->vertex];
                        ftail = &fblock->in;
                        for(bedge = block->use; bedge; bedge = bedge->next) {
                                struct block *src_block;
                                struct flow_block *sfblock;
                                struct flow_edge *sfedge;
                                src_block = bedge->member;
                                sfblock = &scc->flow_blocks[src_block->vertex];
                                for(sfedge = sfblock->out; sfedge; sfedge = sfedge->out_next) {
                                        if (sfedge->dst == fblock) {
                                                break;
                                        }
                                }
                                if (!sfedge) {
                                        internal_error(state, 0, "edge mismatch");
                                }
                                *ftail = sfedge;
                                ftail = &sfedge->in_next;
                                sfedge->in_next = 0;
                        }
                }
                ins = ins->next;
        } while(ins != first);
        /* Setup a dummy block 0 as a node above the start node */
        {
                struct flow_block *fblock, *dst;
                struct flow_edge *fedge;
                fblock = &scc->flow_blocks[0];
                fblock->block = 0;
                fblock->edges = xcmalloc(sizeof(*fblock->edges)*1, "flow_edges");
                fblock->in = 0;
                fblock->out = fblock->edges;
                dst = &scc->flow_blocks[state->bb.first_block->vertex];
                fedge = fblock->edges;
                fedge->src        = fblock;
                fedge->dst        = dst;
                fedge->work_next  = fedge;
                fedge->work_prev  = fedge;
                fedge->in_next    = fedge->dst->in;
                fedge->out_next   = 0;
                fedge->executable = 0;
                fedge->dst->in = fedge;
                
                /* Initialize the work lists */
                scc->flow_work_list = 0;
                scc->ssa_work_list  = 0;
                scc_add_fedge(state, scc, fedge);
        }
        if (state->compiler->debug & DEBUG_SCC_TRANSFORM) {
                fprintf(state->errout, "ins_index: %d ssa_edge_index: %d fblock_index: %d\n",
                        ins_index, ssa_edge_index, fblock_index);
        }
}

        
static void free_scc_state(
        struct compile_state *state, struct scc_state *scc)
{
        int i;
        for(i = 0; i < state->bb.last_vertex + 1; i++) {
                struct flow_block *fblock;
                fblock = &scc->flow_blocks[i];
                if (fblock->edges) {
                        xfree(fblock->edges);
                        fblock->edges = 0;
                }
        }
        xfree(scc->flow_blocks);
        xfree(scc->ssa_edges);
        xfree(scc->lattice);
        
}

static struct lattice_node *triple_to_lattice(
        struct compile_state *state, struct scc_state *scc, struct triple *ins)
{
        if (ins->id <= 0) {
                internal_error(state, ins, "bad id");
        }
        return &scc->lattice[ins->id];
}

static struct triple *preserve_lval(
        struct compile_state *state, struct lattice_node *lnode)
{
        struct triple *old;
        /* Preserve the original value */
        if (lnode->val) {
                old = dup_triple(state, lnode->val);
                if (lnode->val != lnode->def) {
                        xfree(lnode->val);
                }
                lnode->val = 0;
        } else {
                old = 0;
        }
        return old;
}

static int lval_changed(struct compile_state *state, 
        struct triple *old, struct lattice_node *lnode)
{
        int changed;
        /* See if the lattice value has changed */
        changed = 1;
        if (!old && !lnode->val) {
                changed = 0;
        }
        if (changed &&
                lnode->val && old &&
                (memcmp(lnode->val->param, old->param,
                        TRIPLE_SIZE(lnode->val) * sizeof(lnode->val->param[0])) == 0) &&
                (memcmp(&lnode->val->u, &old->u, sizeof(old->u)) == 0)) {
                changed = 0;
        }
        if (old) {
                xfree(old);
        }
        return changed;

}

static void scc_debug_lnode(
        struct compile_state *state, struct scc_state *scc,
        struct lattice_node *lnode, int changed)
{
        if ((state->compiler->debug & DEBUG_SCC_TRANSFORM2) && lnode->val) {
                display_triple_changes(state->errout, lnode->val, lnode->def);
        }
        if (state->compiler->debug & DEBUG_SCC_TRANSFORM) {
                FILE *fp = state->errout;
                struct triple *val, **expr;
                val = lnode->val? lnode->val : lnode->def;
                fprintf(fp, "%p %s %3d %10s (",
                        lnode->def, 
                        ((lnode->def->op == OP_PHI)? "phi: ": "expr:"),
                        lnode->def->id,
                        tops(lnode->def->op));
                expr = triple_rhs(state, lnode->def, 0);
                for(;expr;expr = triple_rhs(state, lnode->def, expr)) {
                        if (*expr) {
                                fprintf(fp, " %d", (*expr)->id);
                        }
                }
                if (val->op == OP_INTCONST) {
                        fprintf(fp, " <0x%08lx>", (unsigned long)(val->u.cval));
                }
                fprintf(fp, " ) -> %s %s\n",
                        (is_lattice_hi(state, lnode)? "hi":
                                is_lattice_const(state, lnode)? "const" : "lo"),
                        changed? "changed" : ""
                        );
        }
}

static int compute_lnode_val(struct compile_state *state, struct scc_state *scc,
        struct lattice_node *lnode)
{
        int changed;
        struct triple *old, *scratch;
        struct triple **dexpr, **vexpr;
        int count, i;
        
        /* Store the original value */
        old = preserve_lval(state, lnode);

        /* Reinitialize the value */
        lnode->val = scratch = dup_triple(state, lnode->def);
        scratch->id = lnode->old_id;
        scratch->next     = scratch;
        scratch->prev     = scratch;
        scratch->use      = 0;

        count = TRIPLE_SIZE(scratch);
        for(i = 0; i < count; i++) {
                dexpr = &lnode->def->param[i];
                vexpr = &scratch->param[i];
                *vexpr = *dexpr;
                if (((i < TRIPLE_MISC_OFF(scratch)) ||
                        (i >= TRIPLE_TARG_OFF(scratch))) &&
                        *dexpr) {
                        struct lattice_node *tmp;
                        tmp = triple_to_lattice(state, scc, *dexpr);
                        *vexpr = (tmp->val)? tmp->val : tmp->def;
                }
        }
        if (triple_is_branch(state, scratch)) {
                scratch->next = lnode->def->next;
        }
        /* Recompute the value */
#warning "FIXME see if simplify does anything bad"
        /* So far it looks like only the strength reduction
         * optimization are things I need to worry about.
         */
        simplify(state, scratch);
        /* Cleanup my value */
        if (scratch->use) {
                internal_error(state, lnode->def, "scratch used?");
        }
        if ((scratch->prev != scratch) ||
                ((scratch->next != scratch) &&
                        (!triple_is_branch(state, lnode->def) ||
                                (scratch->next != lnode->def->next)))) {
                internal_error(state, lnode->def, "scratch in list?");
        }
        /* undo any uses... */
        count = TRIPLE_SIZE(scratch);
        for(i = 0; i < count; i++) {
                vexpr = &scratch->param[i];
                if (*vexpr) {
                        unuse_triple(*vexpr, scratch);
                }
        }
        if (lnode->val->op == OP_UNKNOWNVAL) {
                lnode->val = 0; /* Lattice low by definition */
        }
        /* Find the case when I am lattice high */
        if (lnode->val && 
                (lnode->val->op == lnode->def->op) &&
                (memcmp(lnode->val->param, lnode->def->param, 
                        count * sizeof(lnode->val->param[0])) == 0) &&
                (memcmp(&lnode->val->u, &lnode->def->u, sizeof(lnode->def->u)) == 0)) {
                lnode->val = lnode->def;
        }
        /* Only allow lattice high when all of my inputs
         * are also lattice high.  Occassionally I can
         * have constants with a lattice low input, so
         * I do not need to check that case.
         */
        if (is_lattice_hi(state, lnode)) {
                struct lattice_node *tmp;
                int rhs;
                rhs = lnode->val->rhs;
                for(i = 0; i < rhs; i++) {
                        tmp = triple_to_lattice(state, scc, RHS(lnode->val, i));
                        if (!is_lattice_hi(state, tmp)) {
                                lnode->val = 0;
                                break;
                        }
                }
        }
        /* Find the cases that are always lattice lo */
        if (lnode->val && 
                triple_is_def(state, lnode->val) &&
                !triple_is_pure(state, lnode->val, lnode->old_id)) {
                lnode->val = 0;
        }
        /* See if the lattice value has changed */
        changed = lval_changed(state, old, lnode);
        /* See if this value should not change */
        if ((lnode->val != lnode->def) && 
                ((      !triple_is_def(state, lnode->def)  &&
                        !triple_is_cbranch(state, lnode->def)) ||
                        (lnode->def->op == OP_PIECE))) {
#warning "FIXME constant propogate through expressions with multiple left hand sides"
                if (changed) {
                        internal_warning(state, lnode->def, "non def changes value?");
                }
                lnode->val = 0;
        }

        /* See if we need to free the scratch value */
        if (lnode->val != scratch) {
                xfree(scratch);
        }
        
        return changed;
}


static void scc_visit_cbranch(struct compile_state *state, struct scc_state *scc,
        struct lattice_node *lnode)
{
        struct lattice_node *cond;
        struct flow_edge *left, *right;
        int changed;

        /* Update the branch value */
        changed = compute_lnode_val(state, scc, lnode);
        scc_debug_lnode(state, scc, lnode, changed);

        /* This only applies to conditional branches */
        if (!triple_is_cbranch(state, lnode->def)) {
                internal_error(state, lnode->def, "not a conditional branch");
        }

        if (state->compiler->debug & DEBUG_SCC_TRANSFORM) {
                struct flow_edge *fedge;
                FILE *fp = state->errout;
                fprintf(fp, "%s: %d (",
                        tops(lnode->def->op),
                        lnode->def->id);
                
                for(fedge = lnode->fblock->out; fedge; fedge = fedge->out_next) {
                        fprintf(fp, " %d", fedge->dst->block->vertex);
                }
                fprintf(fp, " )");
                if (lnode->def->rhs > 0) {
                        fprintf(fp, " <- %d",
                                RHS(lnode->def, 0)->id);
                }
                fprintf(fp, "\n");
        }
        cond = triple_to_lattice(state, scc, RHS(lnode->def,0));
        for(left = cond->fblock->out; left; left = left->out_next) {
                if (left->dst->block->first == lnode->def->next) {
                        break;
                }
        }
        if (!left) {
                internal_error(state, lnode->def, "Cannot find left branch edge");
        }
        for(right = cond->fblock->out; right; right = right->out_next) {
                if (right->dst->block->first == TARG(lnode->def, 0)) {
                        break;
                }
        }
        if (!right) {
                internal_error(state, lnode->def, "Cannot find right branch edge");
        }
        /* I should only come here if the controlling expressions value
         * has changed, which means it must be either a constant or lo.
         */
        if (is_lattice_hi(state, cond)) {
                internal_error(state, cond->def, "condition high?");
                return;
        }
        if (is_lattice_lo(state, cond)) {
                scc_add_fedge(state, scc, left);
                scc_add_fedge(state, scc, right);
        }
        else if (cond->val->u.cval) {
                scc_add_fedge(state, scc, right);
        } else {
                scc_add_fedge(state, scc, left);
        }

}


static void scc_add_sedge_dst(struct compile_state *state, 
        struct scc_state *scc, struct ssa_edge *sedge)
{
        if (triple_is_cbranch(state, sedge->dst->def)) {
                scc_visit_cbranch(state, scc, sedge->dst);
        }
        else if (triple_is_def(state, sedge->dst->def)) {
                scc_add_sedge(state, scc, sedge);
        }
}

static void scc_visit_phi(struct compile_state *state, struct scc_state *scc, 
        struct lattice_node *lnode)
{
        struct lattice_node *tmp;
        struct triple **slot, *old;
        struct flow_edge *fedge;
        int changed;
        int index;
        if (lnode->def->op != OP_PHI) {
                internal_error(state, lnode->def, "not phi");
        }
        /* Store the original value */
        old = preserve_lval(state, lnode);

        /* default to lattice high */
        lnode->val = lnode->def;
        slot = &RHS(lnode->def, 0);
        index = 0;
        for(fedge = lnode->fblock->in; fedge; index++, fedge = fedge->in_next) {
                if (state->compiler->debug & DEBUG_SCC_TRANSFORM) {
                        fprintf(state->errout, "Examining edge: %d vertex: %d executable: %d\n", 
                                index,
                                fedge->dst->block->vertex,
                                fedge->executable
                                );
                }
                if (!fedge->executable) {
                        continue;
                }
                if (!slot[index]) {
                        internal_error(state, lnode->def, "no phi value");
                }
                tmp = triple_to_lattice(state, scc, slot[index]);
                /* meet(X, lattice low) = lattice low */
                if (is_lattice_lo(state, tmp)) {
                        lnode->val = 0;
                }
                /* meet(X, lattice high) = X */
                else if (is_lattice_hi(state, tmp)) {
                        lnode->val = lnode->val;
                }
                /* meet(lattice high, X) = X */
                else if (is_lattice_hi(state, lnode)) {
                        lnode->val = dup_triple(state, tmp->val);
                        /* Only change the type if necessary */
                        if (!is_subset_type(lnode->def->type, tmp->val->type)) {
                                lnode->val->type = lnode->def->type;
                        }
                }
                /* meet(const, const) = const or lattice low */
                else if (!constants_equal(state, lnode->val, tmp->val)) {
                        lnode->val = 0;
                }

                /* meet(lattice low, X) = lattice low */
                if (is_lattice_lo(state, lnode)) {
                        lnode->val = 0;
                        break;
                }
        }
        changed = lval_changed(state, old, lnode);
        scc_debug_lnode(state, scc, lnode, changed);

        /* If the lattice value has changed update the work lists. */
        if (changed) {
                struct ssa_edge *sedge;
                for(sedge = lnode->out; sedge; sedge = sedge->out_next) {
                        scc_add_sedge_dst(state, scc, sedge);
                }
        }
}


static void scc_visit_expr(struct compile_state *state, struct scc_state *scc,
        struct lattice_node *lnode)
{
        int changed;

        if (!triple_is_def(state, lnode->def)) {
                internal_warning(state, lnode->def, "not visiting an expression?");
        }
        changed = compute_lnode_val(state, scc, lnode);
        scc_debug_lnode(state, scc, lnode, changed);

        if (changed) {
                struct ssa_edge *sedge;
                for(sedge = lnode->out; sedge; sedge = sedge->out_next) {
                        scc_add_sedge_dst(state, scc, sedge);
                }
        }
}

static void scc_writeback_values(
        struct compile_state *state, struct scc_state *scc)
{
        struct triple *first, *ins;
        first = state->first;
        ins = first;
        do {
                struct lattice_node *lnode;
                lnode = triple_to_lattice(state, scc, ins);
                if (state->compiler->debug & DEBUG_SCC_TRANSFORM) {
                        if (is_lattice_hi(state, lnode) &&
                                (lnode->val->op != OP_NOOP))
                        {
                                struct flow_edge *fedge;
                                int executable;
                                executable = 0;
                                for(fedge = lnode->fblock->in; 
                                    !executable && fedge; fedge = fedge->in_next) {
                                        executable |= fedge->executable;
                                }
                                if (executable) {
                                        internal_warning(state, lnode->def,
                                                "lattice node %d %s->%s still high?",
                                                ins->id, 
                                                tops(lnode->def->op),
                                                tops(lnode->val->op));
                                }
                        }
                }

                /* Restore id */
                ins->id = lnode->old_id;
                if (lnode->val && (lnode->val != ins)) {
                        /* See if it something I know how to write back */
                        switch(lnode->val->op) {
                        case OP_INTCONST:
                                mkconst(state, ins, lnode->val->u.cval);
                                break;
                        case OP_ADDRCONST:
                                mkaddr_const(state, ins, 
                                        MISC(lnode->val, 0), lnode->val->u.cval);
                                break;
                        default:
                                /* By default don't copy the changes,
                                 * recompute them in place instead.
                                 */
                                simplify(state, ins);
                                break;
                        }
                        if (is_const(lnode->val) &&
                                !constants_equal(state, lnode->val, ins)) {
                                internal_error(state, 0, "constants not equal");
                        }
                        /* Free the lattice nodes */
                        xfree(lnode->val);
                        lnode->val = 0;
                }
                ins = ins->next;
        } while(ins != first);
}

static void scc_transform(struct compile_state *state)
{
        struct scc_state scc;
        if (!(state->compiler->flags & COMPILER_SCC_TRANSFORM)) {
                return;
        }

        initialize_scc_state(state, &scc);

        while(scc.flow_work_list || scc.ssa_work_list) {
                struct flow_edge *fedge;
                struct ssa_edge *sedge;
                struct flow_edge *fptr;
                while((fedge = scc_next_fedge(state, &scc))) {
                        struct block *block;
                        struct triple *ptr;
                        struct flow_block *fblock;
                        int reps;
                        int done;
                        if (fedge->executable) {
                                continue;
                        }
                        if (!fedge->dst) {
                                internal_error(state, 0, "fedge without dst");
                        }
                        if (!fedge->src) {
                                internal_error(state, 0, "fedge without src");
                        }
                        fedge->executable = 1;
                        fblock = fedge->dst;
                        block = fblock->block;
                        reps = 0;
                        for(fptr = fblock->in; fptr; fptr = fptr->in_next) {
                                if (fptr->executable) {
                                        reps++;
                                }
                        }
                        
                        if (state->compiler->debug & DEBUG_SCC_TRANSFORM) {
                                fprintf(state->errout, "vertex: %d reps: %d\n", 
                                        block->vertex, reps);
                        }

                        done = 0;
                        for(ptr = block->first; !done; ptr = ptr->next) {
                                struct lattice_node *lnode;
                                done = (ptr == block->last);
                                lnode = &scc.lattice[ptr->id];
                                if (ptr->op == OP_PHI) {
                                        scc_visit_phi(state, &scc, lnode);
                                }
                                else if ((reps == 1) && triple_is_def(state, ptr))
                                {
                                        scc_visit_expr(state, &scc, lnode);
                                }
                        }
                        /* Add unconditional branch edges */
                        if (!triple_is_cbranch(state, fblock->block->last)) {
                                struct flow_edge *out;
                                for(out = fblock->out; out; out = out->out_next) {
                                        scc_add_fedge(state, &scc, out);
                                }
                        }
                }
                while((sedge = scc_next_sedge(state, &scc))) {
                        struct lattice_node *lnode;
                        struct flow_block *fblock;
                        lnode = sedge->dst;
                        fblock = lnode->fblock;

                        if (state->compiler->debug & DEBUG_SCC_TRANSFORM) {
                                fprintf(state->errout, "sedge: %5d (%5d -> %5d)\n",
                                        sedge - scc.ssa_edges,
                                        sedge->src->def->id,
                                        sedge->dst->def->id);
                        }

                        if (lnode->def->op == OP_PHI) {
                                scc_visit_phi(state, &scc, lnode);
                        }
                        else {
                                for(fptr = fblock->in; fptr; fptr = fptr->in_next) {
                                        if (fptr->executable) {
                                                break;
                                        }
                                }
                                if (fptr) {
                                        scc_visit_expr(state, &scc, lnode);
                                }
                        }
                }
        }
        
        scc_writeback_values(state, &scc);
        free_scc_state(state, &scc);
        rebuild_ssa_form(state);
        
        print_blocks(state, __func__, state->dbgout);
}


static void transform_to_arch_instructions(struct compile_state *state)
{
        struct triple *ins, *first;
        first = state->first;
        ins = first;
        do {
                ins = transform_to_arch_instruction(state, ins);
        } while(ins != first);
        
        print_blocks(state, __func__, state->dbgout);
}

#if DEBUG_CONSISTENCY
static void verify_uses(struct compile_state *state)
{
        struct triple *first, *ins;
        struct triple_set *set;
        first = state->first;
        ins = first;
        do {
                struct triple **expr;
                expr = triple_rhs(state, ins, 0);
                for(; expr; expr = triple_rhs(state, ins, expr)) {
                        struct triple *rhs;
                        rhs = *expr;
                        for(set = rhs?rhs->use:0; set; set = set->next) {
                                if (set->member == ins) {
                                        break;
                                }
                        }
                        if (!set) {
                                internal_error(state, ins, "rhs not used");
                        }
                }
                expr = triple_lhs(state, ins, 0);
                for(; expr; expr = triple_lhs(state, ins, expr)) {
                        struct triple *lhs;
                        lhs = *expr;
                        for(set =  lhs?lhs->use:0; set; set = set->next) {
                                if (set->member == ins) {
                                        break;
                                }
                        }
                        if (!set) {
                                internal_error(state, ins, "lhs not used");
                        }
                }
                expr = triple_misc(state, ins, 0);
                if (ins->op != OP_PHI) {
                        for(; expr; expr = triple_targ(state, ins, expr)) {
                                struct triple *misc;
                                misc = *expr;
                                for(set = misc?misc->use:0; set; set = set->next) {
                                        if (set->member == ins) {
                                                break;
                                        }
                                }
                                if (!set) {
                                        internal_error(state, ins, "misc not used");
                                }
                        }
                }
                if (!triple_is_ret(state, ins)) {
                        expr = triple_targ(state, ins, 0);
                        for(; expr; expr = triple_targ(state, ins, expr)) {
                                struct triple *targ;
                                targ = *expr;
                                for(set = targ?targ->use:0; set; set = set->next) {
                                        if (set->member == ins) {
                                                break;
                                        }
                                }
                                if (!set) {
                                        internal_error(state, ins, "targ not used");
                                }
                        }
                }
                ins = ins->next;
        } while(ins != first);
        
}
static void verify_blocks_present(struct compile_state *state)
{
        struct triple *first, *ins;
        if (!state->bb.first_block) {
                return;
        }
        first = state->first;
        ins = first;
        do {
                valid_ins(state, ins);
                if (triple_stores_block(state, ins)) {
                        if (!ins->u.block) {
                                internal_error(state, ins, 
                                        "%p not in a block?", ins);
                        }
                }
                ins = ins->next;
        } while(ins != first);
        
        
}

static int edge_present(struct compile_state *state, struct block *block, struct triple *edge)
{
        struct block_set *bedge;
        struct block *targ;
        targ = block_of_triple(state, edge);
        for(bedge = block->edges; bedge; bedge = bedge->next) {
                if (bedge->member == targ) {
                        return 1;
                }
        }
        return 0;
}

static void verify_blocks(struct compile_state *state)
{
        struct triple *ins;
        struct block *block;
        int blocks;
        block = state->bb.first_block;
        if (!block) {
                return;
        }
        blocks = 0;
        do {
                int users;
                struct block_set *user, *edge;
                blocks++;
                for(ins = block->first; ins != block->last->next; ins = ins->next) {
                        if (triple_stores_block(state, ins) && (ins->u.block != block)) {
                                internal_error(state, ins, "inconsitent block specified");
                        }
                        valid_ins(state, ins);
                }
                users = 0;
                for(user = block->use; user; user = user->next) {
                        users++;
                        if (!user->member->first) {
                                internal_error(state, block->first, "user is empty");
                        }
                        if ((block == state->bb.last_block) &&
                                (user->member == state->bb.first_block)) {
                                continue;
                        }
                        for(edge = user->member->edges; edge; edge = edge->next) {
                                if (edge->member == block) {
                                        break;
                                }
                        }
                        if (!edge) {
                                internal_error(state, user->member->first,
                                        "user does not use block");
                        }
                }
                if (triple_is_branch(state, block->last)) {
                        struct triple **expr;
                        expr = triple_edge_targ(state, block->last, 0);
                        for(;expr; expr = triple_edge_targ(state, block->last, expr)) {
                                if (*expr && !edge_present(state, block, *expr)) {
                                        internal_error(state, block->last, "no edge to targ");
                                }
                        }
                }
                if (!triple_is_ubranch(state, block->last) &&
                        (block != state->bb.last_block) &&
                        !edge_present(state, block, block->last->next)) {
                        internal_error(state, block->last, "no edge to block->last->next");
                }
                for(edge = block->edges; edge; edge = edge->next) {
                        for(user = edge->member->use; user; user = user->next) {
                                if (user->member == block) {
                                        break;
                                }
                        }
                        if (!user || user->member != block) {
                                internal_error(state, block->first,
                                        "block does not use edge");
                        }
                        if (!edge->member->first) {
                                internal_error(state, block->first, "edge block is empty");
                        }
                }
                if (block->users != users) {
                        internal_error(state, block->first, 
                                "computed users %d != stored users %d",
                                users, block->users);
                }
                if (!triple_stores_block(state, block->last->next)) {
                        internal_error(state, block->last->next, 
                                "cannot find next block");
                }
                block = block->last->next->u.block;
                if (!block) {
                        internal_error(state, block->last->next,
                                "bad next block");
                }
        } while(block != state->bb.first_block);
        if (blocks != state->bb.last_vertex) {
                internal_error(state, 0, "computed blocks: %d != stored blocks %d",
                        blocks, state->bb.last_vertex);
        }
}

static void verify_domination(struct compile_state *state)
{
        struct triple *first, *ins;
        struct triple_set *set;
        if (!state->bb.first_block) {
                return;
        }
        
        first = state->first;
        ins = first;
        do {
                for(set = ins->use; set; set = set->next) {
                        struct triple **slot;
                        struct triple *use_point;
                        int i, zrhs;
                        use_point = 0;
                        zrhs = set->member->rhs;
                        slot = &RHS(set->member, 0);
                        /* See if the use is on the right hand side */
                        for(i = 0; i < zrhs; i++) {
                                if (slot[i] == ins) {
                                        break;
                                }
                        }
                        if (i < zrhs) {
                                use_point = set->member;
                                if (set->member->op == OP_PHI) {
                                        struct block_set *bset;
                                        int edge;
                                        bset = set->member->u.block->use;
                                        for(edge = 0; bset && (edge < i); edge++) {
                                                bset = bset->next;
                                        }
                                        if (!bset) {
                                                internal_error(state, set->member, 
                                                        "no edge for phi rhs %d", i);
                                        }
                                        use_point = bset->member->last;
                                }
                        }
                        if (use_point &&
                                !tdominates(state, ins, use_point)) {
                                if (is_const(ins)) {
                                        internal_warning(state, ins, 
                                        "non dominated rhs use point %p?", use_point);
                                }
                                else {
                                        internal_error(state, ins, 
                                                "non dominated rhs use point %p?", use_point);
                                }
                        }
                }
                ins = ins->next;
        } while(ins != first);
}

static void verify_rhs(struct compile_state *state)
{
        struct triple *first, *ins;
        first = state->first;
        ins = first;
        do {
                struct triple **slot;
                int zrhs, i;
                zrhs = ins->rhs;
                slot = &RHS(ins, 0);
                for(i = 0; i < zrhs; i++) {
                        if (slot[i] == 0) {
                                internal_error(state, ins,
                                        "missing rhs %d on %s",
                                        i, tops(ins->op));
                        }
                        if ((ins->op != OP_PHI) && (slot[i] == ins)) {
                                internal_error(state, ins,
                                        "ins == rhs[%d] on %s",
                                        i, tops(ins->op));
                        }
                }
                ins = ins->next;
        } while(ins != first);
}

static void verify_piece(struct compile_state *state)
{
        struct triple *first, *ins;
        first = state->first;
        ins = first;
        do {
                struct triple *ptr;
                int lhs, i;
                lhs = ins->lhs;
                for(ptr = ins->next, i = 0; i < lhs; i++, ptr = ptr->next) {
                        if (ptr != LHS(ins, i)) {
                                internal_error(state, ins, "malformed lhs on %s",
                                        tops(ins->op));
                        }
                        if (ptr->op != OP_PIECE) {
                                internal_error(state, ins, "bad lhs op %s at %d on %s",
                                        tops(ptr->op), i, tops(ins->op));
                        }
                        if (ptr->u.cval != i) {
                                internal_error(state, ins, "bad u.cval of %d %d expected",
                                        ptr->u.cval, i);
                        }
                }
                ins = ins->next;
        } while(ins != first);
}

static void verify_ins_colors(struct compile_state *state)
{
        struct triple *first, *ins;
        
        first = state->first;
        ins = first;
        do {
                ins = ins->next;
        } while(ins != first);
}

static void verify_unknown(struct compile_state *state)
{
        struct triple *first, *ins;
        if (    (unknown_triple.next != &unknown_triple) ||
                (unknown_triple.prev != &unknown_triple) ||
#if 0
                (unknown_triple.use != 0) ||
#endif
                (unknown_triple.op != OP_UNKNOWNVAL) ||
                (unknown_triple.lhs != 0) ||
                (unknown_triple.rhs != 0) ||
                (unknown_triple.misc != 0) ||
                (unknown_triple.targ != 0) ||
                (unknown_triple.template_id != 0) ||
                (unknown_triple.id != -1) ||
                (unknown_triple.type != &unknown_type) ||
                (unknown_triple.occurance != &dummy_occurance) ||
                (unknown_triple.param[0] != 0) ||
                (unknown_triple.param[1] != 0)) {
                internal_error(state, &unknown_triple, "unknown_triple corrupted!");
        }
        if (    (dummy_occurance.count != 2) ||
                (strcmp(dummy_occurance.filename, __FILE__) != 0) ||
                (strcmp(dummy_occurance.function, "") != 0) ||
                (dummy_occurance.col != 0) ||
                (dummy_occurance.parent != 0)) {
                internal_error(state, &unknown_triple, "dummy_occurance corrupted!");
        }
        if (    (unknown_type.type != TYPE_UNKNOWN)) {
                internal_error(state, &unknown_triple, "unknown_type corrupted!");
        }
        first = state->first;
        ins = first;
        do {
                int params, i;
                if (ins == &unknown_triple) {
                        internal_error(state, ins, "unknown triple in list");
                }
                params = TRIPLE_SIZE(ins);
                for(i = 0; i < params; i++) {
                        if (ins->param[i] == &unknown_triple) {
                                internal_error(state, ins, "unknown triple used!");
                        }
                }
                ins = ins->next;
        } while(ins != first);
}

static void verify_types(struct compile_state *state)
{
        struct triple *first, *ins;
        first = state->first;
        ins = first;
        do {
                struct type *invalid;
                invalid = invalid_type(state, ins->type);
                if (invalid) {
                        FILE *fp = state->errout;
                        fprintf(fp, "type: ");
                        name_of(fp, ins->type);
                        fprintf(fp, "\n");
                        fprintf(fp, "invalid type: ");
                        name_of(fp, invalid);
                        fprintf(fp, "\n");
                        internal_error(state, ins, "invalid ins type");
                }
        } while(ins != first);
}

static void verify_copy(struct compile_state *state)
{
        struct triple *first, *ins, *next;
        first = state->first;
        next = ins = first;
        do {
                ins = next;
                next = ins->next;
                if (ins->op != OP_COPY) {
                        continue;
                }
                if (!equiv_types(ins->type, RHS(ins, 0)->type)) {
                        FILE *fp = state->errout;
                        fprintf(fp, "src type: ");
                        name_of(fp, RHS(ins, 0)->type);
                        fprintf(fp, "\n");
                        fprintf(fp, "dst type: ");
                        name_of(fp, ins->type);
                        fprintf(fp, "\n");
                        internal_error(state, ins, "type mismatch in copy");
                }
        } while(next != first);
}

static void verify_consistency(struct compile_state *state)
{
        verify_unknown(state);
        verify_uses(state);
        verify_blocks_present(state);
        verify_blocks(state);
        verify_domination(state);
        verify_rhs(state);
        verify_piece(state);
        verify_ins_colors(state);
        verify_types(state);
        verify_copy(state);
        if (state->compiler->debug & DEBUG_VERIFICATION) {
                fprintf(state->dbgout, "consistency verified\n");
        }
}
#else 
static void verify_consistency(struct compile_state *state) {}
#endif /* DEBUG_CONSISTENCY */

static void optimize(struct compile_state *state)
{
        /* Join all of the functions into one giant function */
        join_functions(state);

        /* Dump what the instruction graph intially looks like */
        print_triples(state);

        /* Replace structures with simpler data types */
        decompose_compound_types(state);
        print_triples(state);

        verify_consistency(state);
        /* Analyze the intermediate code */
        state->bb.first = state->first;
        analyze_basic_blocks(state, &state->bb);

        /* Transform the code to ssa form. */
        /*
         * The transformation to ssa form puts a phi function
         * on each of edge of a dominance frontier where that
         * phi function might be needed.  At -O2 if we don't
         * eleminate the excess phi functions we can get an
         * exponential code size growth.  So I kill the extra
         * phi functions early and I kill them often.
         */
        transform_to_ssa_form(state);
        verify_consistency(state);

        /* Remove dead code */
        eliminate_inefectual_code(state);
        verify_consistency(state);

        /* Do strength reduction and simple constant optimizations */
        simplify_all(state);
        verify_consistency(state);
        /* Propogate constants throughout the code */
        scc_transform(state);
        verify_consistency(state);
#warning "WISHLIST implement single use constants (least possible register pressure)"
#warning "WISHLIST implement induction variable elimination"
        /* Select architecture instructions and an initial partial
         * coloring based on architecture constraints.
         */
        transform_to_arch_instructions(state);
        verify_consistency(state);

        /* Remove dead code */
        eliminate_inefectual_code(state);
        verify_consistency(state);

        /* Color all of the variables to see if they will fit in registers */
        insert_copies_to_phi(state);
        verify_consistency(state);

        insert_mandatory_copies(state);
        verify_consistency(state);

        allocate_registers(state);
        verify_consistency(state);

        /* Remove the optimization information.
         * This is more to check for memory consistency than to free memory.
         */
        free_basic_blocks(state, &state->bb);
}

static void print_op_asm(struct compile_state *state,
        struct triple *ins, FILE *fp)
{
        struct asm_info *info;
        const char *ptr;
        unsigned lhs, rhs, i;
        info = ins->u.ainfo;
        lhs = ins->lhs;
        rhs = ins->rhs;
        /* Don't count the clobbers in lhs */
        for(i = 0; i < lhs; i++) {
                if (LHS(ins, i)->type == &void_type) {
                        break;
                }
        }
        lhs = i;
        fprintf(fp, "#ASM\n");
        fputc('\t', fp);
        for(ptr = info->str; *ptr; ptr++) {
                char *next;
                unsigned long param;
                struct triple *piece;
                if (*ptr != '%') {
                        fputc(*ptr, fp);
                        continue;
                }
                ptr++;
                if (*ptr == '%') {
                        fputc('%', fp);
                        continue;
                }
                param = strtoul(ptr, &next, 10);
                if (ptr == next) {
                        error(state, ins, "Invalid asm template");
                }
                if (param >= (lhs + rhs)) {
                        error(state, ins, "Invalid param %%%u in asm template",
                                param);
                }
                piece = (param < lhs)? LHS(ins, param) : RHS(ins, param - lhs);
                fprintf(fp, "%s", 
                        arch_reg_str(ID_REG(piece->id)));
                ptr = next -1;
        }
        fprintf(fp, "\n#NOT ASM\n");
}


/* Only use the low x86 byte registers.  This allows me
 * allocate the entire register when a byte register is used.
 */
#define X86_4_8BIT_GPRS 1

/* x86 featrues */
#define X86_MMX_REGS  (1<<0)
#define X86_XMM_REGS  (1<<1)
#define X86_NOOP_COPY (1<<2)

/* The x86 register classes */
#define REGC_FLAGS       0
#define REGC_GPR8        1
#define REGC_GPR16       2
#define REGC_GPR32       3
#define REGC_DIVIDEND64  4
#define REGC_DIVIDEND32  5
#define REGC_MMX         6
#define REGC_XMM         7
#define REGC_GPR32_8     8
#define REGC_GPR16_8     9
#define REGC_GPR8_LO    10
#define REGC_IMM32      11
#define REGC_IMM16      12
#define REGC_IMM8       13
#define LAST_REGC  REGC_IMM8
#if LAST_REGC >= MAX_REGC
#error "MAX_REGC is to low"
#endif

/* Register class masks */
#define REGCM_FLAGS      (1 << REGC_FLAGS)
#define REGCM_GPR8       (1 << REGC_GPR8)
#define REGCM_GPR16      (1 << REGC_GPR16)
#define REGCM_GPR32      (1 << REGC_GPR32)
#define REGCM_DIVIDEND64 (1 << REGC_DIVIDEND64)
#define REGCM_DIVIDEND32 (1 << REGC_DIVIDEND32)
#define REGCM_MMX        (1 << REGC_MMX)
#define REGCM_XMM        (1 << REGC_XMM)
#define REGCM_GPR32_8    (1 << REGC_GPR32_8)
#define REGCM_GPR16_8    (1 << REGC_GPR16_8)
#define REGCM_GPR8_LO    (1 << REGC_GPR8_LO)
#define REGCM_IMM32      (1 << REGC_IMM32)
#define REGCM_IMM16      (1 << REGC_IMM16)
#define REGCM_IMM8       (1 << REGC_IMM8)
#define REGCM_ALL        ((1 << (LAST_REGC + 1)) - 1)
#define REGCM_IMMALL    (REGCM_IMM32 | REGCM_IMM16 | REGCM_IMM8)

/* The x86 registers */
#define REG_EFLAGS  2
#define REGC_FLAGS_FIRST REG_EFLAGS
#define REGC_FLAGS_LAST  REG_EFLAGS
#define REG_AL      3
#define REG_BL      4
#define REG_CL      5
#define REG_DL      6
#define REG_AH      7
#define REG_BH      8
#define REG_CH      9
#define REG_DH      10
#define REGC_GPR8_LO_FIRST REG_AL
#define REGC_GPR8_LO_LAST  REG_DL
#define REGC_GPR8_FIRST  REG_AL
#define REGC_GPR8_LAST   REG_DH
#define REG_AX     11
#define REG_BX     12
#define REG_CX     13
#define REG_DX     14
#define REG_SI     15
#define REG_DI     16
#define REG_BP     17
#define REG_SP     18
#define REGC_GPR16_FIRST REG_AX
#define REGC_GPR16_LAST  REG_SP
#define REG_EAX    19
#define REG_EBX    20
#define REG_ECX    21
#define REG_EDX    22
#define REG_ESI    23
#define REG_EDI    24
#define REG_EBP    25
#define REG_ESP    26
#define REGC_GPR32_FIRST REG_EAX
#define REGC_GPR32_LAST  REG_ESP
#define REG_EDXEAX 27
#define REGC_DIVIDEND64_FIRST REG_EDXEAX
#define REGC_DIVIDEND64_LAST  REG_EDXEAX
#define REG_DXAX   28
#define REGC_DIVIDEND32_FIRST REG_DXAX
#define REGC_DIVIDEND32_LAST  REG_DXAX
#define REG_MMX0   29
#define REG_MMX1   30
#define REG_MMX2   31
#define REG_MMX3   32
#define REG_MMX4   33
#define REG_MMX5   34
#define REG_MMX6   35
#define REG_MMX7   36
#define REGC_MMX_FIRST REG_MMX0
#define REGC_MMX_LAST  REG_MMX7
#define REG_XMM0   37
#define REG_XMM1   38
#define REG_XMM2   39
#define REG_XMM3   40
#define REG_XMM4   41
#define REG_XMM5   42
#define REG_XMM6   43
#define REG_XMM7   44
#define REGC_XMM_FIRST REG_XMM0
#define REGC_XMM_LAST  REG_XMM7
#warning "WISHLIST figure out how to use pinsrw and pextrw to better use extended regs"
#define LAST_REG   REG_XMM7

#define REGC_GPR32_8_FIRST REG_EAX
#define REGC_GPR32_8_LAST  REG_EDX
#define REGC_GPR16_8_FIRST REG_AX
#define REGC_GPR16_8_LAST  REG_DX

#define REGC_IMM8_FIRST    -1
#define REGC_IMM8_LAST     -1
#define REGC_IMM16_FIRST   -2
#define REGC_IMM16_LAST    -1
#define REGC_IMM32_FIRST   -4
#define REGC_IMM32_LAST    -1

#if LAST_REG >= MAX_REGISTERS
#error "MAX_REGISTERS to low"
#endif


static unsigned regc_size[LAST_REGC +1] = {
        [REGC_FLAGS]      = REGC_FLAGS_LAST      - REGC_FLAGS_FIRST + 1,
        [REGC_GPR8]       = REGC_GPR8_LAST       - REGC_GPR8_FIRST + 1,
        [REGC_GPR16]      = REGC_GPR16_LAST      - REGC_GPR16_FIRST + 1,
        [REGC_GPR32]      = REGC_GPR32_LAST      - REGC_GPR32_FIRST + 1,
        [REGC_DIVIDEND64] = REGC_DIVIDEND64_LAST - REGC_DIVIDEND64_FIRST + 1,
        [REGC_DIVIDEND32] = REGC_DIVIDEND32_LAST - REGC_DIVIDEND32_FIRST + 1,
        [REGC_MMX]        = REGC_MMX_LAST        - REGC_MMX_FIRST + 1,
        [REGC_XMM]        = REGC_XMM_LAST        - REGC_XMM_FIRST + 1,
        [REGC_GPR32_8]    = REGC_GPR32_8_LAST    - REGC_GPR32_8_FIRST + 1,
        [REGC_GPR16_8]    = REGC_GPR16_8_LAST    - REGC_GPR16_8_FIRST + 1,
        [REGC_GPR8_LO]    = REGC_GPR8_LO_LAST    - REGC_GPR8_LO_FIRST + 1,
        [REGC_IMM32]      = 0,
        [REGC_IMM16]      = 0,
        [REGC_IMM8]       = 0,
};

static const struct {
        int first, last;
} regcm_bound[LAST_REGC + 1] = {
        [REGC_FLAGS]      = { REGC_FLAGS_FIRST,      REGC_FLAGS_LAST },
        [REGC_GPR8]       = { REGC_GPR8_FIRST,       REGC_GPR8_LAST },
        [REGC_GPR16]      = { REGC_GPR16_FIRST,      REGC_GPR16_LAST },
        [REGC_GPR32]      = { REGC_GPR32_FIRST,      REGC_GPR32_LAST },
        [REGC_DIVIDEND64] = { REGC_DIVIDEND64_FIRST, REGC_DIVIDEND64_LAST },
        [REGC_DIVIDEND32] = { REGC_DIVIDEND32_FIRST, REGC_DIVIDEND32_LAST },
        [REGC_MMX]        = { REGC_MMX_FIRST,        REGC_MMX_LAST },
        [REGC_XMM]        = { REGC_XMM_FIRST,        REGC_XMM_LAST },
        [REGC_GPR32_8]    = { REGC_GPR32_8_FIRST,    REGC_GPR32_8_LAST },
        [REGC_GPR16_8]    = { REGC_GPR16_8_FIRST,    REGC_GPR16_8_LAST },
        [REGC_GPR8_LO]    = { REGC_GPR8_LO_FIRST,    REGC_GPR8_LO_LAST },
        [REGC_IMM32]      = { REGC_IMM32_FIRST,      REGC_IMM32_LAST },
        [REGC_IMM16]      = { REGC_IMM16_FIRST,      REGC_IMM16_LAST },
        [REGC_IMM8]       = { REGC_IMM8_FIRST,       REGC_IMM8_LAST },
};

#if ARCH_INPUT_REGS != 4
#error ARCH_INPUT_REGS size mismatch
#endif
static const struct reg_info arch_input_regs[ARCH_INPUT_REGS] = {
        { .reg = REG_EAX, .regcm = REGCM_GPR32 },
        { .reg = REG_EBX, .regcm = REGCM_GPR32 },
        { .reg = REG_ECX, .regcm = REGCM_GPR32 },
        { .reg = REG_EDX, .regcm = REGCM_GPR32 },
};

#if ARCH_OUTPUT_REGS != 4
#error ARCH_INPUT_REGS size mismatch
#endif
static const struct reg_info arch_output_regs[ARCH_OUTPUT_REGS] = {
        { .reg = REG_EAX, .regcm = REGCM_GPR32 },
        { .reg = REG_EBX, .regcm = REGCM_GPR32 },
        { .reg = REG_ECX, .regcm = REGCM_GPR32 },
        { .reg = REG_EDX, .regcm = REGCM_GPR32 },
};

static void init_arch_state(struct arch_state *arch)
{
        memset(arch, 0, sizeof(*arch));
        arch->features = 0;
}

static const struct compiler_flag arch_flags[] = {
        { "mmx",       X86_MMX_REGS },
        { "sse",       X86_XMM_REGS },
        { "noop-copy", X86_NOOP_COPY },
        { 0,     0 },
};
static const struct compiler_flag arch_cpus[] = {
        { "i386", 0 },
        { "p2",   X86_MMX_REGS },
        { "p3",   X86_MMX_REGS | X86_XMM_REGS },
        { "p4",   X86_MMX_REGS | X86_XMM_REGS },
        { "k7",   X86_MMX_REGS },
        { "k8",   X86_MMX_REGS | X86_XMM_REGS },
        { "c3",   X86_MMX_REGS },
        { "c3-2", X86_MMX_REGS | X86_XMM_REGS }, /* Nehemiah */
        {  0,     0 }
};
static int arch_encode_flag(struct arch_state *arch, const char *flag)
{
        int result;
        int act;

        act = 1;
        result = -1;
        if (strncmp(flag, "no-", 3) == 0) {
                flag += 3;
                act = 0;
        }
        if (act && strncmp(flag, "cpu=", 4) == 0) {
                flag += 4;
                result = set_flag(arch_cpus, &arch->features, 1, flag);
        }
        else {
                result = set_flag(arch_flags, &arch->features, act, flag);
        }
        return result;
}

static void arch_usage(FILE *fp)
{
        flag_usage(fp, arch_flags, "-m", "-mno-");
        flag_usage(fp, arch_cpus, "-mcpu=", 0);
}

static unsigned arch_regc_size(struct compile_state *state, int class)
{
        if ((class < 0) || (class > LAST_REGC)) {
                return 0;
        }
        return regc_size[class];
}

static int arch_regcm_intersect(unsigned regcm1, unsigned regcm2)
{
        /* See if two register classes may have overlapping registers */
        unsigned gpr_mask = REGCM_GPR8 | REGCM_GPR8_LO | REGCM_GPR16_8 | REGCM_GPR16 |
                REGCM_GPR32_8 | REGCM_GPR32 | 
                REGCM_DIVIDEND32 | REGCM_DIVIDEND64;

        /* Special case for the immediates */
        if ((regcm1 & (REGCM_IMM32 | REGCM_IMM16 | REGCM_IMM8)) &&
                ((regcm1 & ~(REGCM_IMM32 | REGCM_IMM16 | REGCM_IMM8)) == 0) &&
                (regcm2 & (REGCM_IMM32 | REGCM_IMM16 | REGCM_IMM8)) &&
                ((regcm2 & ~(REGCM_IMM32 | REGCM_IMM16 | REGCM_IMM8)) == 0)) { 
                return 0;
        }
        return (regcm1 & regcm2) ||
                ((regcm1 & gpr_mask) && (regcm2 & gpr_mask));
}

static void arch_reg_equivs(
        struct compile_state *state, unsigned *equiv, int reg)
{
        if ((reg < 0) || (reg > LAST_REG)) {
                internal_error(state, 0, "invalid register");
        }
        *equiv++ = reg;
        switch(reg) {
        case REG_AL:
#if X86_4_8BIT_GPRS
                *equiv++ = REG_AH;
#endif
                *equiv++ = REG_AX;
                *equiv++ = REG_EAX;
                *equiv++ = REG_DXAX;
                *equiv++ = REG_EDXEAX;
                break;
        case REG_AH:
#if X86_4_8BIT_GPRS
                *equiv++ = REG_AL;
#endif
                *equiv++ = REG_AX;
                *equiv++ = REG_EAX;
                *equiv++ = REG_DXAX;
                *equiv++ = REG_EDXEAX;
                break;
        case REG_BL:  
#if X86_4_8BIT_GPRS
                *equiv++ = REG_BH;
#endif
                *equiv++ = REG_BX;
                *equiv++ = REG_EBX;
                break;

        case REG_BH:
#if X86_4_8BIT_GPRS
                *equiv++ = REG_BL;
#endif
                *equiv++ = REG_BX;
                *equiv++ = REG_EBX;
                break;
        case REG_CL:
#if X86_4_8BIT_GPRS
                *equiv++ = REG_CH;
#endif
                *equiv++ = REG_CX;
                *equiv++ = REG_ECX;
                break;

        case REG_CH:
#if X86_4_8BIT_GPRS
                *equiv++ = REG_CL;
#endif
                *equiv++ = REG_CX;
                *equiv++ = REG_ECX;
                break;
        case REG_DL:
#if X86_4_8BIT_GPRS
                *equiv++ = REG_DH;
#endif
                *equiv++ = REG_DX;
                *equiv++ = REG_EDX;
                *equiv++ = REG_DXAX;
                *equiv++ = REG_EDXEAX;
                break;
        case REG_DH:
#if X86_4_8BIT_GPRS
                *equiv++ = REG_DL;
#endif
                *equiv++ = REG_DX;
                *equiv++ = REG_EDX;
                *equiv++ = REG_DXAX;
                *equiv++ = REG_EDXEAX;
                break;
        case REG_AX:
                *equiv++ = REG_AL;
                *equiv++ = REG_AH;
                *equiv++ = REG_EAX;
                *equiv++ = REG_DXAX;
                *equiv++ = REG_EDXEAX;
                break;
        case REG_BX:
                *equiv++ = REG_BL;
                *equiv++ = REG_BH;
                *equiv++ = REG_EBX;
                break;
        case REG_CX:  
                *equiv++ = REG_CL;
                *equiv++ = REG_CH;
                *equiv++ = REG_ECX;
                break;
        case REG_DX:  
                *equiv++ = REG_DL;
                *equiv++ = REG_DH;
                *equiv++ = REG_EDX;
                *equiv++ = REG_DXAX;
                *equiv++ = REG_EDXEAX;
                break;
        case REG_SI:  
                *equiv++ = REG_ESI;
                break;
        case REG_DI:
                *equiv++ = REG_EDI;
                break;
        case REG_BP:
                *equiv++ = REG_EBP;
                break;
        case REG_SP:
                *equiv++ = REG_ESP;
                break;
        case REG_EAX:
                *equiv++ = REG_AL;
                *equiv++ = REG_AH;
                *equiv++ = REG_AX;
                *equiv++ = REG_DXAX;
                *equiv++ = REG_EDXEAX;
                break;
        case REG_EBX:
                *equiv++ = REG_BL;
                *equiv++ = REG_BH;
                *equiv++ = REG_BX;
                break;
        case REG_ECX:
                *equiv++ = REG_CL;
                *equiv++ = REG_CH;
                *equiv++ = REG_CX;
                break;
        case REG_EDX:
                *equiv++ = REG_DL;
                *equiv++ = REG_DH;
                *equiv++ = REG_DX;
                *equiv++ = REG_DXAX;
                *equiv++ = REG_EDXEAX;
                break;
        case REG_ESI: 
                *equiv++ = REG_SI;
                break;
        case REG_EDI: 
                *equiv++ = REG_DI;
                break;
        case REG_EBP: 
                *equiv++ = REG_BP;
                break;
        case REG_ESP: 
                *equiv++ = REG_SP;
                break;
        case REG_DXAX: 
                *equiv++ = REG_AL;
                *equiv++ = REG_AH;
                *equiv++ = REG_DL;
                *equiv++ = REG_DH;
                *equiv++ = REG_AX;
                *equiv++ = REG_DX;
                *equiv++ = REG_EAX;
                *equiv++ = REG_EDX;
                *equiv++ = REG_EDXEAX;
                break;
        case REG_EDXEAX: 
                *equiv++ = REG_AL;
                *equiv++ = REG_AH;
                *equiv++ = REG_DL;
                *equiv++ = REG_DH;
                *equiv++ = REG_AX;
                *equiv++ = REG_DX;
                *equiv++ = REG_EAX;
                *equiv++ = REG_EDX;
                *equiv++ = REG_DXAX;
                break;
        }
        *equiv++ = REG_UNSET; 
}

static unsigned arch_avail_mask(struct compile_state *state)
{
        unsigned avail_mask;
        /* REGCM_GPR8 is not available */
        avail_mask = REGCM_GPR8_LO | REGCM_GPR16_8 | REGCM_GPR16 | 
                REGCM_GPR32 | REGCM_GPR32_8 | 
                REGCM_DIVIDEND32 | REGCM_DIVIDEND64 |
                REGCM_IMM32 | REGCM_IMM16 | REGCM_IMM8 | REGCM_FLAGS;
        if (state->arch->features & X86_MMX_REGS) {
                avail_mask |= REGCM_MMX;
        }
        if (state->arch->features & X86_XMM_REGS) {
                avail_mask |= REGCM_XMM;
        }
        return avail_mask;
}

static unsigned arch_regcm_normalize(struct compile_state *state, unsigned regcm)
{
        unsigned mask, result;
        int class, class2;
        result = regcm;

        for(class = 0, mask = 1; mask; mask <<= 1, class++) {
                if ((result & mask) == 0) {
                        continue;
                }
                if (class > LAST_REGC) {
                        result &= ~mask;
                }
                for(class2 = 0; class2 <= LAST_REGC; class2++) {
                        if ((regcm_bound[class2].first >= regcm_bound[class].first) &&
                                (regcm_bound[class2].last <= regcm_bound[class].last)) {
                                result |= (1 << class2);
                        }
                }
        }
        result &= arch_avail_mask(state);
        return result;
}

static unsigned arch_regcm_reg_normalize(struct compile_state *state, unsigned regcm)
{
        /* Like arch_regcm_normalize except immediate register classes are excluded */
        regcm = arch_regcm_normalize(state, regcm);
        /* Remove the immediate register classes */
        regcm &= ~(REGCM_IMM32 | REGCM_IMM16 | REGCM_IMM8);
        return regcm;
        
}

static unsigned arch_reg_regcm(struct compile_state *state, int reg)
{
        unsigned mask;
        int class;
        mask = 0;
        for(class = 0; class <= LAST_REGC; class++) {
                if ((reg >= regcm_bound[class].first) &&
                        (reg <= regcm_bound[class].last)) {
                        mask |= (1 << class);
                }
        }
        if (!mask) {
                internal_error(state, 0, "reg %d not in any class", reg);
        }
        return mask;
}

static struct reg_info arch_reg_constraint(
        struct compile_state *state, struct type *type, const char *constraint)
{
        static const struct {
                char class;
                unsigned int mask;
                unsigned int reg;
        } constraints[] = {
                { 'r', REGCM_GPR32,   REG_UNSET },
                { 'g', REGCM_GPR32,   REG_UNSET },
                { 'p', REGCM_GPR32,   REG_UNSET },
                { 'q', REGCM_GPR8_LO, REG_UNSET },
                { 'Q', REGCM_GPR32_8, REG_UNSET },
                { 'x', REGCM_XMM,     REG_UNSET },
                { 'y', REGCM_MMX,     REG_UNSET },
                { 'a', REGCM_GPR32,   REG_EAX },
                { 'b', REGCM_GPR32,   REG_EBX },
                { 'c', REGCM_GPR32,   REG_ECX },
                { 'd', REGCM_GPR32,   REG_EDX },
                { 'D', REGCM_GPR32,   REG_EDI },
                { 'S', REGCM_GPR32,   REG_ESI },
                { '\0', 0, REG_UNSET },
        };
        unsigned int regcm;
        unsigned int mask, reg;
        struct reg_info result;
        const char *ptr;
        regcm = arch_type_to_regcm(state, type);
        reg = REG_UNSET;
        mask = 0;
        for(ptr = constraint; *ptr; ptr++) {
                int i;
                if (*ptr ==  ' ') {
                        continue;
                }
                for(i = 0; constraints[i].class != '\0'; i++) {
                        if (constraints[i].class == *ptr) {
                                break;
                        }
                }
                if (constraints[i].class == '\0') {
                        error(state, 0, "invalid register constraint ``%c''", *ptr);
                        break;
                }
                if ((constraints[i].mask & regcm) == 0) {
                        error(state, 0, "invalid register class %c specified",
                                *ptr);
                }
                mask |= constraints[i].mask;
                if (constraints[i].reg != REG_UNSET) {
                        if ((reg != REG_UNSET) && (reg != constraints[i].reg)) {
                                error(state, 0, "Only one register may be specified");
                        }
                        reg = constraints[i].reg;
                }
        }
        result.reg = reg;
        result.regcm = mask;
        return result;
}

static struct reg_info arch_reg_clobber(
        struct compile_state *state, const char *clobber)
{
        struct reg_info result;
        if (strcmp(clobber, "memory") == 0) {
                result.reg = REG_UNSET;
                result.regcm = 0;
        }
        else if (strcmp(clobber, "eax") == 0) {
                result.reg = REG_EAX;
                result.regcm = REGCM_GPR32;
        }
        else if (strcmp(clobber, "ebx") == 0) {
                result.reg = REG_EBX;
                result.regcm = REGCM_GPR32;
        }
        else if (strcmp(clobber, "ecx") == 0) {
                result.reg = REG_ECX;
                result.regcm = REGCM_GPR32;
        }
        else if (strcmp(clobber, "edx") == 0) {
                result.reg = REG_EDX;
                result.regcm = REGCM_GPR32;
        }
        else if (strcmp(clobber, "esi") == 0) {
                result.reg = REG_ESI;
                result.regcm = REGCM_GPR32;
        }
        else if (strcmp(clobber, "edi") == 0) {
                result.reg = REG_EDI;
                result.regcm = REGCM_GPR32;
        }
        else if (strcmp(clobber, "ebp") == 0) {
                result.reg = REG_EBP;
                result.regcm = REGCM_GPR32;
        }
        else if (strcmp(clobber, "esp") == 0) {
                result.reg = REG_ESP;
                result.regcm = REGCM_GPR32;
        }
        else if (strcmp(clobber, "cc") == 0) {
                result.reg = REG_EFLAGS;
                result.regcm = REGCM_FLAGS;
        }
        else if ((strncmp(clobber, "xmm", 3) == 0)  &&
                octdigitp(clobber[3]) && (clobber[4] == '\0')) {
                result.reg = REG_XMM0 + octdigval(clobber[3]);
                result.regcm = REGCM_XMM;
        }
        else if ((strncmp(clobber, "mm", 2) == 0) &&
                octdigitp(clobber[3]) && (clobber[4] == '\0')) {
                result.reg = REG_MMX0 + octdigval(clobber[3]);
                result.regcm = REGCM_MMX;
        }
        else {
                error(state, 0, "unknown register name `%s' in asm",
                        clobber);
                result.reg = REG_UNSET;
                result.regcm = 0;
        }
        return result;
}

static int do_select_reg(struct compile_state *state, 
        char *used, int reg, unsigned classes)
{
        unsigned mask;
        if (used[reg]) {
                return REG_UNSET;
        }
        mask = arch_reg_regcm(state, reg);
        return (classes & mask) ? reg : REG_UNSET;
}

static int arch_select_free_register(
        struct compile_state *state, char *used, int classes)
{
        /* Live ranges with the most neighbors are colored first.
         *
         * Generally it does not matter which colors are given
         * as the register allocator attempts to color live ranges
         * in an order where you are guaranteed not to run out of colors.
         *
         * Occasionally the register allocator cannot find an order
         * of register selection that will find a free color.  To
         * increase the odds the register allocator will work when
         * it guesses first give out registers from register classes
         * least likely to run out of registers.
         * 
         */
        int i, reg;
        reg = REG_UNSET;
        for(i = REGC_XMM_FIRST; (reg == REG_UNSET) && (i <= REGC_XMM_LAST); i++) {
                reg = do_select_reg(state, used, i, classes);
        }
        for(i = REGC_MMX_FIRST; (reg == REG_UNSET) && (i <= REGC_MMX_LAST); i++) {
                reg = do_select_reg(state, used, i, classes);
        }
        for(i = REGC_GPR32_LAST; (reg == REG_UNSET) && (i >= REGC_GPR32_FIRST); i--) {
                reg = do_select_reg(state, used, i, classes);
        }
        for(i = REGC_GPR16_FIRST; (reg == REG_UNSET) && (i <= REGC_GPR16_LAST); i++) {
                reg = do_select_reg(state, used, i, classes);
        }
        for(i = REGC_GPR8_FIRST; (reg == REG_UNSET) && (i <= REGC_GPR8_LAST); i++) {
                reg = do_select_reg(state, used, i, classes);
        }
        for(i = REGC_GPR8_LO_FIRST; (reg == REG_UNSET) && (i <= REGC_GPR8_LO_LAST); i++) {
                reg = do_select_reg(state, used, i, classes);
        }
        for(i = REGC_DIVIDEND32_FIRST; (reg == REG_UNSET) && (i <= REGC_DIVIDEND32_LAST); i++) {
                reg = do_select_reg(state, used, i, classes);
        }
        for(i = REGC_DIVIDEND64_FIRST; (reg == REG_UNSET) && (i <= REGC_DIVIDEND64_LAST); i++) {
                reg = do_select_reg(state, used, i, classes);
        }
        for(i = REGC_FLAGS_FIRST; (reg == REG_UNSET) && (i <= REGC_FLAGS_LAST); i++) {
                reg = do_select_reg(state, used, i, classes);
        }
        return reg;
}


static unsigned arch_type_to_regcm(struct compile_state *state, struct type *type) 
{
#warning "FIXME force types smaller (if legal) before I get here"
        unsigned mask;
        mask = 0;
        switch(type->type & TYPE_MASK) {
        case TYPE_ARRAY:
        case TYPE_VOID: 
                mask = 0; 
                break;
        case TYPE_CHAR:
        case TYPE_UCHAR:
                mask = REGCM_GPR8 | REGCM_GPR8_LO |
                        REGCM_GPR16 | REGCM_GPR16_8 | 
                        REGCM_GPR32 | REGCM_GPR32_8 |
                        REGCM_DIVIDEND32 | REGCM_DIVIDEND64 |
                        REGCM_MMX | REGCM_XMM |
                        REGCM_IMM32 | REGCM_IMM16 | REGCM_IMM8;
                break;
        case TYPE_SHORT:
        case TYPE_USHORT:
                mask =  REGCM_GPR16 | REGCM_GPR16_8 |
                        REGCM_GPR32 | REGCM_GPR32_8 |
                        REGCM_DIVIDEND32 | REGCM_DIVIDEND64 |
                        REGCM_MMX | REGCM_XMM |
                        REGCM_IMM32 | REGCM_IMM16;
                break;
        case TYPE_ENUM:
        case TYPE_INT:
        case TYPE_UINT:
        case TYPE_LONG:
        case TYPE_ULONG:
        case TYPE_POINTER:
                mask =  REGCM_GPR32 | REGCM_GPR32_8 |
                        REGCM_DIVIDEND32 | REGCM_DIVIDEND64 |
                        REGCM_MMX | REGCM_XMM |
                        REGCM_IMM32;
                break;
        case TYPE_JOIN:
        case TYPE_UNION:
                mask = arch_type_to_regcm(state, type->left);
                break;
        case TYPE_OVERLAP:
                mask = arch_type_to_regcm(state, type->left) &
                        arch_type_to_regcm(state, type->right);
                break;
        case TYPE_BITFIELD:
                mask = arch_type_to_regcm(state, type->left);
                break;
        default:
                fprintf(state->errout, "type: ");
                name_of(state->errout, type);
                fprintf(state->errout, "\n");
                internal_error(state, 0, "no register class for type");
                break;
        }
        mask = arch_regcm_normalize(state, mask);
        return mask;
}

static int is_imm32(struct triple *imm)
{
        return ((imm->op == OP_INTCONST) && (imm->u.cval <= 0xffffffffUL)) ||
                (imm->op == OP_ADDRCONST);
        
}
static int is_imm16(struct triple *imm)
{
        return ((imm->op == OP_INTCONST) && (imm->u.cval <= 0xffff));
}
static int is_imm8(struct triple *imm)
{
        return ((imm->op == OP_INTCONST) && (imm->u.cval <= 0xff));
}

static int get_imm32(struct triple *ins, struct triple **expr)
{
        struct triple *imm;
        imm = *expr;
        while(imm->op == OP_COPY) {
                imm = RHS(imm, 0);
        }
        if (!is_imm32(imm)) {
                return 0;
        }
        unuse_triple(*expr, ins);
        use_triple(imm, ins);
        *expr = imm;
        return 1;
}

static int get_imm8(struct triple *ins, struct triple **expr)
{
        struct triple *imm;
        imm = *expr;
        while(imm->op == OP_COPY) {
                imm = RHS(imm, 0);
        }
        if (!is_imm8(imm)) {
                return 0;
        }
        unuse_triple(*expr, ins);
        use_triple(imm, ins);
        *expr = imm;
        return 1;
}

#define TEMPLATE_NOP           0
#define TEMPLATE_INTCONST8     1
#define TEMPLATE_INTCONST32    2
#define TEMPLATE_UNKNOWNVAL    3
#define TEMPLATE_COPY8_REG     5
#define TEMPLATE_COPY16_REG    6
#define TEMPLATE_COPY32_REG    7
#define TEMPLATE_COPY_IMM8     8
#define TEMPLATE_COPY_IMM16    9
#define TEMPLATE_COPY_IMM32   10
#define TEMPLATE_PHI8         11
#define TEMPLATE_PHI16        12
#define TEMPLATE_PHI32        13
#define TEMPLATE_STORE8       14
#define TEMPLATE_STORE16      15
#define TEMPLATE_STORE32      16
#define TEMPLATE_LOAD8        17
#define TEMPLATE_LOAD16       18
#define TEMPLATE_LOAD32       19
#define TEMPLATE_BINARY8_REG  20
#define TEMPLATE_BINARY16_REG 21
#define TEMPLATE_BINARY32_REG 22
#define TEMPLATE_BINARY8_IMM  23
#define TEMPLATE_BINARY16_IMM 24
#define TEMPLATE_BINARY32_IMM 25
#define TEMPLATE_SL8_CL       26
#define TEMPLATE_SL16_CL      27
#define TEMPLATE_SL32_CL      28
#define TEMPLATE_SL8_IMM      29
#define TEMPLATE_SL16_IMM     30
#define TEMPLATE_SL32_IMM     31
#define TEMPLATE_UNARY8       32
#define TEMPLATE_UNARY16      33
#define TEMPLATE_UNARY32      34
#define TEMPLATE_CMP8_REG     35
#define TEMPLATE_CMP16_REG    36
#define TEMPLATE_CMP32_REG    37
#define TEMPLATE_CMP8_IMM     38
#define TEMPLATE_CMP16_IMM    39
#define TEMPLATE_CMP32_IMM    40
#define TEMPLATE_TEST8        41
#define TEMPLATE_TEST16       42
#define TEMPLATE_TEST32       43
#define TEMPLATE_SET          44
#define TEMPLATE_JMP          45
#define TEMPLATE_RET          46
#define TEMPLATE_INB_DX       47
#define TEMPLATE_INB_IMM      48
#define TEMPLATE_INW_DX       49
#define TEMPLATE_INW_IMM      50
#define TEMPLATE_INL_DX       51
#define TEMPLATE_INL_IMM      52
#define TEMPLATE_OUTB_DX      53
#define TEMPLATE_OUTB_IMM     54
#define TEMPLATE_OUTW_DX      55
#define TEMPLATE_OUTW_IMM     56
#define TEMPLATE_OUTL_DX      57
#define TEMPLATE_OUTL_IMM     58
#define TEMPLATE_BSF          59
#define TEMPLATE_RDMSR        60
#define TEMPLATE_WRMSR        61
#define TEMPLATE_UMUL8        62
#define TEMPLATE_UMUL16       63
#define TEMPLATE_UMUL32       64
#define TEMPLATE_DIV8         65
#define TEMPLATE_DIV16        66
#define TEMPLATE_DIV32        67
#define LAST_TEMPLATE       TEMPLATE_DIV32
#if LAST_TEMPLATE >= MAX_TEMPLATES
#error "MAX_TEMPLATES to low"
#endif

#define COPY8_REGCM     (REGCM_DIVIDEND64 | REGCM_DIVIDEND32 | REGCM_GPR32 | REGCM_GPR16 | REGCM_GPR8_LO | REGCM_MMX | REGCM_XMM)
#define COPY16_REGCM    (REGCM_DIVIDEND64 | REGCM_DIVIDEND32 | REGCM_GPR32 | REGCM_GPR16 | REGCM_MMX | REGCM_XMM)  
#define COPY32_REGCM    (REGCM_DIVIDEND64 | REGCM_DIVIDEND32 | REGCM_GPR32 | REGCM_MMX | REGCM_XMM)


static struct ins_template templates[] = {
        [TEMPLATE_NOP]      = {
                .lhs = { 
                        [ 0] = { REG_UNNEEDED, REGCM_IMMALL },
                        [ 1] = { REG_UNNEEDED, REGCM_IMMALL },
                        [ 2] = { REG_UNNEEDED, REGCM_IMMALL },
                        [ 3] = { REG_UNNEEDED, REGCM_IMMALL },
                        [ 4] = { REG_UNNEEDED, REGCM_IMMALL },
                        [ 5] = { REG_UNNEEDED, REGCM_IMMALL },
                        [ 6] = { REG_UNNEEDED, REGCM_IMMALL },
                        [ 7] = { REG_UNNEEDED, REGCM_IMMALL },
                        [ 8] = { REG_UNNEEDED, REGCM_IMMALL },
                        [ 9] = { REG_UNNEEDED, REGCM_IMMALL },
                        [10] = { REG_UNNEEDED, REGCM_IMMALL },
                        [11] = { REG_UNNEEDED, REGCM_IMMALL },
                        [12] = { REG_UNNEEDED, REGCM_IMMALL },
                        [13] = { REG_UNNEEDED, REGCM_IMMALL },
                        [14] = { REG_UNNEEDED, REGCM_IMMALL },
                        [15] = { REG_UNNEEDED, REGCM_IMMALL },
                        [16] = { REG_UNNEEDED, REGCM_IMMALL },
                        [17] = { REG_UNNEEDED, REGCM_IMMALL },
                        [18] = { REG_UNNEEDED, REGCM_IMMALL },
                        [19] = { REG_UNNEEDED, REGCM_IMMALL },
                        [20] = { REG_UNNEEDED, REGCM_IMMALL },
                        [21] = { REG_UNNEEDED, REGCM_IMMALL },
                        [22] = { REG_UNNEEDED, REGCM_IMMALL },
                        [23] = { REG_UNNEEDED, REGCM_IMMALL },
                        [24] = { REG_UNNEEDED, REGCM_IMMALL },
                        [25] = { REG_UNNEEDED, REGCM_IMMALL },
                        [26] = { REG_UNNEEDED, REGCM_IMMALL },
                        [27] = { REG_UNNEEDED, REGCM_IMMALL },
                        [28] = { REG_UNNEEDED, REGCM_IMMALL },
                        [29] = { REG_UNNEEDED, REGCM_IMMALL },
                        [30] = { REG_UNNEEDED, REGCM_IMMALL },
                        [31] = { REG_UNNEEDED, REGCM_IMMALL },
                        [32] = { REG_UNNEEDED, REGCM_IMMALL },
                        [33] = { REG_UNNEEDED, REGCM_IMMALL },
                        [34] = { REG_UNNEEDED, REGCM_IMMALL },
                        [35] = { REG_UNNEEDED, REGCM_IMMALL },
                        [36] = { REG_UNNEEDED, REGCM_IMMALL },
                        [37] = { REG_UNNEEDED, REGCM_IMMALL },
                        [38] = { REG_UNNEEDED, REGCM_IMMALL },
                        [39] = { REG_UNNEEDED, REGCM_IMMALL },
                        [40] = { REG_UNNEEDED, REGCM_IMMALL },
                        [41] = { REG_UNNEEDED, REGCM_IMMALL },
                        [42] = { REG_UNNEEDED, REGCM_IMMALL },
                        [43] = { REG_UNNEEDED, REGCM_IMMALL },
                        [44] = { REG_UNNEEDED, REGCM_IMMALL },
                        [45] = { REG_UNNEEDED, REGCM_IMMALL },
                        [46] = { REG_UNNEEDED, REGCM_IMMALL },
                        [47] = { REG_UNNEEDED, REGCM_IMMALL },
                        [48] = { REG_UNNEEDED, REGCM_IMMALL },
                        [49] = { REG_UNNEEDED, REGCM_IMMALL },
                        [50] = { REG_UNNEEDED, REGCM_IMMALL },
                        [51] = { REG_UNNEEDED, REGCM_IMMALL },
                        [52] = { REG_UNNEEDED, REGCM_IMMALL },
                        [53] = { REG_UNNEEDED, REGCM_IMMALL },
                        [54] = { REG_UNNEEDED, REGCM_IMMALL },
                        [55] = { REG_UNNEEDED, REGCM_IMMALL },
                        [56] = { REG_UNNEEDED, REGCM_IMMALL },
                        [57] = { REG_UNNEEDED, REGCM_IMMALL },
                        [58] = { REG_UNNEEDED, REGCM_IMMALL },
                        [59] = { REG_UNNEEDED, REGCM_IMMALL },
                        [60] = { REG_UNNEEDED, REGCM_IMMALL },
                        [61] = { REG_UNNEEDED, REGCM_IMMALL },
                        [62] = { REG_UNNEEDED, REGCM_IMMALL },
                        [63] = { REG_UNNEEDED, REGCM_IMMALL },
                },
        },
        [TEMPLATE_INTCONST8] = { 
                .lhs = { [0] = { REG_UNNEEDED, REGCM_IMM8 } },
        },
        [TEMPLATE_INTCONST32] = { 
                .lhs = { [0] = { REG_UNNEEDED, REGCM_IMM32 } },
        },
        [TEMPLATE_UNKNOWNVAL] = {
                .lhs = { [0] = { REG_UNSET, COPY32_REGCM } },
        },
        [TEMPLATE_COPY8_REG] = {
                .lhs = { [0] = { REG_UNSET, COPY8_REGCM } },
                .rhs = { [0] = { REG_UNSET, COPY8_REGCM }  },
        },
        [TEMPLATE_COPY16_REG] = {
                .lhs = { [0] = { REG_UNSET, COPY16_REGCM } },
                .rhs = { [0] = { REG_UNSET, COPY16_REGCM }  },
        },
        [TEMPLATE_COPY32_REG] = {
                .lhs = { [0] = { REG_UNSET, COPY32_REGCM } },
                .rhs = { [0] = { REG_UNSET, COPY32_REGCM }  },
        },
        [TEMPLATE_COPY_IMM8] = {
                .lhs = { [0] = { REG_UNSET, COPY8_REGCM } },
                .rhs = { [0] = { REG_UNNEEDED, REGCM_IMM8 } },
        },
        [TEMPLATE_COPY_IMM16] = {
                .lhs = { [0] = { REG_UNSET, COPY16_REGCM } },
                .rhs = { [0] = { REG_UNNEEDED, REGCM_IMM16 | REGCM_IMM8 } },
        },
        [TEMPLATE_COPY_IMM32] = {
                .lhs = { [0] = { REG_UNSET, COPY32_REGCM } },
                .rhs = { [0] = { REG_UNNEEDED, REGCM_IMM32 | REGCM_IMM16 | REGCM_IMM8 } },
        },
        [TEMPLATE_PHI8] = { 
                .lhs = { [0] = { REG_VIRT0, COPY8_REGCM } },
                .rhs = { [0] = { REG_VIRT0, COPY8_REGCM } },
        },
        [TEMPLATE_PHI16] = { 
                .lhs = { [0] = { REG_VIRT0, COPY16_REGCM } },
                .rhs = { [0] = { REG_VIRT0, COPY16_REGCM } }, 
        },
        [TEMPLATE_PHI32] = { 
                .lhs = { [0] = { REG_VIRT0, COPY32_REGCM } },
                .rhs = { [0] = { REG_VIRT0, COPY32_REGCM } }, 
        },
        [TEMPLATE_STORE8] = {
                .rhs = { 
                        [0] = { REG_UNSET, REGCM_GPR32 },
                        [1] = { REG_UNSET, REGCM_GPR8_LO },
                },
        },
        [TEMPLATE_STORE16] = {
                .rhs = { 
                        [0] = { REG_UNSET, REGCM_GPR32 },
                        [1] = { REG_UNSET, REGCM_GPR16 },
                },
        },
        [TEMPLATE_STORE32] = {
                .rhs = { 
                        [0] = { REG_UNSET, REGCM_GPR32 },
                        [1] = { REG_UNSET, REGCM_GPR32 },
                },
        },
        [TEMPLATE_LOAD8] = {
                .lhs = { [0] = { REG_UNSET, REGCM_GPR8_LO } },
                .rhs = { [0] = { REG_UNSET, REGCM_GPR32 } },
        },
        [TEMPLATE_LOAD16] = {
                .lhs = { [0] = { REG_UNSET, REGCM_GPR16 } },
                .rhs = { [0] = { REG_UNSET, REGCM_GPR32 } },
        },
        [TEMPLATE_LOAD32] = {
                .lhs = { [0] = { REG_UNSET, REGCM_GPR32 } },
                .rhs = { [0] = { REG_UNSET, REGCM_GPR32 } },
        },
        [TEMPLATE_BINARY8_REG] = {
                .lhs = { [0] = { REG_VIRT0, REGCM_GPR8_LO } },
                .rhs = { 
                        [0] = { REG_VIRT0, REGCM_GPR8_LO },
                        [1] = { REG_UNSET, REGCM_GPR8_LO },
                },
        },
        [TEMPLATE_BINARY16_REG] = {
                .lhs = { [0] = { REG_VIRT0, REGCM_GPR16 } },
                .rhs = { 
                        [0] = { REG_VIRT0, REGCM_GPR16 },
                        [1] = { REG_UNSET, REGCM_GPR16 },
                },
        },
        [TEMPLATE_BINARY32_REG] = {
                .lhs = { [0] = { REG_VIRT0, REGCM_GPR32 } },
                .rhs = { 
                        [0] = { REG_VIRT0, REGCM_GPR32 },
                        [1] = { REG_UNSET, REGCM_GPR32 },
                },
        },
        [TEMPLATE_BINARY8_IMM] = {
                .lhs = { [0] = { REG_VIRT0, REGCM_GPR8_LO } },
                .rhs = { 
                        [0] = { REG_VIRT0,    REGCM_GPR8_LO },
                        [1] = { REG_UNNEEDED, REGCM_IMM8 },
                },
        },
        [TEMPLATE_BINARY16_IMM] = {
                .lhs = { [0] = { REG_VIRT0, REGCM_GPR16 } },
                .rhs = { 
                        [0] = { REG_VIRT0,    REGCM_GPR16 },
                        [1] = { REG_UNNEEDED, REGCM_IMM16 },
                },
        },
        [TEMPLATE_BINARY32_IMM] = {
                .lhs = { [0] = { REG_VIRT0, REGCM_GPR32 } },
                .rhs = { 
                        [0] = { REG_VIRT0,    REGCM_GPR32 },
                        [1] = { REG_UNNEEDED, REGCM_IMM32 },
                },
        },
        [TEMPLATE_SL8_CL] = {
                .lhs = { [0] = { REG_VIRT0, REGCM_GPR8_LO } },
                .rhs = { 
                        [0] = { REG_VIRT0, REGCM_GPR8_LO },
                        [1] = { REG_CL, REGCM_GPR8_LO },
                },
        },
        [TEMPLATE_SL16_CL] = {
                .lhs = { [0] = { REG_VIRT0, REGCM_GPR16 } },
                .rhs = { 
                        [0] = { REG_VIRT0, REGCM_GPR16 },
                        [1] = { REG_CL, REGCM_GPR8_LO },
                },
        },
        [TEMPLATE_SL32_CL] = {
                .lhs = { [0] = { REG_VIRT0, REGCM_GPR32 } },
                .rhs = { 
                        [0] = { REG_VIRT0, REGCM_GPR32 },
                        [1] = { REG_CL, REGCM_GPR8_LO },
                },
        },
        [TEMPLATE_SL8_IMM] = {
                .lhs = { [0] = { REG_VIRT0, REGCM_GPR8_LO } },
                .rhs = { 
                        [0] = { REG_VIRT0,    REGCM_GPR8_LO },
                        [1] = { REG_UNNEEDED, REGCM_IMM8 },
                },
        },
        [TEMPLATE_SL16_IMM] = {
                .lhs = { [0] = { REG_VIRT0, REGCM_GPR16 } },
                .rhs = { 
                        [0] = { REG_VIRT0,    REGCM_GPR16 },
                        [1] = { REG_UNNEEDED, REGCM_IMM8 },
                },
        },
        [TEMPLATE_SL32_IMM] = {
                .lhs = { [0] = { REG_VIRT0, REGCM_GPR32 } },
                .rhs = { 
                        [0] = { REG_VIRT0,    REGCM_GPR32 },
                        [1] = { REG_UNNEEDED, REGCM_IMM8 },
                },
        },
        [TEMPLATE_UNARY8] = {
                .lhs = { [0] = { REG_VIRT0, REGCM_GPR8_LO } },
                .rhs = { [0] = { REG_VIRT0, REGCM_GPR8_LO } },
        },
        [TEMPLATE_UNARY16] = {
                .lhs = { [0] = { REG_VIRT0, REGCM_GPR16 } },
                .rhs = { [0] = { REG_VIRT0, REGCM_GPR16 } },
        },
        [TEMPLATE_UNARY32] = {
                .lhs = { [0] = { REG_VIRT0, REGCM_GPR32 } },
                .rhs = { [0] = { REG_VIRT0, REGCM_GPR32 } },
        },
        [TEMPLATE_CMP8_REG] = {
                .lhs = { [0] = { REG_EFLAGS, REGCM_FLAGS } },
                .rhs = {
                        [0] = { REG_UNSET, REGCM_GPR8_LO },
                        [1] = { REG_UNSET, REGCM_GPR8_LO },
                },
        },
        [TEMPLATE_CMP16_REG] = {
                .lhs = { [0] = { REG_EFLAGS, REGCM_FLAGS } },
                .rhs = {
                        [0] = { REG_UNSET, REGCM_GPR16 },
                        [1] = { REG_UNSET, REGCM_GPR16 },
                },
        },
        [TEMPLATE_CMP32_REG] = {
                .lhs = { [0] = { REG_EFLAGS, REGCM_FLAGS } },
                .rhs = {
                        [0] = { REG_UNSET, REGCM_GPR32 },
                        [1] = { REG_UNSET, REGCM_GPR32 },
                },
        },
        [TEMPLATE_CMP8_IMM] = {
                .lhs = { [0] = { REG_EFLAGS, REGCM_FLAGS } },
                .rhs = {
                        [0] = { REG_UNSET, REGCM_GPR8_LO },
                        [1] = { REG_UNNEEDED, REGCM_IMM8 },
                },
        },
        [TEMPLATE_CMP16_IMM] = {
                .lhs = { [0] = { REG_EFLAGS, REGCM_FLAGS } },
                .rhs = {
                        [0] = { REG_UNSET, REGCM_GPR16 },
                        [1] = { REG_UNNEEDED, REGCM_IMM16 },
                },
        },
        [TEMPLATE_CMP32_IMM] = {
                .lhs = { [0] = { REG_EFLAGS, REGCM_FLAGS } },
                .rhs = {
                        [0] = { REG_UNSET, REGCM_GPR32 },
                        [1] = { REG_UNNEEDED, REGCM_IMM32 },
                },
        },
        [TEMPLATE_TEST8] = {
                .lhs = { [0] = { REG_EFLAGS, REGCM_FLAGS } },
                .rhs = { [0] = { REG_UNSET, REGCM_GPR8_LO } },
        },
        [TEMPLATE_TEST16] = {
                .lhs = { [0] = { REG_EFLAGS, REGCM_FLAGS } },
                .rhs = { [0] = { REG_UNSET, REGCM_GPR16 } },
        },
        [TEMPLATE_TEST32] = {
                .lhs = { [0] = { REG_EFLAGS, REGCM_FLAGS } },
                .rhs = { [0] = { REG_UNSET, REGCM_GPR32 } },
        },
        [TEMPLATE_SET] = {
                .lhs = { [0] = { REG_UNSET, REGCM_GPR8_LO } },
                .rhs = { [0] = { REG_EFLAGS, REGCM_FLAGS } },
        },
        [TEMPLATE_JMP] = {
                .rhs = { [0] = { REG_EFLAGS, REGCM_FLAGS } },
        },
        [TEMPLATE_RET] = {
                .rhs = { [0] = { REG_UNSET, REGCM_GPR32 } },
        },
        [TEMPLATE_INB_DX] = {
                .lhs = { [0] = { REG_AL,  REGCM_GPR8_LO } },  
                .rhs = { [0] = { REG_DX, REGCM_GPR16 } },
        },
        [TEMPLATE_INB_IMM] = {
                .lhs = { [0] = { REG_AL,  REGCM_GPR8_LO } },  
                .rhs = { [0] = { REG_UNNEEDED, REGCM_IMM8 } },
        },
        [TEMPLATE_INW_DX]  = { 
                .lhs = { [0] = { REG_AX,  REGCM_GPR16 } }, 
                .rhs = { [0] = { REG_DX, REGCM_GPR16 } },
        },
        [TEMPLATE_INW_IMM] = { 
                .lhs = { [0] = { REG_AX,  REGCM_GPR16 } }, 
                .rhs = { [0] = { REG_UNNEEDED, REGCM_IMM8 } },
        },
        [TEMPLATE_INL_DX]  = {
                .lhs = { [0] = { REG_EAX, REGCM_GPR32 } },
                .rhs = { [0] = { REG_DX, REGCM_GPR16 } },
        },
        [TEMPLATE_INL_IMM] = {
                .lhs = { [0] = { REG_EAX, REGCM_GPR32 } },
                .rhs = { [0] = { REG_UNNEEDED, REGCM_IMM8 } },
        },
        [TEMPLATE_OUTB_DX] = { 
                .rhs = {
                        [0] = { REG_AL,  REGCM_GPR8_LO },
                        [1] = { REG_DX, REGCM_GPR16 },
                },
        },
        [TEMPLATE_OUTB_IMM] = { 
                .rhs = {
                        [0] = { REG_AL,  REGCM_GPR8_LO },  
                        [1] = { REG_UNNEEDED, REGCM_IMM8 },
                },
        },
        [TEMPLATE_OUTW_DX] = { 
                .rhs = {
                        [0] = { REG_AX,  REGCM_GPR16 },
                        [1] = { REG_DX, REGCM_GPR16 },
                },
        },
        [TEMPLATE_OUTW_IMM] = {
                .rhs = {
                        [0] = { REG_AX,  REGCM_GPR16 }, 
                        [1] = { REG_UNNEEDED, REGCM_IMM8 },
                },
        },
        [TEMPLATE_OUTL_DX] = { 
                .rhs = {
                        [0] = { REG_EAX, REGCM_GPR32 },
                        [1] = { REG_DX, REGCM_GPR16 },
                },
        },
        [TEMPLATE_OUTL_IMM] = { 
                .rhs = {
                        [0] = { REG_EAX, REGCM_GPR32 }, 
                        [1] = { REG_UNNEEDED, REGCM_IMM8 },
                },
        },
        [TEMPLATE_BSF] = {
                .lhs = { [0] = { REG_UNSET, REGCM_GPR32 } },
                .rhs = { [0] = { REG_UNSET, REGCM_GPR32 } },
        },
        [TEMPLATE_RDMSR] = {
                .lhs = { 
                        [0] = { REG_EAX, REGCM_GPR32 },
                        [1] = { REG_EDX, REGCM_GPR32 },
                },
                .rhs = { [0] = { REG_ECX, REGCM_GPR32 } },
        },
        [TEMPLATE_WRMSR] = {
                .rhs = {
                        [0] = { REG_ECX, REGCM_GPR32 },
                        [1] = { REG_EAX, REGCM_GPR32 },
                        [2] = { REG_EDX, REGCM_GPR32 },
                },
        },
        [TEMPLATE_UMUL8] = {
                .lhs = { [0] = { REG_AX, REGCM_GPR16 } },
                .rhs = { 
                        [0] = { REG_AL, REGCM_GPR8_LO },
                        [1] = { REG_UNSET, REGCM_GPR8_LO },
                },
        },
        [TEMPLATE_UMUL16] = {
                .lhs = { [0] = { REG_DXAX, REGCM_DIVIDEND32 } },
                .rhs = { 
                        [0] = { REG_AX, REGCM_GPR16 },
                        [1] = { REG_UNSET, REGCM_GPR16 },
                },
        },
        [TEMPLATE_UMUL32] = {
                .lhs = { [0] = { REG_EDXEAX, REGCM_DIVIDEND64 } },
                .rhs = { 
                        [0] = { REG_EAX, REGCM_GPR32 },
                        [1] = { REG_UNSET, REGCM_GPR32 },
                },
        },
        [TEMPLATE_DIV8] = {
                .lhs = { 
                        [0] = { REG_AL, REGCM_GPR8_LO },
                        [1] = { REG_AH, REGCM_GPR8 },
                },
                .rhs = {
                        [0] = { REG_AX, REGCM_GPR16 },
                        [1] = { REG_UNSET, REGCM_GPR8_LO },
                },
        },
        [TEMPLATE_DIV16] = {
                .lhs = { 
                        [0] = { REG_AX, REGCM_GPR16 },
                        [1] = { REG_DX, REGCM_GPR16 },
                },
                .rhs = {
                        [0] = { REG_DXAX, REGCM_DIVIDEND32 },
                        [1] = { REG_UNSET, REGCM_GPR16 },
                },
        },
        [TEMPLATE_DIV32] = {
                .lhs = { 
                        [0] = { REG_EAX, REGCM_GPR32 },
                        [1] = { REG_EDX, REGCM_GPR32 },
                },
                .rhs = {
                        [0] = { REG_EDXEAX, REGCM_DIVIDEND64 },
                        [1] = { REG_UNSET, REGCM_GPR32 },
                },
        },
};

static void fixup_branch(struct compile_state *state,
        struct triple *branch, int jmp_op, int cmp_op, struct type *cmp_type,
        struct triple *left, struct triple *right)
{
        struct triple *test;
        if (!left) {
                internal_error(state, branch, "no branch test?");
        }
        test = pre_triple(state, branch,
                cmp_op, cmp_type, left, right);
        test->template_id = TEMPLATE_TEST32; 
        if (cmp_op == OP_CMP) {
                test->template_id = TEMPLATE_CMP32_REG;
                if (get_imm32(test, &RHS(test, 1))) {
                        test->template_id = TEMPLATE_CMP32_IMM;
                }
        }
        use_triple(RHS(test, 0), test);
        use_triple(RHS(test, 1), test);
        unuse_triple(RHS(branch, 0), branch);
        RHS(branch, 0) = test;
        branch->op = jmp_op;
        branch->template_id = TEMPLATE_JMP;
        use_triple(RHS(branch, 0), branch);
}

static void fixup_branches(struct compile_state *state,
        struct triple *cmp, struct triple *use, int jmp_op)
{
        struct triple_set *entry, *next;
        for(entry = use->use; entry; entry = next) {
                next = entry->next;
                if (entry->member->op == OP_COPY) {
                        fixup_branches(state, cmp, entry->member, jmp_op);
                }
                else if (entry->member->op == OP_CBRANCH) {
                        struct triple *branch;
                        struct triple *left, *right;
                        left = right = 0;
                        left = RHS(cmp, 0);
                        if (cmp->rhs > 1) {
                                right = RHS(cmp, 1);
                        }
                        branch = entry->member;
                        fixup_branch(state, branch, jmp_op, 
                                cmp->op, cmp->type, left, right);
                }
        }
}

static void bool_cmp(struct compile_state *state, 
        struct triple *ins, int cmp_op, int jmp_op, int set_op)
{
        struct triple_set *entry, *next;
        struct triple *set, *convert;

        /* Put a barrier up before the cmp which preceeds the
         * copy instruction.  If a set actually occurs this gives
         * us a chance to move variables in registers out of the way.
         */

        /* Modify the comparison operator */
        ins->op = cmp_op;
        ins->template_id = TEMPLATE_TEST32;
        if (cmp_op == OP_CMP) {
                ins->template_id = TEMPLATE_CMP32_REG;
                if (get_imm32(ins, &RHS(ins, 1))) {
                        ins->template_id =  TEMPLATE_CMP32_IMM;
                }
        }
        /* Generate the instruction sequence that will transform the
         * result of the comparison into a logical value.
         */
        set = post_triple(state, ins, set_op, &uchar_type, ins, 0);
        use_triple(ins, set);
        set->template_id = TEMPLATE_SET;

        convert = set;
        if (!equiv_types(ins->type, set->type)) {
                convert = post_triple(state, set, OP_CONVERT, ins->type, set, 0);
                use_triple(set, convert);
                convert->template_id = TEMPLATE_COPY32_REG;
        }

        for(entry = ins->use; entry; entry = next) {
                next = entry->next;
                if (entry->member == set) {
                        continue;
                }
                replace_rhs_use(state, ins, convert, entry->member);
        }
        fixup_branches(state, ins, convert, jmp_op);
}

struct reg_info arch_reg_lhs(struct compile_state *state, struct triple *ins, int index)
{
        struct ins_template *template;
        struct reg_info result;
        int zlhs;
        if (ins->op == OP_PIECE) {
                index = ins->u.cval;
                ins = MISC(ins, 0);
        }
        zlhs = ins->lhs;
        if (triple_is_def(state, ins)) {
                zlhs = 1;
        }
        if (index >= zlhs) {
                internal_error(state, ins, "index %d out of range for %s",
                        index, tops(ins->op));
        }
        switch(ins->op) {
        case OP_ASM:
                template = &ins->u.ainfo->tmpl;
                break;
        default:
                if (ins->template_id > LAST_TEMPLATE) {
                        internal_error(state, ins, "bad template number %d", 
                                ins->template_id);
                }
                template = &templates[ins->template_id];
                break;
        }
        result = template->lhs[index];
        result.regcm = arch_regcm_normalize(state, result.regcm);
        if (result.reg != REG_UNNEEDED) {
                result.regcm &= ~(REGCM_IMM32 | REGCM_IMM16 | REGCM_IMM8);
        }
        if (result.regcm == 0) {
                internal_error(state, ins, "lhs %d regcm == 0", index);
        }
        return result;
}

struct reg_info arch_reg_rhs(struct compile_state *state, struct triple *ins, int index)
{
        struct reg_info result;
        struct ins_template *template;
        if ((index > ins->rhs) ||
                (ins->op == OP_PIECE)) {
                internal_error(state, ins, "index %d out of range for %s\n",
                        index, tops(ins->op));
        }
        switch(ins->op) {
        case OP_ASM:
                template = &ins->u.ainfo->tmpl;
                break;
        case OP_PHI:
                index = 0;
                /* Fall through */
        default:
                if (ins->template_id > LAST_TEMPLATE) {
                        internal_error(state, ins, "bad template number %d", 
                                ins->template_id);
                }
                template = &templates[ins->template_id];
                break;
        }
        result = template->rhs[index];
        result.regcm = arch_regcm_normalize(state, result.regcm);
        if (result.regcm == 0) {
                internal_error(state, ins, "rhs %d regcm == 0", index);
        }
        return result;
}

static struct triple *mod_div(struct compile_state *state,
        struct triple *ins, int div_op, int index)
{
        struct triple *div, *piece0, *piece1;
        
        /* Generate the appropriate division instruction */
        div = post_triple(state, ins, div_op, ins->type, 0, 0);
        RHS(div, 0) = RHS(ins, 0);
        RHS(div, 1) = RHS(ins, 1);
        piece0 = LHS(div, 0);
        piece1 = LHS(div, 1);
        div->template_id  = TEMPLATE_DIV32;
        use_triple(RHS(div, 0), div);
        use_triple(RHS(div, 1), div);
        use_triple(LHS(div, 0), div);
        use_triple(LHS(div, 1), div);

        /* Replate uses of ins with the appropriate piece of the div */
        propogate_use(state, ins, LHS(div, index));
        release_triple(state, ins);

        /* Return the address of the next instruction */
        return piece1->next;
}

static int noop_adecl(struct triple *adecl)
{
        struct triple_set *use;
        /* It's a noop if it doesn't specify stoorage */
        if (adecl->lhs == 0) {
                return 1;
        }
        /* Is the adecl used? If not it's a noop */
        for(use = adecl->use; use ; use = use->next) {
                if ((use->member->op != OP_PIECE) ||
                        (MISC(use->member, 0) != adecl)) {
                        return 0;
                }
        }
        return 1;
}

static struct triple *x86_deposit(struct compile_state *state, struct triple *ins)
{
        struct triple *mask, *nmask, *shift;
        struct triple *val, *val_mask, *val_shift;
        struct triple *targ, *targ_mask;
        struct triple *new;
        ulong_t the_mask, the_nmask;

        targ = RHS(ins, 0);
        val = RHS(ins, 1);

        /* Get constant for the mask value */
        the_mask = 1;
        the_mask <<= ins->u.bitfield.size;
        the_mask -= 1;
        the_mask <<= ins->u.bitfield.offset;
        mask = pre_triple(state, ins, OP_INTCONST, &uint_type, 0, 0);
        mask->u.cval = the_mask;

        /* Get the inverted mask value */
        the_nmask = ~the_mask;
        nmask = pre_triple(state, ins, OP_INTCONST, &uint_type, 0, 0);
        nmask->u.cval = the_nmask;

        /* Get constant for the shift value */
        shift = pre_triple(state, ins, OP_INTCONST, &uint_type, 0, 0);
        shift->u.cval = ins->u.bitfield.offset;

        /* Shift and mask the source value */
        val_shift = val;
        if (shift->u.cval != 0) {
                val_shift = pre_triple(state, ins, OP_SL, val->type, val, shift);
                use_triple(val, val_shift);
                use_triple(shift, val_shift);
        }
        val_mask = val_shift;
        if (is_signed(val->type)) {
                val_mask = pre_triple(state, ins, OP_AND, val->type, val_shift, mask);
                use_triple(val_shift, val_mask);
                use_triple(mask, val_mask);
        }

        /* Mask the target value */
        targ_mask = pre_triple(state, ins, OP_AND, targ->type, targ, nmask);
        use_triple(targ, targ_mask);
        use_triple(nmask, targ_mask);

        /* Now combined them together */
        new = pre_triple(state, ins, OP_OR, targ->type, targ_mask, val_mask);
        use_triple(targ_mask, new);
        use_triple(val_mask, new);

        /* Move all of the users over to the new expression */
        propogate_use(state, ins, new);

        /* Delete the original triple */
        release_triple(state, ins);

        /* Restart the transformation at mask */
        return mask;
}

static struct triple *x86_extract(struct compile_state *state, struct triple *ins)
{
        struct triple *mask, *shift;
        struct triple *val, *val_mask, *val_shift;
        ulong_t the_mask;

        val = RHS(ins, 0);

        /* Get constant for the mask value */
        the_mask = 1;
        the_mask <<= ins->u.bitfield.size;
        the_mask -= 1;
        mask = pre_triple(state, ins, OP_INTCONST, &int_type, 0, 0);
        mask->u.cval = the_mask;

        /* Get constant for the right shift value */
        shift = pre_triple(state, ins, OP_INTCONST, &int_type, 0, 0);
        shift->u.cval = ins->u.bitfield.offset;

        /* Shift arithmetic right, to correct the sign */
        val_shift = val;
        if (shift->u.cval != 0) {
                int op;
                if (ins->op == OP_SEXTRACT) {
                        op = OP_SSR;
                } else {
                        op = OP_USR;
                }
                val_shift = pre_triple(state, ins, op, val->type, val, shift);
                use_triple(val, val_shift);
                use_triple(shift, val_shift);
        }

        /* Finally mask the value */
        val_mask = pre_triple(state, ins, OP_AND, ins->type, val_shift, mask);
        use_triple(val_shift, val_mask);
        use_triple(mask,      val_mask);

        /* Move all of the users over to the new expression */
        propogate_use(state, ins, val_mask);

        /* Release the original instruction */
        release_triple(state, ins);

        return mask;

}

static struct triple *transform_to_arch_instruction(
        struct compile_state *state, struct triple *ins)
{
        /* Transform from generic 3 address instructions
         * to archtecture specific instructions.
         * And apply architecture specific constraints to instructions.
         * Copies are inserted to preserve the register flexibility
         * of 3 address instructions.
         */
        struct triple *next, *value;
        size_t size;
        next = ins->next;
        switch(ins->op) {
        case OP_INTCONST:
                ins->template_id = TEMPLATE_INTCONST32;
                if (ins->u.cval < 256) {
                        ins->template_id = TEMPLATE_INTCONST8;
                }
                break;
        case OP_ADDRCONST:
                ins->template_id = TEMPLATE_INTCONST32;
                break;
        case OP_UNKNOWNVAL:
                ins->template_id = TEMPLATE_UNKNOWNVAL;
                break;
        case OP_NOOP:
        case OP_SDECL:
        case OP_BLOBCONST:
        case OP_LABEL:
                ins->template_id = TEMPLATE_NOP;
                break;
        case OP_COPY:
        case OP_CONVERT:
                size = size_of(state, ins->type);
                value = RHS(ins, 0);
                if (is_imm8(value) && (size <= SIZEOF_I8)) {
                        ins->template_id = TEMPLATE_COPY_IMM8;
                }
                else if (is_imm16(value) && (size <= SIZEOF_I16)) {
                        ins->template_id = TEMPLATE_COPY_IMM16;
                }
                else if (is_imm32(value) && (size <= SIZEOF_I32)) {
                        ins->template_id = TEMPLATE_COPY_IMM32;
                }
                else if (is_const(value)) {
                        internal_error(state, ins, "bad constant passed to copy");
                }
                else if (size <= SIZEOF_I8) {
                        ins->template_id = TEMPLATE_COPY8_REG;
                }
                else if (size <= SIZEOF_I16) {
                        ins->template_id = TEMPLATE_COPY16_REG;
                }
                else if (size <= SIZEOF_I32) {
                        ins->template_id = TEMPLATE_COPY32_REG;
                }
                else {
                        internal_error(state, ins, "bad type passed to copy");
                }
                break;
        case OP_PHI:
                size = size_of(state, ins->type);
                if (size <= SIZEOF_I8) {
                        ins->template_id = TEMPLATE_PHI8;
                }
                else if (size <= SIZEOF_I16) {
                        ins->template_id = TEMPLATE_PHI16;
                }
                else if (size <= SIZEOF_I32) {
                        ins->template_id = TEMPLATE_PHI32;
                }
                else {
                        internal_error(state, ins, "bad type passed to phi");
                }
                break;
        case OP_ADECL:
                /* Adecls should always be treated as dead code and
                 * removed.  If we are not optimizing they may linger.
                 */
                if (!noop_adecl(ins)) {
                        internal_error(state, ins, "adecl remains?");
                }
                ins->template_id = TEMPLATE_NOP;
                next = after_lhs(state, ins);
                break;
        case OP_STORE:
                switch(ins->type->type & TYPE_MASK) {
                case TYPE_CHAR:    case TYPE_UCHAR:
                        ins->template_id = TEMPLATE_STORE8;
                        break;
                case TYPE_SHORT:   case TYPE_USHORT:
                        ins->template_id = TEMPLATE_STORE16;
                        break;
                case TYPE_INT:     case TYPE_UINT:
                case TYPE_LONG:    case TYPE_ULONG:
                case TYPE_POINTER:
                        ins->template_id = TEMPLATE_STORE32;
                        break;
                default:
                        internal_error(state, ins, "unknown type in store");
                        break;
                }
                break;
        case OP_LOAD:
                switch(ins->type->type & TYPE_MASK) {
                case TYPE_CHAR:   case TYPE_UCHAR:
                case TYPE_SHORT:  case TYPE_USHORT:
                case TYPE_INT:    case TYPE_UINT:
                case TYPE_LONG:   case TYPE_ULONG:
                case TYPE_POINTER:
                        break;
                default:
                        internal_error(state, ins, "unknown type in load");
                        break;
                }
                ins->template_id = TEMPLATE_LOAD32;
                break;
        case OP_ADD:
        case OP_SUB:
        case OP_AND:
        case OP_XOR:
        case OP_OR:
        case OP_SMUL:
                ins->template_id = TEMPLATE_BINARY32_REG;
                if (get_imm32(ins, &RHS(ins, 1))) {
                        ins->template_id = TEMPLATE_BINARY32_IMM;
                }
                break;
        case OP_SDIVT:
        case OP_UDIVT:
                ins->template_id = TEMPLATE_DIV32;
                next = after_lhs(state, ins);
                break;
        case OP_UMUL:
                ins->template_id = TEMPLATE_UMUL32;
                break;
        case OP_UDIV:
                next = mod_div(state, ins, OP_UDIVT, 0);
                break;
        case OP_SDIV:
                next = mod_div(state, ins, OP_SDIVT, 0);
                break;
        case OP_UMOD:
                next = mod_div(state, ins, OP_UDIVT, 1);
                break;
        case OP_SMOD:
                next = mod_div(state, ins, OP_SDIVT, 1);
                break;
        case OP_SL:
        case OP_SSR:
        case OP_USR:
                ins->template_id = TEMPLATE_SL32_CL;
                if (get_imm8(ins, &RHS(ins, 1))) {
                        ins->template_id = TEMPLATE_SL32_IMM;
                } else if (size_of(state, RHS(ins, 1)->type) > SIZEOF_CHAR) {
                        typed_pre_copy(state, &uchar_type, ins, 1);
                }
                break;
        case OP_INVERT:
        case OP_NEG:
                ins->template_id = TEMPLATE_UNARY32;
                break;
        case OP_EQ: 
                bool_cmp(state, ins, OP_CMP, OP_JMP_EQ, OP_SET_EQ); 
                break;
        case OP_NOTEQ:
                bool_cmp(state, ins, OP_CMP, OP_JMP_NOTEQ, OP_SET_NOTEQ);
                break;
        case OP_SLESS:
                bool_cmp(state, ins, OP_CMP, OP_JMP_SLESS, OP_SET_SLESS);
                break;
        case OP_ULESS:
                bool_cmp(state, ins, OP_CMP, OP_JMP_ULESS, OP_SET_ULESS);
                break;
        case OP_SMORE:
                bool_cmp(state, ins, OP_CMP, OP_JMP_SMORE, OP_SET_SMORE);
                break;
        case OP_UMORE:
                bool_cmp(state, ins, OP_CMP, OP_JMP_UMORE, OP_SET_UMORE);
                break;
        case OP_SLESSEQ:
                bool_cmp(state, ins, OP_CMP, OP_JMP_SLESSEQ, OP_SET_SLESSEQ);
                break;
        case OP_ULESSEQ:
                bool_cmp(state, ins, OP_CMP, OP_JMP_ULESSEQ, OP_SET_ULESSEQ);
                break;
        case OP_SMOREEQ:
                bool_cmp(state, ins, OP_CMP, OP_JMP_SMOREEQ, OP_SET_SMOREEQ);
                break;
        case OP_UMOREEQ:
                bool_cmp(state, ins, OP_CMP, OP_JMP_UMOREEQ, OP_SET_UMOREEQ);
                break;
        case OP_LTRUE:
                bool_cmp(state, ins, OP_TEST, OP_JMP_NOTEQ, OP_SET_NOTEQ);
                break;
        case OP_LFALSE:
                bool_cmp(state, ins, OP_TEST, OP_JMP_EQ, OP_SET_EQ);
                break;
        case OP_BRANCH:
                ins->op = OP_JMP;
                ins->template_id = TEMPLATE_NOP;
                break;
        case OP_CBRANCH:
                fixup_branch(state, ins, OP_JMP_NOTEQ, OP_TEST, 
                        RHS(ins, 0)->type, RHS(ins, 0), 0);
                break;
        case OP_CALL:
                ins->template_id = TEMPLATE_NOP;
                break;
        case OP_RET:
                ins->template_id = TEMPLATE_RET;
                break;
        case OP_INB:
        case OP_INW:
        case OP_INL:
                switch(ins->op) {
                case OP_INB: ins->template_id = TEMPLATE_INB_DX; break;
                case OP_INW: ins->template_id = TEMPLATE_INW_DX; break;
                case OP_INL: ins->template_id = TEMPLATE_INL_DX; break;
                }
                if (get_imm8(ins, &RHS(ins, 0))) {
                        ins->template_id += 1;
                }
                break;
        case OP_OUTB:
        case OP_OUTW:
        case OP_OUTL:
                switch(ins->op) {
                case OP_OUTB: ins->template_id = TEMPLATE_OUTB_DX; break;
                case OP_OUTW: ins->template_id = TEMPLATE_OUTW_DX; break;
                case OP_OUTL: ins->template_id = TEMPLATE_OUTL_DX; break;
                }
                if (get_imm8(ins, &RHS(ins, 1))) {
                        ins->template_id += 1;
                }
                break;
        case OP_BSF:
        case OP_BSR:
                ins->template_id = TEMPLATE_BSF;
                break;
        case OP_RDMSR:
                ins->template_id = TEMPLATE_RDMSR;
                next = after_lhs(state, ins);
                break;
        case OP_WRMSR:
                ins->template_id = TEMPLATE_WRMSR;
                break;
        case OP_HLT:
                ins->template_id = TEMPLATE_NOP;
                break;
        case OP_ASM:
                ins->template_id = TEMPLATE_NOP;
                next = after_lhs(state, ins);
                break;
                /* Already transformed instructions */
        case OP_TEST:
                ins->template_id = TEMPLATE_TEST32;
                break;
        case OP_CMP:
                ins->template_id = TEMPLATE_CMP32_REG;
                if (get_imm32(ins, &RHS(ins, 1))) {
                        ins->template_id = TEMPLATE_CMP32_IMM;
                }
                break;
        case OP_JMP:
                ins->template_id = TEMPLATE_NOP;
                break;
        case OP_JMP_EQ:      case OP_JMP_NOTEQ:
        case OP_JMP_SLESS:   case OP_JMP_ULESS:
        case OP_JMP_SMORE:   case OP_JMP_UMORE:
        case OP_JMP_SLESSEQ: case OP_JMP_ULESSEQ:
        case OP_JMP_SMOREEQ: case OP_JMP_UMOREEQ:
                ins->template_id = TEMPLATE_JMP;
                break;
        case OP_SET_EQ:      case OP_SET_NOTEQ:
        case OP_SET_SLESS:   case OP_SET_ULESS:
        case OP_SET_SMORE:   case OP_SET_UMORE:
        case OP_SET_SLESSEQ: case OP_SET_ULESSEQ:
        case OP_SET_SMOREEQ: case OP_SET_UMOREEQ:
                ins->template_id = TEMPLATE_SET;
                break;
        case OP_DEPOSIT:
                next = x86_deposit(state, ins);
                break;
        case OP_SEXTRACT:
        case OP_UEXTRACT:
                next = x86_extract(state, ins);
                break;
                /* Unhandled instructions */
        case OP_PIECE:
        default:
                internal_error(state, ins, "unhandled ins: %d %s",
                        ins->op, tops(ins->op));
                break;
        }
        return next;
}

static long next_label(struct compile_state *state)
{
        static long label_counter = 1000;
        return ++label_counter;
}
static void generate_local_labels(struct compile_state *state)
{
        struct triple *first, *label;
        first = state->first;
        label = first;
        do {
                if ((label->op == OP_LABEL) || 
                        (label->op == OP_SDECL)) {
                        if (label->use) {
                                label->u.cval = next_label(state);
                        } else {
                                label->u.cval = 0;
                        }
                        
                }
                label = label->next;
        } while(label != first);
}

static int check_reg(struct compile_state *state, 
        struct triple *triple, int classes)
{
        unsigned mask;
        int reg;
        reg = ID_REG(triple->id);
        if (reg == REG_UNSET) {
                internal_error(state, triple, "register not set");
        }
        mask = arch_reg_regcm(state, reg);
        if (!(classes & mask)) {
                internal_error(state, triple, "reg %d in wrong class",
                        reg);
        }
        return reg;
}


#if REG_XMM7 != 44
#error "Registers have renumberd fix arch_reg_str"
#endif
static const char *arch_regs[] = {
        "%unset",
        "%unneeded",
        "%eflags",
        "%al", "%bl", "%cl", "%dl", "%ah", "%bh", "%ch", "%dh",
        "%ax", "%bx", "%cx", "%dx", "%si", "%di", "%bp", "%sp",
        "%eax", "%ebx", "%ecx", "%edx", "%esi", "%edi", "%ebp", "%esp",
        "%edx:%eax",
        "%dx:%ax",
        "%mm0", "%mm1", "%mm2", "%mm3", "%mm4", "%mm5", "%mm6", "%mm7",
        "%xmm0", "%xmm1", "%xmm2", "%xmm3", 
        "%xmm4", "%xmm5", "%xmm6", "%xmm7",
};
static const char *arch_reg_str(int reg)
{
        if (!((reg >= REG_EFLAGS) && (reg <= REG_XMM7))) {
                reg = 0;
        }
        return arch_regs[reg];
}

static const char *reg(struct compile_state *state, struct triple *triple,
        int classes)
{
        int reg;
        reg = check_reg(state, triple, classes);
        return arch_reg_str(reg);
}

static int arch_reg_size(int reg)
{
        int size;
        size = 0;
        if (reg == REG_EFLAGS) {
                size = 32;
        }
        else if ((reg >= REG_AL) && (reg <= REG_DH)) {
                size = 8;
        }
        else if ((reg >= REG_AX) && (reg <= REG_SP)) {
                size = 16;
        }
        else if ((reg >= REG_EAX) && (reg <= REG_ESP)) {
                size = 32;
        }
        else if (reg == REG_EDXEAX) {
                size = 64;
        }
        else if (reg == REG_DXAX) {
                size = 32;
        }
        else if ((reg >= REG_MMX0) && (reg <= REG_MMX7)) {
                size = 64;
        }
        else if ((reg >= REG_XMM0) && (reg <= REG_XMM7)) {
                size = 128;
        }
        return size;
}

static int reg_size(struct compile_state *state, struct triple *ins)
{
        int reg;
        reg = ID_REG(ins->id);
        if (reg == REG_UNSET) {
                internal_error(state, ins, "register not set");
        }
        return arch_reg_size(reg);
}
        


const char *type_suffix(struct compile_state *state, struct type *type)
{
        const char *suffix;
        switch(size_of(state, type)) {
        case SIZEOF_I8:  suffix = "b"; break;
        case SIZEOF_I16: suffix = "w"; break;
        case SIZEOF_I32: suffix = "l"; break;
        default:
                internal_error(state, 0, "unknown suffix");
                suffix = 0;
                break;
        }
        return suffix;
}

static void print_const_val(
        struct compile_state *state, struct triple *ins, FILE *fp)
{
        switch(ins->op) {
        case OP_INTCONST:
                fprintf(fp, " $%ld ", 
                        (long)(ins->u.cval));
                break;
        case OP_ADDRCONST:
                if ((MISC(ins, 0)->op != OP_SDECL) &&
                        (MISC(ins, 0)->op != OP_LABEL))
                {
                        internal_error(state, ins, "bad base for addrconst");
                }
                if (MISC(ins, 0)->u.cval <= 0) {
                        internal_error(state, ins, "unlabeled constant");
                }
                fprintf(fp, " $L%s%lu+%lu ",
                        state->compiler->label_prefix, 
                        (unsigned long)(MISC(ins, 0)->u.cval),
                        (unsigned long)(ins->u.cval));
                break;
        default:
                internal_error(state, ins, "unknown constant type");
                break;
        }
}

static void print_const(struct compile_state *state,
        struct triple *ins, FILE *fp)
{
        switch(ins->op) {
        case OP_INTCONST:
                switch(ins->type->type & TYPE_MASK) {
                case TYPE_CHAR:
                case TYPE_UCHAR:
                        fprintf(fp, ".byte 0x%02lx\n", 
                                (unsigned long)(ins->u.cval));
                        break;
                case TYPE_SHORT:
                case TYPE_USHORT:
                        fprintf(fp, ".short 0x%04lx\n", 
                                (unsigned long)(ins->u.cval));
                        break;
                case TYPE_INT:
                case TYPE_UINT:
                case TYPE_LONG:
                case TYPE_ULONG:
                case TYPE_POINTER:
                        fprintf(fp, ".int %lu\n", 
                                (unsigned long)(ins->u.cval));
                        break;
                default:
                        fprintf(state->errout, "type: ");
                        name_of(state->errout, ins->type);
                        fprintf(state->errout, "\n");
                        internal_error(state, ins, "Unknown constant type. Val: %lu",
                                (unsigned long)(ins->u.cval));
                }
                
                break;
        case OP_ADDRCONST:
                if ((MISC(ins, 0)->op != OP_SDECL) &&
                        (MISC(ins, 0)->op != OP_LABEL)) {
                        internal_error(state, ins, "bad base for addrconst");
                }
                if (MISC(ins, 0)->u.cval <= 0) {
                        internal_error(state, ins, "unlabeled constant");
                }
                fprintf(fp, ".int L%s%lu+%lu\n",
                        state->compiler->label_prefix,
                        (unsigned long)(MISC(ins, 0)->u.cval),
                        (unsigned long)(ins->u.cval));
                break;
        case OP_BLOBCONST:
        {
                unsigned char *blob;
                size_t size, i;
                size = size_of_in_bytes(state, ins->type);
                blob = ins->u.blob;
                for(i = 0; i < size; i++) {
                        fprintf(fp, ".byte 0x%02x\n",
                                blob[i]);
                }
                break;
        }
        default:
                internal_error(state, ins, "Unknown constant type");
                break;
        }
}

#define TEXT_SECTION ".rom.text"
#define DATA_SECTION ".rom.data"

static long get_const_pool_ref(
        struct compile_state *state, struct triple *ins, size_t size, FILE *fp)
{
        size_t fill_bytes;
        long ref;
        ref = next_label(state);
        fprintf(fp, ".section \"" DATA_SECTION "\"\n");
        fprintf(fp, ".balign %d\n", align_of_in_bytes(state, ins->type));
        fprintf(fp, "L%s%lu:\n", state->compiler->label_prefix, ref);
        print_const(state, ins, fp);
        fill_bytes = bits_to_bytes(size - size_of(state, ins->type));
        if (fill_bytes) {
                fprintf(fp, ".fill %d, 1, 0\n", fill_bytes);
        }
        fprintf(fp, ".section \"" TEXT_SECTION "\"\n");
        return ref;
}

static long get_mask_pool_ref(
        struct compile_state *state, struct triple *ins, unsigned long mask, FILE *fp)
{
        long ref;
        if (mask == 0xff) {
                ref = 1;
        }
        else if (mask == 0xffff) {
                ref = 2;
        }
        else {
                ref = 0;
                internal_error(state, ins, "unhandled mask value");
        }
        return ref;
}

static void print_binary_op(struct compile_state *state,
        const char *op, struct triple *ins, FILE *fp) 
{
        unsigned mask;
        mask = REGCM_GPR32 | REGCM_GPR16 | REGCM_GPR8_LO;
        if (ID_REG(RHS(ins, 0)->id) != ID_REG(ins->id)) {
                internal_error(state, ins, "invalid register assignment");
        }
        if (is_const(RHS(ins, 1))) {
                fprintf(fp, "\t%s ", op);
                print_const_val(state, RHS(ins, 1), fp);
                fprintf(fp, ", %s\n",
                        reg(state, RHS(ins, 0), mask));
        }
        else {
                unsigned lmask, rmask;
                int lreg, rreg;
                lreg = check_reg(state, RHS(ins, 0), mask);
                rreg = check_reg(state, RHS(ins, 1), mask);
                lmask = arch_reg_regcm(state, lreg);
                rmask = arch_reg_regcm(state, rreg);
                mask = lmask & rmask;
                fprintf(fp, "\t%s %s, %s\n",
                        op,
                        reg(state, RHS(ins, 1), mask),
                        reg(state, RHS(ins, 0), mask));
        }
}
static void print_unary_op(struct compile_state *state, 
        const char *op, struct triple *ins, FILE *fp)
{
        unsigned mask;
        mask = REGCM_GPR32 | REGCM_GPR16 | REGCM_GPR8_LO;
        fprintf(fp, "\t%s %s\n",
                op,
                reg(state, RHS(ins, 0), mask));
}

static void print_op_shift(struct compile_state *state,
        const char *op, struct triple *ins, FILE *fp)
{
        unsigned mask;
        mask = REGCM_GPR32 | REGCM_GPR16 | REGCM_GPR8_LO;
        if (ID_REG(RHS(ins, 0)->id) != ID_REG(ins->id)) {
                internal_error(state, ins, "invalid register assignment");
        }
        if (is_const(RHS(ins, 1))) {
                fprintf(fp, "\t%s ", op);
                print_const_val(state, RHS(ins, 1), fp);
                fprintf(fp, ", %s\n",
                        reg(state, RHS(ins, 0), mask));
        }
        else {
                fprintf(fp, "\t%s %s, %s\n",
                        op,
                        reg(state, RHS(ins, 1), REGCM_GPR8_LO),
                        reg(state, RHS(ins, 0), mask));
        }
}

static void print_op_in(struct compile_state *state, struct triple *ins, FILE *fp)
{
        const char *op;
        int mask;
        int dreg;
        mask = 0;
        switch(ins->op) {
        case OP_INB: op = "inb", mask = REGCM_GPR8_LO; break;
        case OP_INW: op = "inw", mask = REGCM_GPR16; break;
        case OP_INL: op = "inl", mask = REGCM_GPR32; break;
        default:
                internal_error(state, ins, "not an in operation");
                op = 0;
                break;
        }
        dreg = check_reg(state, ins, mask);
        if (!reg_is_reg(state, dreg, REG_EAX)) {
                internal_error(state, ins, "dst != %%eax");
        }
        if (is_const(RHS(ins, 0))) {
                fprintf(fp, "\t%s ", op);
                print_const_val(state, RHS(ins, 0), fp);
                fprintf(fp, ", %s\n",
                        reg(state, ins, mask));
        }
        else {
                int addr_reg;
                addr_reg = check_reg(state, RHS(ins, 0), REGCM_GPR16);
                if (!reg_is_reg(state, addr_reg, REG_DX)) {
                        internal_error(state, ins, "src != %%dx");
                }
                fprintf(fp, "\t%s %s, %s\n",
                        op, 
                        reg(state, RHS(ins, 0), REGCM_GPR16),
                        reg(state, ins, mask));
        }
}

static void print_op_out(struct compile_state *state, struct triple *ins, FILE *fp)
{
        const char *op;
        int mask;
        int lreg;
        mask = 0;
        switch(ins->op) {
        case OP_OUTB: op = "outb", mask = REGCM_GPR8_LO; break;
        case OP_OUTW: op = "outw", mask = REGCM_GPR16; break;
        case OP_OUTL: op = "outl", mask = REGCM_GPR32; break;
        default:
                internal_error(state, ins, "not an out operation");
                op = 0;
                break;
        }
        lreg = check_reg(state, RHS(ins, 0), mask);
        if (!reg_is_reg(state, lreg, REG_EAX)) {
                internal_error(state, ins, "src != %%eax");
        }
        if (is_const(RHS(ins, 1))) {
                fprintf(fp, "\t%s %s,", 
                        op, reg(state, RHS(ins, 0), mask));
                print_const_val(state, RHS(ins, 1), fp);
                fprintf(fp, "\n");
        }
        else {
                int addr_reg;
                addr_reg = check_reg(state, RHS(ins, 1), REGCM_GPR16);
                if (!reg_is_reg(state, addr_reg, REG_DX)) {
                        internal_error(state, ins, "dst != %%dx");
                }
                fprintf(fp, "\t%s %s, %s\n",
                        op, 
                        reg(state, RHS(ins, 0), mask),
                        reg(state, RHS(ins, 1), REGCM_GPR16));
        }
}

static void print_op_move(struct compile_state *state,
        struct triple *ins, FILE *fp)
{
        /* op_move is complex because there are many types
         * of registers we can move between.
         * Because OP_COPY will be introduced in arbitrary locations
         * OP_COPY must not affect flags.
         * OP_CONVERT can change the flags and it is the only operation
         * where it is expected the types in the registers can change.
         */
        int omit_copy = 1; /* Is it o.k. to omit a noop copy? */
        struct triple *dst, *src;
        if (state->arch->features & X86_NOOP_COPY) {
                omit_copy = 0;
        }
        if ((ins->op == OP_COPY) || (ins->op == OP_CONVERT)) {
                src = RHS(ins, 0);
                dst = ins;
        }
        else {
                internal_error(state, ins, "unknown move operation");
                src = dst = 0;
        }
        if (reg_size(state, dst) < size_of(state, dst->type)) {
                internal_error(state, ins, "Invalid destination register");
        }
        if (!equiv_types(src->type, dst->type) && (dst->op == OP_COPY)) {
                fprintf(state->errout, "src type: ");
                name_of(state->errout, src->type);
                fprintf(state->errout, "\n");
                fprintf(state->errout, "dst type: ");
                name_of(state->errout, dst->type);
                fprintf(state->errout, "\n");
                internal_error(state, ins, "Type mismatch for OP_COPY");
        }

        if (!is_const(src)) {
                int src_reg, dst_reg;
                int src_regcm, dst_regcm;
                src_reg   = ID_REG(src->id);
                dst_reg   = ID_REG(dst->id);
                src_regcm = arch_reg_regcm(state, src_reg);
                dst_regcm = arch_reg_regcm(state, dst_reg);
                /* If the class is the same just move the register */
                if (src_regcm & dst_regcm & 
                        (REGCM_GPR8_LO | REGCM_GPR16 | REGCM_GPR32)) {
                        if ((src_reg != dst_reg) || !omit_copy) {
                                fprintf(fp, "\tmov %s, %s\n",
                                        reg(state, src, src_regcm),
                                        reg(state, dst, dst_regcm));
                        }
                }
                /* Move 32bit to 16bit */
                else if ((src_regcm & REGCM_GPR32) &&
                        (dst_regcm & REGCM_GPR16)) {
                        src_reg = (src_reg - REGC_GPR32_FIRST) + REGC_GPR16_FIRST;
                        if ((src_reg != dst_reg) || !omit_copy) {
                                fprintf(fp, "\tmovw %s, %s\n",
                                        arch_reg_str(src_reg), 
                                        arch_reg_str(dst_reg));
                        }
                }
                /* Move from 32bit gprs to 16bit gprs */
                else if ((src_regcm & REGCM_GPR32) &&
                        (dst_regcm & REGCM_GPR16)) {
                        dst_reg = (dst_reg - REGC_GPR16_FIRST) + REGC_GPR32_FIRST;
                        if ((src_reg != dst_reg) || !omit_copy) {
                                fprintf(fp, "\tmov %s, %s\n",
                                        arch_reg_str(src_reg),
                                        arch_reg_str(dst_reg));
                        }
                }
                /* Move 32bit to 8bit */
                else if ((src_regcm & REGCM_GPR32_8) &&
                        (dst_regcm & REGCM_GPR8_LO))
                {
                        src_reg = (src_reg - REGC_GPR32_8_FIRST) + REGC_GPR8_FIRST;
                        if ((src_reg != dst_reg) || !omit_copy) {
                                fprintf(fp, "\tmovb %s, %s\n",
                                        arch_reg_str(src_reg),
                                        arch_reg_str(dst_reg));
                        }
                }
                /* Move 16bit to 8bit */
                else if ((src_regcm & REGCM_GPR16_8) &&
                        (dst_regcm & REGCM_GPR8_LO))
                {
                        src_reg = (src_reg - REGC_GPR16_8_FIRST) + REGC_GPR8_FIRST;
                        if ((src_reg != dst_reg) || !omit_copy) {
                                fprintf(fp, "\tmovb %s, %s\n",
                                        arch_reg_str(src_reg),
                                        arch_reg_str(dst_reg));
                        }
                }
                /* Move 8/16bit to 16/32bit */
                else if ((src_regcm & (REGCM_GPR8_LO | REGCM_GPR16)) && 
                        (dst_regcm & (REGCM_GPR16 | REGCM_GPR32))) {
                        const char *op;
                        op = is_signed(src->type)? "movsx": "movzx";
                        fprintf(fp, "\t%s %s, %s\n",
                                op,
                                reg(state, src, src_regcm),
                                reg(state, dst, dst_regcm));
                }
                /* Move between sse registers */
                else if ((src_regcm & dst_regcm & REGCM_XMM)) {
                        if ((src_reg != dst_reg) || !omit_copy) {
                                fprintf(fp, "\tmovdqa %s, %s\n",
                                        reg(state, src, src_regcm),
                                        reg(state, dst, dst_regcm));
                        }
                }
                /* Move between mmx registers */
                else if ((src_regcm & dst_regcm & REGCM_MMX)) {
                        if ((src_reg != dst_reg) || !omit_copy) {
                                fprintf(fp, "\tmovq %s, %s\n",
                                        reg(state, src, src_regcm),
                                        reg(state, dst, dst_regcm));
                        }
                }
                /* Move from sse to mmx registers */
                else if ((src_regcm & REGCM_XMM) && (dst_regcm & REGCM_MMX)) {
                        fprintf(fp, "\tmovdq2q %s, %s\n",
                                reg(state, src, src_regcm),
                                reg(state, dst, dst_regcm));
                }
                /* Move from mmx to sse registers */
                else if ((src_regcm & REGCM_MMX) && (dst_regcm & REGCM_XMM)) {
                        fprintf(fp, "\tmovq2dq %s, %s\n",
                                reg(state, src, src_regcm),
                                reg(state, dst, dst_regcm));
                }
                /* Move between 32bit gprs & mmx/sse registers */
                else if ((src_regcm & (REGCM_GPR32 | REGCM_MMX | REGCM_XMM)) &&
                        (dst_regcm & (REGCM_GPR32 | REGCM_MMX | REGCM_XMM))) {
                        fprintf(fp, "\tmovd %s, %s\n",
                                reg(state, src, src_regcm),
                                reg(state, dst, dst_regcm));
                }
                /* Move from 16bit gprs &  mmx/sse registers */
                else if ((src_regcm & REGCM_GPR16) &&
                        (dst_regcm & (REGCM_MMX | REGCM_XMM))) {
                        const char *op;
                        int mid_reg;
                        op = is_signed(src->type)? "movsx":"movzx";
                        mid_reg = (src_reg - REGC_GPR16_FIRST) + REGC_GPR32_FIRST;
                        fprintf(fp, "\t%s %s, %s\n\tmovd %s, %s\n",
                                op,
                                arch_reg_str(src_reg),
                                arch_reg_str(mid_reg),
                                arch_reg_str(mid_reg),
                                arch_reg_str(dst_reg));
                }
                /* Move from mmx/sse registers to 16bit gprs */
                else if ((src_regcm & (REGCM_MMX | REGCM_XMM)) &&
                        (dst_regcm & REGCM_GPR16)) {
                        dst_reg = (dst_reg - REGC_GPR16_FIRST) + REGC_GPR32_FIRST;
                        fprintf(fp, "\tmovd %s, %s\n",
                                arch_reg_str(src_reg),
                                arch_reg_str(dst_reg));
                }
                /* Move from gpr to 64bit dividend */
                else if ((src_regcm & (REGCM_GPR32 | REGCM_GPR16 | REGCM_GPR8_LO))  &&
                        (dst_regcm & REGCM_DIVIDEND64)) {
                        const char *extend;
                        extend = is_signed(src->type)? "cltd":"movl $0, %edx";
                        fprintf(fp, "\tmov %s, %%eax\n\t%s\n",
                                arch_reg_str(src_reg), 
                                extend);
                }
                /* Move from 64bit gpr to gpr */
                else if ((src_regcm & REGCM_DIVIDEND64) &&
                        (dst_regcm & (REGCM_GPR32 | REGCM_GPR16 | REGCM_GPR8_LO))) {
                        if (dst_regcm & REGCM_GPR32) {
                                src_reg = REG_EAX;
                        } 
                        else if (dst_regcm & REGCM_GPR16) {
                                src_reg = REG_AX;
                        }
                        else if (dst_regcm & REGCM_GPR8_LO) {
                                src_reg = REG_AL;
                        }
                        fprintf(fp, "\tmov %s, %s\n",
                                arch_reg_str(src_reg),
                                arch_reg_str(dst_reg));
                }
                /* Move from mmx/sse registers to 64bit gpr */
                else if ((src_regcm & (REGCM_MMX | REGCM_XMM)) &&
                        (dst_regcm & REGCM_DIVIDEND64)) {
                        const char *extend;
                        extend = is_signed(src->type)? "cltd": "movl $0, %edx";
                        fprintf(fp, "\tmovd %s, %%eax\n\t%s\n",
                                arch_reg_str(src_reg),
                                extend);
                }
                /* Move from 64bit gpr to mmx/sse register */
                else if ((src_regcm & REGCM_DIVIDEND64) &&
                        (dst_regcm & (REGCM_XMM | REGCM_MMX))) {
                        fprintf(fp, "\tmovd %%eax, %s\n",
                                arch_reg_str(dst_reg));
                }
#if X86_4_8BIT_GPRS
                /* Move from 8bit gprs to  mmx/sse registers */
                else if ((src_regcm & REGCM_GPR8_LO) && (src_reg <= REG_DL) &&
                        (dst_regcm & (REGCM_MMX | REGCM_XMM))) {
                        const char *op;
                        int mid_reg;
                        op = is_signed(src->type)? "movsx":"movzx";
                        mid_reg = (src_reg - REGC_GPR8_FIRST) + REGC_GPR32_FIRST;
                        fprintf(fp, "\t%s %s, %s\n\tmovd %s, %s\n",
                                op,
                                reg(state, src, src_regcm),
                                arch_reg_str(mid_reg),
                                arch_reg_str(mid_reg),
                                reg(state, dst, dst_regcm));
                }
                /* Move from mmx/sse registers and 8bit gprs */
                else if ((src_regcm & (REGCM_MMX | REGCM_XMM)) &&
                        (dst_regcm & REGCM_GPR8_LO) && (dst_reg <= REG_DL)) {
                        int mid_reg;
                        mid_reg = (dst_reg - REGC_GPR8_FIRST) + REGC_GPR32_FIRST;
                        fprintf(fp, "\tmovd %s, %s\n",
                                reg(state, src, src_regcm),
                                arch_reg_str(mid_reg));
                }
                /* Move from 32bit gprs to 8bit gprs */
                else if ((src_regcm & REGCM_GPR32) &&
                        (dst_regcm & REGCM_GPR8_LO)) {
                        dst_reg = (dst_reg - REGC_GPR8_FIRST) + REGC_GPR32_FIRST;
                        if ((src_reg != dst_reg) || !omit_copy) {
                                fprintf(fp, "\tmov %s, %s\n",
                                        arch_reg_str(src_reg),
                                        arch_reg_str(dst_reg));
                        }
                }
                /* Move from 16bit gprs to 8bit gprs */
                else if ((src_regcm & REGCM_GPR16) &&
                        (dst_regcm & REGCM_GPR8_LO)) {
                        dst_reg = (dst_reg - REGC_GPR8_FIRST) + REGC_GPR16_FIRST;
                        if ((src_reg != dst_reg) || !omit_copy) {
                                fprintf(fp, "\tmov %s, %s\n",
                                        arch_reg_str(src_reg),
                                        arch_reg_str(dst_reg));
                        }
                }
#endif /* X86_4_8BIT_GPRS */
                /* Move from %eax:%edx to %eax:%edx */
                else if ((src_regcm & REGCM_DIVIDEND64) &&
                        (dst_regcm & REGCM_DIVIDEND64) &&
                        (src_reg == dst_reg)) {
                        if (!omit_copy) {
                                fprintf(fp, "\t/*mov %s, %s*/\n",
                                        arch_reg_str(src_reg),
                                        arch_reg_str(dst_reg));
                        }
                }
                else {
                        if ((src_regcm & ~REGCM_FLAGS) == 0) {
                                internal_error(state, ins, "attempt to copy from %%eflags!");
                        }
                        internal_error(state, ins, "unknown copy type");
                }
        }
        else {
                size_t dst_size;
                int dst_reg;
                int dst_regcm;
                dst_size = size_of(state, dst->type);
                dst_reg = ID_REG(dst->id);
                dst_regcm = arch_reg_regcm(state, dst_reg);
                if (dst_regcm & (REGCM_GPR32 | REGCM_GPR16 | REGCM_GPR8_LO)) {
                        fprintf(fp, "\tmov ");
                        print_const_val(state, src, fp);
                        fprintf(fp, ", %s\n",
                                reg(state, dst, REGCM_GPR32 | REGCM_GPR16 | REGCM_GPR8_LO));
                }
                else if (dst_regcm & REGCM_DIVIDEND64) {
                        if (dst_size > SIZEOF_I32) {
                                internal_error(state, ins, "%dbit constant...", dst_size);
                        }
                        fprintf(fp, "\tmov $0, %%edx\n");
                        fprintf(fp, "\tmov ");
                        print_const_val(state, src, fp);
                        fprintf(fp, ", %%eax\n");
                }
                else if (dst_regcm & REGCM_DIVIDEND32) {
                        if (dst_size > SIZEOF_I16) {
                                internal_error(state, ins, "%dbit constant...", dst_size);
                        }
                        fprintf(fp, "\tmov $0, %%dx\n");
                        fprintf(fp, "\tmov ");
                        print_const_val(state, src, fp);
                        fprintf(fp, ", %%ax");
                }
                else if (dst_regcm & (REGCM_XMM | REGCM_MMX)) {
                        long ref;
                        if (dst_size > SIZEOF_I32) {
                                internal_error(state, ins, "%d bit constant...", dst_size);
                        }
                        ref = get_const_pool_ref(state, src, SIZEOF_I32, fp);
                        fprintf(fp, "\tmovd L%s%lu, %s\n",
                                state->compiler->label_prefix, ref,
                                reg(state, dst, (REGCM_XMM | REGCM_MMX)));
                }
                else {
                        internal_error(state, ins, "unknown copy immediate type");
                }
        }
        /* Leave now if this is not a type conversion */
        if (ins->op != OP_CONVERT) {
                return;
        }
        /* Now make certain I have not logically overflowed the destination */
        if ((size_of(state, src->type) > size_of(state, dst->type)) &&
                (size_of(state, dst->type) < reg_size(state, dst)))
        {
                unsigned long mask;
                int dst_reg;
                int dst_regcm;
                if (size_of(state, dst->type) >= 32) {
                        fprintf(state->errout, "dst type: ");
                        name_of(state->errout, dst->type);
                        fprintf(state->errout, "\n");
                        internal_error(state, dst, "unhandled dst type size");
                }
                mask = 1;
                mask <<= size_of(state, dst->type);
                mask -= 1;

                dst_reg = ID_REG(dst->id);
                dst_regcm = arch_reg_regcm(state, dst_reg);

                if (dst_regcm & (REGCM_GPR32 | REGCM_GPR16 | REGCM_GPR8_LO)) {
                        fprintf(fp, "\tand $0x%lx, %s\n",
                                mask, reg(state, dst, REGCM_GPR32 | REGCM_GPR16 | REGCM_GPR8_LO));
                }
                else if (dst_regcm & REGCM_MMX) {
                        long ref;
                        ref = get_mask_pool_ref(state, dst, mask, fp);
                        fprintf(fp, "\tpand L%s%lu, %s\n",
                                state->compiler->label_prefix, ref,
                                reg(state, dst, REGCM_MMX));
                }
                else if (dst_regcm & REGCM_XMM) {
                        long ref;
                        ref = get_mask_pool_ref(state, dst, mask, fp);
                        fprintf(fp, "\tpand L%s%lu, %s\n",
                                state->compiler->label_prefix, ref,
                                reg(state, dst, REGCM_XMM));
                }
                else {
                        fprintf(state->errout, "dst type: ");
                        name_of(state->errout, dst->type);
                        fprintf(state->errout, "\n");
                        fprintf(state->errout, "dst: %s\n", reg(state, dst, REGCM_ALL));
                        internal_error(state, dst, "failed to trunc value: mask %lx", mask);
                }
        }
        /* Make certain I am properly sign extended */
        if ((size_of(state, src->type) < size_of(state, dst->type)) &&
                (is_signed(src->type)))
        {
                int bits, reg_bits, shift_bits;
                int dst_reg;
                int dst_regcm;

                bits = size_of(state, src->type);
                reg_bits = reg_size(state, dst);
                if (reg_bits > 32) {
                        reg_bits = 32;
                }
                shift_bits = reg_bits - size_of(state, src->type);
                dst_reg = ID_REG(dst->id);
                dst_regcm = arch_reg_regcm(state, dst_reg);

                if (shift_bits < 0) {
                        internal_error(state, dst, "negative shift?");
                }

                if (dst_regcm & (REGCM_GPR32 | REGCM_GPR16 | REGCM_GPR8_LO)) {
                        fprintf(fp, "\tshl $%d, %s\n", 
                                shift_bits, 
                                reg(state, dst, REGCM_GPR32 | REGCM_GPR16 | REGCM_GPR8_LO));
                        fprintf(fp, "\tsar $%d, %s\n", 
                                shift_bits, 
                                reg(state, dst, REGCM_GPR32 | REGCM_GPR16 | REGCM_GPR8_LO));
                }
                else if (dst_regcm & (REGCM_MMX | REGCM_XMM)) {
                        fprintf(fp, "\tpslld $%d, %s\n",
                                shift_bits, 
                                reg(state, dst, REGCM_MMX | REGCM_XMM));
                        fprintf(fp, "\tpsrad $%d, %s\n",
                                shift_bits, 
                                reg(state, dst, REGCM_MMX | REGCM_XMM));
                }
                else {
                        fprintf(state->errout, "dst type: ");
                        name_of(state->errout, dst->type);
                        fprintf(state->errout, "\n");
                        fprintf(state->errout, "dst: %s\n", reg(state, dst, REGCM_ALL));
                        internal_error(state, dst, "failed to signed extend value");
                }
        }
}

static void print_op_load(struct compile_state *state,
        struct triple *ins, FILE *fp)
{
        struct triple *dst, *src;
        const char *op;
        dst = ins;
        src = RHS(ins, 0);
        if (is_const(src) || is_const(dst)) {
                internal_error(state, ins, "unknown load operation");
        }
        switch(ins->type->type & TYPE_MASK) {
        case TYPE_CHAR:   op = "movsbl"; break;
        case TYPE_UCHAR:  op = "movzbl"; break;
        case TYPE_SHORT:  op = "movswl"; break;
        case TYPE_USHORT: op = "movzwl"; break;
        case TYPE_INT:    case TYPE_UINT:
        case TYPE_LONG:   case TYPE_ULONG:
        case TYPE_POINTER:
                op = "movl"; 
                break;
        default:
                internal_error(state, ins, "unknown type in load");
                op = "<invalid opcode>";
                break;
        }
        fprintf(fp, "\t%s (%s), %s\n",
                op, 
                reg(state, src, REGCM_GPR32),
                reg(state, dst, REGCM_GPR32));
}


static void print_op_store(struct compile_state *state,
        struct triple *ins, FILE *fp)
{
        struct triple *dst, *src;
        dst = RHS(ins, 0);
        src = RHS(ins, 1);
        if (is_const(src) && (src->op == OP_INTCONST)) {
                long_t value;
                value = (long_t)(src->u.cval);
                fprintf(fp, "\tmov%s $%ld, (%s)\n",
                        type_suffix(state, src->type),
                        (long)(value),
                        reg(state, dst, REGCM_GPR32));
        }
        else if (is_const(dst) && (dst->op == OP_INTCONST)) {
                fprintf(fp, "\tmov%s %s, 0x%08lx\n",
                        type_suffix(state, src->type),
                        reg(state, src, REGCM_GPR8_LO | REGCM_GPR16 | REGCM_GPR32),
                        (unsigned long)(dst->u.cval));
        }
        else {
                if (is_const(src) || is_const(dst)) {
                        internal_error(state, ins, "unknown store operation");
                }
                fprintf(fp, "\tmov%s %s, (%s)\n",
                        type_suffix(state, src->type),
                        reg(state, src, REGCM_GPR8_LO | REGCM_GPR16 | REGCM_GPR32),
                        reg(state, dst, REGCM_GPR32));
        }
        
        
}

static void print_op_smul(struct compile_state *state,
        struct triple *ins, FILE *fp)
{
        if (!is_const(RHS(ins, 1))) {
                fprintf(fp, "\timul %s, %s\n",
                        reg(state, RHS(ins, 1), REGCM_GPR32),
                        reg(state, RHS(ins, 0), REGCM_GPR32));
        }
        else {
                fprintf(fp, "\timul ");
                print_const_val(state, RHS(ins, 1), fp);
                fprintf(fp, ", %s\n", reg(state, RHS(ins, 0), REGCM_GPR32));
        }
}

static void print_op_cmp(struct compile_state *state,
        struct triple *ins, FILE *fp)
{
        unsigned mask;
        int dreg;
        mask = REGCM_GPR32 | REGCM_GPR16 | REGCM_GPR8_LO;
        dreg = check_reg(state, ins, REGCM_FLAGS);
        if (!reg_is_reg(state, dreg, REG_EFLAGS)) {
                internal_error(state, ins, "bad dest register for cmp");
        }
        if (is_const(RHS(ins, 1))) {
                fprintf(fp, "\tcmp ");
                print_const_val(state, RHS(ins, 1), fp);
                fprintf(fp, ", %s\n", reg(state, RHS(ins, 0), mask));
        }
        else {
                unsigned lmask, rmask;
                int lreg, rreg;
                lreg = check_reg(state, RHS(ins, 0), mask);
                rreg = check_reg(state, RHS(ins, 1), mask);
                lmask = arch_reg_regcm(state, lreg);
                rmask = arch_reg_regcm(state, rreg);
                mask = lmask & rmask;
                fprintf(fp, "\tcmp %s, %s\n",
                        reg(state, RHS(ins, 1), mask),
                        reg(state, RHS(ins, 0), mask));
        }
}

static void print_op_test(struct compile_state *state,
        struct triple *ins, FILE *fp)
{
        unsigned mask;
        mask = REGCM_GPR32 | REGCM_GPR16 | REGCM_GPR8_LO;
        fprintf(fp, "\ttest %s, %s\n",
                reg(state, RHS(ins, 0), mask),
                reg(state, RHS(ins, 0), mask));
}

static void print_op_branch(struct compile_state *state,
        struct triple *branch, FILE *fp)
{
        const char *bop = "j";
        if ((branch->op == OP_JMP) || (branch->op == OP_CALL)) {
                if (branch->rhs != 0) {
                        internal_error(state, branch, "jmp with condition?");
                }
                bop = "jmp";
        }
        else {
                struct triple *ptr;
                if (branch->rhs != 1) {
                        internal_error(state, branch, "jmpcc without condition?");
                }
                check_reg(state, RHS(branch, 0), REGCM_FLAGS);
                if ((RHS(branch, 0)->op != OP_CMP) &&
                        (RHS(branch, 0)->op != OP_TEST)) {
                        internal_error(state, branch, "bad branch test");
                }
#warning "FIXME I have observed instructions between the test and branch instructions"
                ptr = RHS(branch, 0);
                for(ptr = RHS(branch, 0)->next; ptr != branch; ptr = ptr->next) {
                        if (ptr->op != OP_COPY) {
                                internal_error(state, branch, "branch does not follow test");
                        }
                }
                switch(branch->op) {
                case OP_JMP_EQ:       bop = "jz";  break;
                case OP_JMP_NOTEQ:    bop = "jnz"; break;
                case OP_JMP_SLESS:    bop = "jl";  break;
                case OP_JMP_ULESS:    bop = "jb";  break;
                case OP_JMP_SMORE:    bop = "jg";  break;
                case OP_JMP_UMORE:    bop = "ja";  break;
                case OP_JMP_SLESSEQ:  bop = "jle"; break;
                case OP_JMP_ULESSEQ:  bop = "jbe"; break;
                case OP_JMP_SMOREEQ:  bop = "jge"; break;
                case OP_JMP_UMOREEQ:  bop = "jae"; break;
                default:
                        internal_error(state, branch, "Invalid branch op");
                        break;
                }
                
        }
#if 1
        if (branch->op == OP_CALL) {
                fprintf(fp, "\t/* call */\n");
        }
#endif
        fprintf(fp, "\t%s L%s%lu\n",
                bop, 
                state->compiler->label_prefix,
                (unsigned long)(TARG(branch, 0)->u.cval));
}

static void print_op_ret(struct compile_state *state,
        struct triple *branch, FILE *fp)
{
        fprintf(fp, "\tjmp *%s\n",
                reg(state, RHS(branch, 0), REGCM_GPR32));
}

static void print_op_set(struct compile_state *state,
        struct triple *set, FILE *fp)
{
        const char *sop = "set";
        if (set->rhs != 1) {
                internal_error(state, set, "setcc without condition?");
        }
        check_reg(state, RHS(set, 0), REGCM_FLAGS);
        if ((RHS(set, 0)->op != OP_CMP) &&
                (RHS(set, 0)->op != OP_TEST)) {
                internal_error(state, set, "bad set test");
        }
        if (RHS(set, 0)->next != set) {
                internal_error(state, set, "set does not follow test");
        }
        switch(set->op) {
        case OP_SET_EQ:       sop = "setz";  break;
        case OP_SET_NOTEQ:    sop = "setnz"; break;
        case OP_SET_SLESS:    sop = "setl";  break;
        case OP_SET_ULESS:    sop = "setb";  break;
        case OP_SET_SMORE:    sop = "setg";  break;
        case OP_SET_UMORE:    sop = "seta";  break;
        case OP_SET_SLESSEQ:  sop = "setle"; break;
        case OP_SET_ULESSEQ:  sop = "setbe"; break;
        case OP_SET_SMOREEQ:  sop = "setge"; break;
        case OP_SET_UMOREEQ:  sop = "setae"; break;
        default:
                internal_error(state, set, "Invalid set op");
                break;
        }
        fprintf(fp, "\t%s %s\n",
                sop, reg(state, set, REGCM_GPR8_LO));
}

static void print_op_bit_scan(struct compile_state *state, 
        struct triple *ins, FILE *fp) 
{
        const char *op;
        switch(ins->op) {
        case OP_BSF: op = "bsf"; break;
        case OP_BSR: op = "bsr"; break;
        default: 
                internal_error(state, ins, "unknown bit scan");
                op = 0;
                break;
        }
        fprintf(fp, 
                "\t%s %s, %s\n"
                "\tjnz 1f\n"
                "\tmovl $-1, %s\n"
                "1:\n",
                op,
                reg(state, RHS(ins, 0), REGCM_GPR32),
                reg(state, ins, REGCM_GPR32),
                reg(state, ins, REGCM_GPR32));
}


static void print_sdecl(struct compile_state *state,
        struct triple *ins, FILE *fp)
{
        fprintf(fp, ".section \"" DATA_SECTION "\"\n");
        fprintf(fp, ".balign %d\n", align_of_in_bytes(state, ins->type));
        fprintf(fp, "L%s%lu:\n", 
                state->compiler->label_prefix, (unsigned long)(ins->u.cval));
        print_const(state, MISC(ins, 0), fp);
        fprintf(fp, ".section \"" TEXT_SECTION "\"\n");
                
}

static void print_instruction(struct compile_state *state,
        struct triple *ins, FILE *fp)
{
        /* Assumption: after I have exted the register allocator
         * everything is in a valid register. 
         */
        switch(ins->op) {
        case OP_ASM:
                print_op_asm(state, ins, fp);
                break;
        case OP_ADD:    print_binary_op(state, "add", ins, fp); break;
        case OP_SUB:    print_binary_op(state, "sub", ins, fp); break;
        case OP_AND:    print_binary_op(state, "and", ins, fp); break;
        case OP_XOR:    print_binary_op(state, "xor", ins, fp); break;
        case OP_OR:     print_binary_op(state, "or",  ins, fp); break;
        case OP_SL:     print_op_shift(state, "shl", ins, fp); break;
        case OP_USR:    print_op_shift(state, "shr", ins, fp); break;
        case OP_SSR:    print_op_shift(state, "sar", ins, fp); break;
        case OP_POS:    break;
        case OP_NEG:    print_unary_op(state, "neg", ins, fp); break;
        case OP_INVERT: print_unary_op(state, "not", ins, fp); break;
        case OP_NOOP:
        case OP_INTCONST:
        case OP_ADDRCONST:
        case OP_BLOBCONST:
                /* Don't generate anything here for constants */
        case OP_PHI:
                /* Don't generate anything for variable declarations. */
                break;
        case OP_UNKNOWNVAL:
                fprintf(fp, " /* unknown %s */\n",
                        reg(state, ins, REGCM_ALL));
                break;
        case OP_SDECL:
                print_sdecl(state, ins, fp);
                break;
        case OP_COPY:   
        case OP_CONVERT:
                print_op_move(state, ins, fp);
                break;
        case OP_LOAD:
                print_op_load(state, ins, fp);
                break;
        case OP_STORE:
                print_op_store(state, ins, fp);
                break;
        case OP_SMUL:
                print_op_smul(state, ins, fp);
                break;
        case OP_CMP:    print_op_cmp(state, ins, fp); break;
        case OP_TEST:   print_op_test(state, ins, fp); break;
        case OP_JMP:
        case OP_JMP_EQ:      case OP_JMP_NOTEQ:
        case OP_JMP_SLESS:   case OP_JMP_ULESS:
        case OP_JMP_SMORE:   case OP_JMP_UMORE:
        case OP_JMP_SLESSEQ: case OP_JMP_ULESSEQ:
        case OP_JMP_SMOREEQ: case OP_JMP_UMOREEQ:
        case OP_CALL:
                print_op_branch(state, ins, fp);
                break;
        case OP_RET:
                print_op_ret(state, ins, fp);
                break;
        case OP_SET_EQ:      case OP_SET_NOTEQ:
        case OP_SET_SLESS:   case OP_SET_ULESS:
        case OP_SET_SMORE:   case OP_SET_UMORE:
        case OP_SET_SLESSEQ: case OP_SET_ULESSEQ:
        case OP_SET_SMOREEQ: case OP_SET_UMOREEQ:
                print_op_set(state, ins, fp);
                break;
        case OP_INB:  case OP_INW:  case OP_INL:
                print_op_in(state, ins, fp); 
                break;
        case OP_OUTB: case OP_OUTW: case OP_OUTL:
                print_op_out(state, ins, fp); 
                break;
        case OP_BSF:
        case OP_BSR:
                print_op_bit_scan(state, ins, fp);
                break;
        case OP_RDMSR:
                after_lhs(state, ins);
                fprintf(fp, "\trdmsr\n");
                break;
        case OP_WRMSR:
                fprintf(fp, "\twrmsr\n");
                break;
        case OP_HLT:
                fprintf(fp, "\thlt\n");
                break;
        case OP_SDIVT:
                fprintf(fp, "\tidiv %s\n", reg(state, RHS(ins, 1), REGCM_GPR32));
                break;
        case OP_UDIVT:
                fprintf(fp, "\tdiv %s\n", reg(state, RHS(ins, 1), REGCM_GPR32));
                break;
        case OP_UMUL:
                fprintf(fp, "\tmul %s\n", reg(state, RHS(ins, 1), REGCM_GPR32));
                break;
        case OP_LABEL:
                if (!ins->use) {
                        return;
                }
                fprintf(fp, "L%s%lu:\n", 
                        state->compiler->label_prefix, (unsigned long)(ins->u.cval));
                break;
        case OP_ADECL:
                /* Ignore adecls with no registers error otherwise */
                if (!noop_adecl(ins)) {
                        internal_error(state, ins, "adecl remains?");
                }
                break;
                /* Ignore OP_PIECE */
        case OP_PIECE:
                break;
                /* Operations that should never get here */
        case OP_SDIV: case OP_UDIV:
        case OP_SMOD: case OP_UMOD:
        case OP_LTRUE:   case OP_LFALSE:  case OP_EQ:      case OP_NOTEQ:
        case OP_SLESS:   case OP_ULESS:   case OP_SMORE:   case OP_UMORE:
        case OP_SLESSEQ: case OP_ULESSEQ: case OP_SMOREEQ: case OP_UMOREEQ:
        default:
                internal_error(state, ins, "unknown op: %d %s",
                        ins->op, tops(ins->op));
                break;
        }
}

static void print_instructions(struct compile_state *state)
{
        struct triple *first, *ins;
        int print_location;
        struct occurance *last_occurance;
        FILE *fp;
        int max_inline_depth;
        max_inline_depth = 0;
        print_location = 1;
        last_occurance = 0;
        fp = state->output;
        /* Masks for common sizes */
        fprintf(fp, ".section \"" DATA_SECTION "\"\n");
        fprintf(fp, ".balign 16\n");
        fprintf(fp, "L%s1:\n", state->compiler->label_prefix);
        fprintf(fp, ".int 0xff, 0, 0, 0\n");
        fprintf(fp, "L%s2:\n", state->compiler->label_prefix);
        fprintf(fp, ".int 0xffff, 0, 0, 0\n");
        fprintf(fp, ".section \"" TEXT_SECTION "\"\n");
        first = state->first;
        ins = first;
        do {
                if (print_location && 
                        last_occurance != ins->occurance) {
                        if (!ins->occurance->parent) {
                                fprintf(fp, "\t/* %s,%s:%d.%d */\n",
                                        ins->occurance->function,
                                        ins->occurance->filename,
                                        ins->occurance->line,
                                        ins->occurance->col);
                        }
                        else {
                                struct occurance *ptr;
                                int inline_depth;
                                fprintf(fp, "\t/*\n");
                                inline_depth = 0;
                                for(ptr = ins->occurance; ptr; ptr = ptr->parent) {
                                        inline_depth++;
                                        fprintf(fp, "\t * %s,%s:%d.%d\n",
                                                ptr->function,
                                                ptr->filename,
                                                ptr->line,
                                                ptr->col);
                                }
                                fprintf(fp, "\t */\n");
                                if (inline_depth > max_inline_depth) {
                                        max_inline_depth = inline_depth;
                                }
                        }
                        if (last_occurance) {
                                put_occurance(last_occurance);
                        }
                        get_occurance(ins->occurance);
                        last_occurance = ins->occurance;
                }

                print_instruction(state, ins, fp);
                ins = ins->next;
        } while(ins != first);
        if (print_location) {
                fprintf(fp, "/* max inline depth %d */\n",
                        max_inline_depth);
        }
}

static void generate_code(struct compile_state *state)
{
        generate_local_labels(state);
        print_instructions(state);
        
}

static void print_preprocessed_tokens(struct compile_state *state)
{
        int tok;
        FILE *fp;
        int line;
        const char *filename;
        fp = state->output;
        filename = 0;
        line = 0;
        for(;;) {
                struct file_state *file;
                struct token *tk;
                const char *token_str;
                tok = peek(state);
                if (tok == TOK_EOF) {
                        break;
                }
                tk = eat(state, tok);
                token_str = 
                        tk->ident ? tk->ident->name :
                        tk->str_len ? tk->val.str :
                        tokens[tk->tok];

                file = state->file;
                while(file->macro && file->prev) {
                        file = file->prev;
                }
                if (!file->macro && 
                        ((file->line != line) || (file->basename != filename))) 
                {
                        int i, col;
                        if ((file->basename == filename) &&
                                (line < file->line)) {
                                while(line < file->line) {
                                        fprintf(fp, "\n");
                                        line++;
                                }
                        }
                        else {
                                fprintf(fp, "\n#line %d \"%s\"\n",
                                        file->line, file->basename);
                        }
                        line = file->line;
                        filename = file->basename;
                        col = get_col(file) - strlen(token_str);
                        for(i = 0; i < col; i++) {
                                fprintf(fp, " ");
                        }
                }
                
                fprintf(fp, "%s ", token_str);
                
                if (state->compiler->debug & DEBUG_TOKENS) {
                        loc(state->dbgout, state, 0);
                        fprintf(state->dbgout, "%s <- `%s'\n",
                                tokens[tok], token_str);
                }
        }
}

static void compile(const char *filename, 
        struct compiler_state *compiler, struct arch_state *arch)
{
        int i;
        struct compile_state state;
        struct triple *ptr;
        memset(&state, 0, sizeof(state));
        state.compiler = compiler;
        state.arch     = arch;
        state.file = 0;
        for(i = 0; i < sizeof(state.token)/sizeof(state.token[0]); i++) {
                memset(&state.token[i], 0, sizeof(state.token[i]));
                state.token[i].tok = -1;
        }
        /* Remember the output descriptors */
        state.errout = stderr;
        state.dbgout = stdout;
        /* Remember the output filename */
        state.output    = fopen(state.compiler->ofilename, "w");
        if (!state.output) {
                error(&state, 0, "Cannot open output file %s\n",
                        state.compiler->ofilename);
        }
        /* Make certain a good cleanup happens */
        exit_state = &state;
        atexit(exit_cleanup);

        /* Prep the preprocessor */
        state.if_depth = 0;
        memset(state.if_bytes, 0, sizeof(state.if_bytes));
        /* register the C keywords */
        register_keywords(&state);
        /* register the keywords the macro preprocessor knows */
        register_macro_keywords(&state);
        /* generate some builtin macros */
        register_builtin_macros(&state);
        /* Memorize where some special keywords are. */
        state.i_switch        = lookup(&state, "switch", 6);
        state.i_case          = lookup(&state, "case", 4);
        state.i_continue      = lookup(&state, "continue", 8);
        state.i_break         = lookup(&state, "break", 5);
        state.i_default       = lookup(&state, "default", 7);
        state.i_return        = lookup(&state, "return", 6);
        /* Memorize where predefined macros are. */
        state.i___VA_ARGS__   = lookup(&state, "__VA_ARGS__", 11);
        state.i___FILE__      = lookup(&state, "__FILE__", 8);
        state.i___LINE__      = lookup(&state, "__LINE__", 8);
        /* Memorize where predefined identifiers are. */
        state.i___func__      = lookup(&state, "__func__", 8);
        /* Memorize where some attribute keywords are. */
        state.i_noinline      = lookup(&state, "noinline", 8);
        state.i_always_inline = lookup(&state, "always_inline", 13);

        /* Process the command line macros */
        process_cmdline_macros(&state);

        /* Allocate beginning bounding labels for the function list */
        state.first = label(&state);
        state.first->id |= TRIPLE_FLAG_VOLATILE;
        use_triple(state.first, state.first);
        ptr = label(&state);
        ptr->id |= TRIPLE_FLAG_VOLATILE;
        use_triple(ptr, ptr);
        flatten(&state, state.first, ptr);

        /* Allocate a label for the pool of global variables */
        state.global_pool = label(&state);
        state.global_pool->id |= TRIPLE_FLAG_VOLATILE;
        flatten(&state, state.first, state.global_pool);

        /* Enter the globl definition scope */
        start_scope(&state);
        register_builtins(&state);
        compile_file(&state, filename, 1);

        /* Stop if all we want is preprocessor output */
        if (state.compiler->flags & COMPILER_PP_ONLY) {
                print_preprocessed_tokens(&state);
                return;
        }

        decls(&state);

        /* Exit the global definition scope */
        end_scope(&state);

        /* Now that basic compilation has happened 
         * optimize the intermediate code 
         */
        optimize(&state);

        generate_code(&state);
        if (state.compiler->debug) {
                fprintf(state.errout, "done\n");
        }
        exit_state = 0;
}

static void version(FILE *fp)
{
        fprintf(fp, "romcc " VERSION " released " RELEASE_DATE "\n");
}

static void usage(void)
{
        FILE *fp = stdout;
        version(fp);
        fprintf(fp,
                "\nUsage: romcc [options] <source>.c\n"
                "Compile a C source file generating a binary that does not implicilty use RAM\n"
                "Options: \n"
                "-o <output file name>\n"
                "-f<option>            Specify a generic compiler option\n"
                "-m<option>            Specify a arch dependent option\n"
                "--                    Specify this is the last option\n"
                "\nGeneric compiler options:\n"
        );
        compiler_usage(fp);
        fprintf(fp,
                "\nArchitecture compiler options:\n"
        );
        arch_usage(fp);
        fprintf(fp,
                "\n"
        );
}

static void arg_error(char *fmt, ...)
{
        va_list args;
        va_start(args, fmt);
        vfprintf(stderr, fmt, args);
        va_end(args);
        usage();
        exit(1);
}

int main(int argc, char **argv)
{
        const char *filename;
        struct compiler_state compiler;
        struct arch_state arch;
        int all_opts;
        
        
        /* I don't want any surprises */
        setlocale(LC_ALL, "C");

        init_compiler_state(&compiler);
        init_arch_state(&arch);
        filename = 0;
        all_opts = 0;
        while(argc > 1) {
                if (!all_opts && (strcmp(argv[1], "-o") == 0) && (argc > 2)) {
                        compiler.ofilename = argv[2];
                        argv += 2;
                        argc -= 2;
                }
                else if (!all_opts && argv[1][0] == '-') {
                        int result;
                        result = -1;
                        if (strcmp(argv[1], "--") == 0) {
                                result = 0;
                                all_opts = 1;
                        }
                        else if (strncmp(argv[1], "-E", 2) == 0) {
                                result = compiler_encode_flag(&compiler, argv[1]);
                        }
                        else if (strncmp(argv[1], "-O", 2) == 0) {
                                result = compiler_encode_flag(&compiler, argv[1]);
                        }
                        else if (strncmp(argv[1], "-I", 2) == 0) {
                                result = compiler_encode_flag(&compiler, argv[1]);
                        }
                        else if (strncmp(argv[1], "-D", 2) == 0) {
                                result = compiler_encode_flag(&compiler, argv[1]);
                        }
                        else if (strncmp(argv[1], "-U", 2) == 0) {
                                result = compiler_encode_flag(&compiler, argv[1]);
                        }
                        else if (strncmp(argv[1], "--label-prefix=", 15) == 0) {
                                result = compiler_encode_flag(&compiler, argv[1]+2);
                        }
                        else if (strncmp(argv[1], "-f", 2) == 0) {
                                result = compiler_encode_flag(&compiler, argv[1]+2);
                        }
                        else if (strncmp(argv[1], "-m", 2) == 0) {
                                result = arch_encode_flag(&arch, argv[1]+2);
                        }
                        if (result < 0) {
                                arg_error("Invalid option specified: %s\n",
                                        argv[1]);
                        }
                        argv++;
                        argc--;
                }
                else {
                        if (filename) {
                                arg_error("Only one filename may be specified\n");
                        }
                        filename = argv[1];
                        argv++;
                        argc--;
                }
        }
        if (!filename) {
                arg_error("No filename specified\n");
        }
        compile(filename, &compiler, &arch);

        return 0;
}