Return to assizetab.c CVS log

Up to [CSRG BSD Unix] / 43BSDTahoe / lib / old_compiler / as / as.tahoe

Annotation of 43BSDTahoe/lib/old_compiler/as/as.tahoe/assizetab.c, revision 1.1

1.1     ! root        1: /*
        !             2:  *     Copyright (c) 1982 Regents of the University of California
        !             3:  */
        !             4: #ifndef lint
        !             5: static char sccsid[] = "@(#)assizetab.c 4.4 11/11/82";
        !             6: #endif not lint
        !             7: 
        !             8: #ifdef AS
        !             9: #include <stdio.h>
        !            10: #include "as.h"
        !            11: #include "assyms.h"
        !            12: 
        !            13: /*
        !            14:  *     Convert loader reference types (plus PCREL) to bytes and lg bytes
        !            15:  */
        !            16: int    reflen[] = {    /* {LEN*+PCREL} ==> number of bytes */
        !            17:        0,      0,
        !            18:        1,      1,      /* LEN1,        LEN1 + PCREL */
        !            19:        2,      2,      /* LEN2,        LEN2 + PCREL */
        !            20:        4,      4,      /* LEN4,        LEN2 + PCREL */
        !            21:        8,      8       /* LEN8,        LEN2 + PCREL */
        !            22: };     
        !            23: int    lgreflen[] = {  /* {LEN*+PCREL} ==> number of bytes */
        !            24:        -1,     -1,
        !            25:        0,      0,      /* LEN1,        LEN1 + PCREL */
        !            26:        1,      1,      /* LEN2,        LEN2 + PCREL */
        !            27:        2,      2,      /* LEN4,        LEN2 + PCREL */
        !            28:        3,      3       /* LEN8,        LEN2 + PCREL */
        !            29: };     
        !            30: 
        !            31: /*
        !            32:  *     Convert sizes to loader reference types and type flags
        !            33:  */
        !            34: /*0    1       2       3       4       5       6       7       8*/
        !            35: /*
        !            36:  *     Convert {1,2,4,8} into {LEN1, LEN2, LEN4, LEN8}
        !            37:  */
        !            38: int    len124[] = {
        !            39:        0,      LEN1,   /* 0 */
        !            40:        LEN2,   0,      /* 2 */
        !            41:        LEN4,   0,      /* 4 */
        !            42:        0,      0,      /* 6 */
        !            43:        LEN8,   0       /* 8 */
        !            44: };
        !            45: /*
        !            46:  *     Convert {1,2,4,8} into {bits to construct operands}
        !            47:  */
        !            48: char   mod124[] = {
        !            49:        0,      0x00,   /* 0 */
        !            50:        0x20,   0,      /* 2 */
        !            51:        0x40,   0,      /* 4 */
        !            52:        0,      0,      /* 6 */
        !            53:        0,      0       /* 8 */
        !            54: };
        !            55: /*
        !            56:  *     {1,2,4,8} into {TYPB, TYPW, TYPL, TYPQ}
        !            57:  */
        !            58: int    type_124[] = {
        !            59:        0,      TYPB,   /* 0 */
        !            60:        TYPW,   0,      /* 2 */
        !            61:        TYPL,   0,      /* 4 */
        !            62:        0,      0,      /* 6 */
        !            63:        TYPQ,   0       /* 8 */
        !            64: };
        !            65: #endif AS
        !            66: /*
        !            67:  *     Convert TYP[BWLQOFDGH] into {1 if relocation not OK}
        !            68:  */
        !            69: int    ty_NORELOC[] = {
        !            70:        0,      /* TYPB */
        !            71:        0,      /* TYPW */
        !            72:        0,      /* TYPL */
        !            73:        1,      /* TYPQ */
        !            74:        1,      /* TYPF */
        !            75:        1,      /* TYPD */
        !            76:        1       /* TYPNONE */
        !            77: };
        !            78: #ifndef ADB
        !            79: /*
        !            80:  *     Convert TYP[BWLQOFDGH] into {1 if a floating point number}
        !            81:  */
        !            82: int    ty_float[] = {
        !            83:        0,      /* TYPB */
        !            84:        0,      /* TYPW */
        !            85:        0,      /* TYPL */
        !            86:        0,      /* TYPQ */
        !            87:        1,      /* TYPF */
        !            88:        1,      /* TYPD */
        !            89:        0       /* TYPNONE */
        !            90: };
        !            91: #endif
        !            92: #ifdef AS
        !            93: /*
        !            94:  *     Convert TYP[BWLQOFDGH] into {LEN1 ... LEN16}
        !            95:  */
        !            96: int    ty_LEN[] = {
        !            97:        LEN1,   /* TYPB */
        !            98:        LEN2,   /* TYPW */
        !            99:        LEN4,   /* TYPL */
        !           100:        LEN8,   /* TYPQ */
        !           101:        LEN4,   /* TYPF */
        !           102:        LEN8,   /* TYPD */
        !           103:        0       /* TYPNONE */
        !           104: };
        !           105: #endif AS
        !           106: /*
        !           107:  *     Convert TYP[BWLQFD] into {1 ... 8}
        !           108:  */
        !           109: int    ty_nbyte[] = {
        !           110:        1,      /* TYPB */
        !           111:        2,      /* TYPW */
        !           112:        4,      /* TYPL */
        !           113:        8,      /* TYPQ */
        !           114:        4,      /* TYPF */
        !           115:        8,      /* TYPD */
        !           116:        0       /* TYPNONE */
        !           117: };
        !           118: #ifndef ADB
        !           119: /*
        !           120:  *     Convert TYP[BWLQFD] into lg{1 ... 8}
        !           121:  */
        !           122: int    ty_nlg[] = {
        !           123:        0,      /* TYPB */
        !           124:        1,      /* TYPW */
        !           125:        2,      /* TYPL */
        !           126:        3,      /* TYPQ */
        !           127:        2,      /* TYPF */
        !           128:        3,      /* TYPD */
        !           129:        -1      /* TYPNONE */
        !           130: };
        !           131: /*
        !           132:  *     Convert TYP[BWLQFD] into strings
        !           133:  */
        !           134: char   *ty_string[] = {
        !           135:        "byte",         /* TYPB */
        !           136:        "word",         /* TYPW */
        !           137:        "long",         /* TYPL */
        !           138:        "quad",         /* TYPQ */
        !           139:        "f_float",      /* TYPF */
        !           140:        "d_float",      /* TYPD */
        !           141:        "??snark??"     /* TYPNONE */
        !           142: };
        !           143: #endif

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