Return to reloc.h CVS log

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

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

1.1     ! root        1: /*
        !             2:  * Relocatable object (from translator)
        !             3:  *     header
        !             4:  *     summary segment; contains sizes of loadable segments
        !             5:  *     loadable segments (possibly fragmented)
        !             6:  *     relocation fragment follows each relocatable fragment
        !             7:  *     symbol segment (seek address is seg_off[SYMBOLS] in summary)
        !             8:  *             (see below)
        !             9:  */
        !            10: 
        !            11: #ifndef        RELOC_H
        !            12: #define        RELOC_H RELOC_H
        !            13: 
        !            14: #include <types.h>
        !            15: typedef unsigned long uaddr_t;
        !            16: #define canuaddr(x)    canlong(x)
        !            17: 
        !            18: /*
        !            19:  * Object header
        !            20:  */
        !            21: #define        REL_OBJ "(Reloc)"
        !            22: 
        !            23: typedef        struct  objhdr_t        {       /* object module header */
        !            24:        char            obj_type[8],    /* REL_OBJ, BND_OBJ etc. */
        !            25:                        obj_hware[8],   /* target hardware */
        !            26:                        obj_sware[8],   /* program that produced object */
        !            27:                        obj_vers[8];    /* version of above */
        !            28: } objhdr_t;
        !            29: 
        !            30: /*
        !            31:  * Segment types
        !            32:  */
        !            33: 
        !            34: /* vertically encoded */
        !            35: #define        Xb      0x01    /* execute */
        !            36: #define        Wb      0x02    /* write */
        !            37: #define        Sb      0x04    /* shared */
        !            38: #define        Bb      0x08    /* block */
        !            39: #define        Cb      0x10    /* common */
        !            40: #define        Db      Bb      /* expand downwards (output only) */
        !            41: #define        Lb      Cb      /* loadable (output only) */
        !            42: 
        !            43: /* ordinary segments */
        !            44: #define        PURCODE (Xb)
        !            45: #define        PURDATA (0)
        !            46: #define        SHRCODE (Sb|Wb|Xb)      /* shared => writeable */
        !            47: #define        SHRDATA (Sb|Wb)
        !            48: #define        OWNCODE (Wb|Xb)
        !            49: #define        OWNDATA (Wb)
        !            50: #define        PLCODE  (Bb|Sb|Wb|Xb)   /* pooled => shared block */
        !            51: #define        PLDATA  (Bb|Sb|Wb)
        !            52: #define        BLCODE  (Bb|Wb|Xb)
        !            53: #define        BLDATA  (Bb|Wb)
        !            54: 
        !            55: /* meanings of otherwise meaningless bit combinations */
        !            56: /* these take clever advantage of the order of the bits */
        !            57: #define        STRINGS (Sb)
        !            58: #define        DEBUG   (Sb|Xb)
        !            59: #define        SYMBOLS (Bb)
        !            60: #define        TYPESYM (Bb|Xb)
        !            61: #define        ABSLUTE (Bb|Sb)
        !            62: #define        RELOCN  (Bb|Sb|Xb)
        !            63: #define        SUMMARY (Cb)
        !            64: #define        LASTSEG (0xFF)
        !            65: 
        !            66: typedef        struct  summseg_t       {       /* summary segment */
        !            67:        unsigned char   seg_type;       /* SUMMARY */
        !            68:        fsize_t         seg_size;       /* sizeof (seg_off) */
        !            69:        fsize_t         seg_off[SUMMARY];
        !            70: } summseg_t;
        !            71: 
        !            72: typedef        struct  segment_t       {       /* general segment fragment */
        !            73:        unsigned char   seg_type;
        !            74:        fsize_t         seg_size;
        !            75:        unsigned char   seg_data[];
        !            76: } segment_t;
        !            77: 
        !            78: /*
        !            79:  * A relocation fragment contains relocation items.
        !            80:  * Relocation type specifies the byte layout of the relocated word.
        !            81:  * The name defined for each layout is intended to suggest the number
        !            82:  * of bytes in the word, and their significance in increasing order
        !            83:  * when read in address order.
        !            84:  */
        !            85: #define        B_0     0
        !            86: #define        B_01    ((0<<2)|1)
        !            87: #define        B_10    ((1<<2)|0)
        !            88: #define        B_012   ((0<<4)|(1<<2)|2)
        !            89: #define        B_210   ((2<<4)|(1<<2)|0)
        !            90: #define        B_0123  ((0<<6)|(1<<4)|(2<<2)|3)
        !            91: #define        B_3210  ((3<<6)|(2<<4)|(1<<2)|0)
        !            92: #define        B_2301  ((2<<6)|(3<<4)|(0<<2)|1)
        !            93: #define        B_1032  ((1<<6)|(0<<4)|(3<<2)|2)
        !            94: 
        !            95: /* relocation flags (in rel_seg) */
        !            96: #define        PCREL   0x40
        !            97: #define        RELFLAGS (SIGNEDt|PCREL)
        !            98: 
        !            99: typedef        struct  reloctn_t       {       /* relocation item */
        !           100:        unsigned char   rel_type,       /* byte layout of relocated word */
        !           101:                        rel_seg;        /* segment referenced by relocator */
        !           102:        uaddr_t         rel_addr;       /* address of relocation */
        !           103: /*     uaddr_t         rel_num;           symbol num if rel_seg is SYMBOLS */
        !           104:                                        /* bias if rel_seg is ABSLUTE */
        !           105: } reloctn_t;
        !           106: 
        !           107: /*
        !           108:  * Symbol segment contains a symbol count, followed by that many symbols,
        !           109:  * numbered from 0, not necessarily in order.
        !           110:  */
        !           111: 
        !           112: typedef        union   symbol_t        {       /* object symbol */
        !           113:        struct  {                       /* relocatable */
        !           114:        unsigned char   sym_scope;      /* module, segment, load or ref */
        !           115:        uaddr_t         sym_num;        /* symbol number */
        !           116:        char            sym_name[];     /* NUL terminated */
        !           117:        unsigned char   sym_expr[];     /* absent if reference */
        !           118:        char            sym_type[];     /* always present */
        !           119:        };
        !           120:        struct  {                       /* bound or debug symbol */
        !           121:        unsigned char   sym_seg;        /* seg type */
        !           122:        uaddr_t         sym_addr;       /* value */
        !           123:        char            sym_name[];     /* NUL terminated */
        !           124:        char            sym_type[];     /* always present */
        !           125:        };
        !           126: } symbol_t;
        !           127: 
        !           128: typedef        struct  symseg_t        {       /* symbol segment */
        !           129:        unsigned char   seg_type;
        !           130:        fsize_t         seg_size;
        !           131:        uaddr_t         seg_nsym;
        !           132:        symbol_t        seg_sym[];
        !           133: } symseg_t;
        !           134: 
        !           135: /* Symbol scope */
        !           136: #define        RFSCOPE 0       /* reference (undefined) */
        !           137: #define        LDSCOPE 1       /* whole load */
        !           138: #define        SGSCOPE 2       /* single segment */
        !           139: #define        MDSCOPE 3       /* single module */
        !           140: 
        !           141: /*
        !           142:  * Symbol names are arbitrary length NUL ('\0') terminated character strings.
        !           143:  */
        !           144: /*
        !           145:  * Symbol expression is a prefix polish representation of a binary tree
        !           146:  * i.e. (opr) (left expr) (right expr).
        !           147:  * No expression exists for undefined symbols (scope == RFSCOPE).
        !           148:  */
        !           149: 
        !           150: typedef        struct  symleaf_t       {       /* expression tree leaf */
        !           151:        unsigned char   seg_type;
        !           152:        uaddr_t         sym_addr;       /* relocatable address */
        !           153: } symleaf_t;
        !           154: /* If seg_type is SYMBOLS sym_addr is symbol number */
        !           155: 
        !           156: /* Operators */
        !           157: #define        X_OP    0x80                    /* distinguish opr from seg */
        !           158: #define        X_ADD   (X_OP+1)
        !           159: #define        X_SUB   (X_OP+2)
        !           160: #define        X_MUL   (X_OP+3)
        !           161: #define        X_DIV   (X_OP+4)
        !           162: #define        X_MOD   (X_OP+5)
        !           163: #define        X_SHL   (X_OP+6)
        !           164: #define        X_SRL   (X_OP+7)                /* shift right logical */
        !           165: #define        X_SRA   (X_OP+8)                /* shift right arithmetic */
        !           166: #define        X_MSK   (X_OP+9)                /* a msk b  <=>  a&~b */
        !           167: #define        X_AND   (X_OP+10)
        !           168: #define        X_XOR   (X_OP+11)
        !           169: #define        X_IOR   (X_OP+12)
        !           170: 
        !           171: typedef        unsigned char   symopr_t;
        !           172: 
        !           173: /*
        !           174:  * Symbol type is tree represented as a NUL terminated string of leaves
        !           175:  * where a leaf is a character string, an n-byte signed or unsigned number,
        !           176:  * a type string, a type symbol, or special leaf ANYt.
        !           177:  * A character string is introduced by STRINGt, and is NUL terminated.
        !           178:  * A number consists of a byte count (or'd with SIGNEDt if signed),
        !           179:  * followed by that many bytes of data in order of increasing significance,
        !           180:  * with the sign (if any) at the top bit of the last byte.
        !           181:  * A type string is introduced by TYPEt, and is recursively defined as above.
        !           182:  * A type symbol is SYMBOLt followed by a symbol number (canonical uaddr_t)
        !           183:  * referring to the symbol segment in which the type was found.
        !           184:  */
        !           185: #define        ANYt    (-2)
        !           186: #define        STRINGt (-3)
        !           187: #define        TYPEt   (-4)
        !           188: #define        SYMBOLt (-5)
        !           189: #define        SIGNEDt (-1<<7)
        !           190: 
        !           191: #endif

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