Return to cc1mch.h CVS log

Up to [MW Coherent from dump] / coherent / b / bin / c / h / i386

Annotation of coherent/b/bin/c/h/i386/cc1mch.h, revision 1.1

1.1     ! root        1: /*
        !             2:  * h/i386/cc1mch.h
        !             3:  * Machine specific macros, types and definitions
        !             4:  * used by the C compiler code generator (cc1).
        !             5:  * i386.
        !             6:  */
        !             7: 
        !             8: /* Type definitions. */
        !             9: typedef        char    COST;           /* Cost of evaluation                   */
        !            10: typedef        char    TYPE;           /* Machine type                         */
        !            11: typedef        long    FLAG;           /* Flags                                */
        !            12: typedef        char    REGNAME;        /* Register name                        */
        !            13: typedef        int     TYPESET;        /* Set of TYPE                          */
        !            14: typedef        char    PHYSREG;        /* Physical register name               */
        !            15: typedef        unsigned long PATFLAG;  /* Pattern flags, at least 16 bits      */
        !            16: typedef        int     KIND;           /* Register kind                        */
        !            17: typedef        long    MASK;           /* Field masks                          */
        !            18: typedef        char    INDEX;          /* Index type                           */
        !            19: 
        !            20: /* Manifest constants. */
        !            21: #define        DOWN    1               /* Grow stack downwards                 */
        !            22: #define        BITS    0               /* n'th bit code is not needed          */
        !            23: #define LONGREL        0               /* Long relational code is not needed   */
        !            24: #define        SWREG   EAX             /* Switch register                      */
        !            25: #define        FNUSED  (BEAX|BECX|BEDX)        /* Preserve EBX, EDI, ESI       */
        !            26: #define NOFREE (BESP|BEBP)     /* Always occupied registers            */
        !            27: #define        MBLARG  MFNARG          /* Block argument context               */
        !            28: #define        MBLREG  ANYR            /* Block argument register              */
        !            29: #define        ICALLS  1               /* Free level on call                   */
        !            30: #define        DVALIS  0               /* Index into dval for DVAL sign        */
        !            31: #define        DVALMS  0200            /* Bit to flip for DVAL sign            */
        !            32: #define        NBPCH   8               /* # of bits in char (out.c)            */
        !            33: #define        NSWITCH 4               /* # of cases in switch coded as conditionals */
        !            34: 
        !            35: /* Macros. */
        !            36: #define        isblkp(t)       ((t)==PTB)
        !            37: #if    DECVAX
        !            38: #define poolseg(op)    ((op!=DCON) ? SLINK : SDATA)
        !            39: #else
        !            40: #define poolseg(op)    SLINK
        !            41: #endif
        !            42: 
        !            43: #if    !TINY
        !            44: /*
        !            45:  * Debug printout macros.
        !            46:  * Explained in snap1.c
        !            47:  */
        !            48: #define isnap(x)       printf(" %d", (x))
        !            49: #define lsnap(x)       printf(" %ld", (x))
        !            50: #define csnap(x)       ((x)!=0?printf(" cost=%d", (x)):0)
        !            51: #define fsnap(x)       ((x)!=0?printf(" flag=%lx", (x)):0)
        !            52: #define mdlsnap(x)     snaptype((x), "Bad leaf")
        !            53: #define mdosnap(x)     snaptype((x), "Bad op")
        !            54: #endif
        !            55: 
        !            56: /*
        !            57:  * Tree flags.
        !            58:  * The 'FLAG' type must be big enough to hold all of these bits.
        !            59:  * After the machine specific flags are the machine independent ones,
        !            60:  * and then a number of handy combinations of the flags,
        !            61:  * which are used all over.
        !            62:  */
        !            63: #define        T_0     0x00000001L     /* 0                            */
        !            64: #define        T_1     0x00000002L     /* 1                            */
        !            65: #define        T_SHCNT 0x00000004L     /* [0 ... 31] (shift count)     */
        !            66: #define        T_SBYTE 0x00000008L     /* [-128 ... 127]               */
        !            67: #define        T_UBYTE 0x00000010L     /* [0 ... 255]                  */
        !            68: #define        T_SWORD 0x00000020L     /* [-32768 ... 32768]           */
        !            69: #define        T_UWORD 0x00000040L     /* [0 ... 65535]                */
        !            70: #define        T_NUM   0x00000080L     /* ICON or LCON                 */
        !            71: #define        T_DCN   0x00000100L     /* DCON                         */
        !            72: #define        T_ADDR  0x00000200L     /* ADDR                         */
        !            73: #define        T_REG   0x00000400L     /* REG                          */
        !            74: #define        T_LEA   0x00000800L     /* Looks like a LEA             */
        !            75: #define        T_DIR   0x00001000L     /* Direct                       */
        !            76: #define        T_OFS   0x00002000L     /* Offset                       */
        !            77: 
        !            78: /* The following are used to determine SIB addressibility.     */
        !            79: #define        T_123   0x00004000L     /* [1 2 3]                      */
        !            80: #define        T_234589 0x00008000L    /* [2 3 4 5 8 9]                */
        !            81: #define        T_SIBM  0x000F0000L     /* SIB-addressible mask         */
        !            82: #define        T_ADISP 0x00010000L     /* SIB absolute displacement    */
        !            83: #define        T_RDISP 0x00020000L     /* SIB relocatable displacement */
        !            84: #define        T_BREG  0x00040000L     /* SIB with base register       */
        !            85: #define        T_IREG  0x00080000L     /* SIB with (scaled) index reg  */
        !            86: 
        !            87: #define        T_TREG  0x80000000L     /* Need a temporary register    */
        !            88: #define        T_LV    0x40000000L     /* Lvalue context               */
        !            89: #define        T_MMX   0x20000000L     /* Must match shape exactly     */
        !            90: #define        T_INDIR 0x10000000L     /* Fake indirect flag           */
        !            91: 
        !            92: #define        T_CON   (T_NUM|T_ADDR)
        !            93: #define        T_IMM   (T_CON|T_DCN)
        !            94: #define        T_ADR   (T_DIR|T_REG)
        !            95: #define T_NLEAF        (T_DIR|T_REG|T_IMM)
        !            96: #define        T_EASY  (T_DIR|T_REG|T_IMM|T_OFS)
        !            97: #define        T_LEAF  (T_DIR|T_REG|T_IMM|T_OFS|T_LEA)
        !            98: 
        !            99: /*
        !           100:  * These type testing macros use a
        !           101:  * table that is hidden in file "table1.c".
        !           102:  * Although you might think they should be in the "PERTYPE"
        !           103:  * table (and you are right), they are not so that the
        !           104:  * code that is generated does not have a multiply in it.
        !           105:  */
        !           106: #define islong(t)      ((tinfo[t]&01)  != 0)
        !           107: #define isword(t)      ((tinfo[t]&02)  != 0)
        !           108: #define        isworl(t)       ((tinfo[t]&03)  != 0)
        !           109: #define isuns(t)       ((tinfo[t]&04)  != 0)
        !           110: #define        isflt(t)        ((tinfo[t]&010) != 0)
        !           111: #define isint(t)       ((tinfo[t]&020) != 0)
        !           112: #define isbyte(t)      ((tinfo[t]&040) != 0)
        !           113: #define isworb(t)       ((tinfo[t]&042) != 0)
        !           114: #define        issized(t)      ((tinfo[t]&0100)!= 0)
        !           115: #define        ispoint(t)      ((tinfo[t]&0200)!= 0)
        !           116: 
        !           117: /*
        !           118:  * Machine-dependent pattern flags.
        !           119:  * These must not overlap with the pattern flags in cc1.h.
        !           120:  */
        !           121: #define        PNDP            0x10000L        /* 80x87 hardware fp            */
        !           122: #define        PIEEE           0x20000L        /* IEEE software fp             */
        !           123: #define        PDECVAX         0x40000L        /* DECVAX software fp           */
        !           124: #define        PBYTE           0x80000L        /* Requires EAX EBX ECX EDX     */
        !           125: #define        MDPFLAGS        0xF0000L        /* Machine-dependent pattern flags */
        !           126: 
        !           127: /*
        !           128:  * Register kinds.
        !           129:  * Used by the register allocator.
        !           130:  */
        !           131: #define        KB      0x01            /* Byte                 */
        !           132: #define        KW      0x02            /* Word                 */
        !           133: #define        KL      0x04            /* Long (dword)         */
        !           134: #define        KD      0x08            /* Double               */
        !           135: #define        KP      KL              /* Pointer              */
        !           136: 
        !           137: #define        KWL     (KW|KL)         /* Word or dword        */
        !           138: #define        KBWL    (KB|KW|KL)      /* Byte, word or dword  */
        !           139: 
        !           140: /*
        !           141:  * Macros for machine dependent stuff.
        !           142:  * out.c, pool.c.
        !           143:  */
        !           144: #define GIDFMT (A_GID|A_DIR)           /* Afield ival for GID output   */
        !           145: #define LIDFMT (A_LID|A_DIR)           /* Afield ival for LID output   */
        !           146: #define CONFMT (A_OFFS|A_IMM)          /* Afield ival for constant output */
        !           147: #define mapssize(i)    (((i)+3)&~3)    /* Stack roundup                */
        !           148: #define mapcode(c, tp) (c)             /* Escape to map mch opcodes    */
        !           149: #define gentos(x,y)                    /* No top of stack required     */
        !           150: #define genstar(x,y,z,zz)              /* No star address required     */
        !           151: #define iptrtype()     PTR
        !           152: 
        !           153: /*
        !           154:  * Externals.
        !           155:  */
        !           156: #if    !YATC
        !           157: extern int     blkflab;                /* n1/i386/mtree2.c     */
        !           158: extern PREGSET regbusy;                /* n1/i386/gen1.c       */
        !           159: extern char    tinfo[];                /* n1/i386/table1.c     */
        !           160: #endif
        !           161: 
        !           162: /* end of h/i386/cc1mch.h */
        !           163: 

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.