Return to reloc.h CVS log

Up to [Apple XNU] / GNUtools / cctools / include / mach-o / hppa

Annotation of GNUtools/cctools/include/mach-o/hppa/reloc.h, revision 1.1

1.1     ! root        1: /*    reloc.h   -  assemble for HP-PA    */
        !             2: /*    Defines machine specific relocation entries */
        !             3: 
        !             4: #ifndef HPPA_RELOC_INCLUDED
        !             5: #define HPPA_RELOC_INCLUDED
        !             6: 
        !             7: /*
        !             8:  * Relocation types used in the hppa implementation.  Relocation entries for
        !             9:  * things other than instructions use the same generic relocation as discribed
        !            10:  * in <mach-o/reloc.h> and their r_type is HPPA_RELOC_VANILLA.  The rest of the
        !            11:  * relocation types are for instructions.  Since they are for instructions the
        !            12:  * r_address field indicates the 32 bit instruction that the relocation is to
        !            13:  * be preformed on.  The field r_pcrel is set only for the HPPA_RELOC_BR17.
        !            14:  * And r_length is set to long for all non-RELOC_VANILLA r_types.
        !            15:  */
        !            16: enum reloc_type_hppa
        !            17: {
        !            18:     HPPA_RELOC_VANILLA,        /* generic relocation as discribed in <mach-o/reloc.h>*/
        !            19:     HPPA_RELOC_PAIR,   /* the second relocation entry of a pair */
        !            20:     HPPA_RELOC_HI21,   /* a PAIR follows with the low part */
        !            21:     HPPA_RELOC_LO14,   /* a PAIR follows with the high part */
        !            22:     HPPA_RELOC_BR17,   /* 17 bit branch displacement (to a word address)
        !            23:                           a PAIR follows with the high part */
        !            24:     HPPA_RELOC_BL17,   /* a bl instruction (overlow causes an error) */
        !            25:     HPPA_RELOC_JBSR,   /* a bl instruction that is targeted at a long branch
        !            26:                           stub, a PAIR follows with the high part */
        !            27:     HPPA_RELOC_SECTDIFF,       /* a PAIR follows with subtract symbol value */
        !            28:     HPPA_RELOC_HI21_SECTDIFF,  /* a PAIR follows with subtract symbol value */
        !            29:     HPPA_RELOC_LO14_SECTDIFF   /* a PAIR follows with subtract symbol value */
        !            30: };
        !            31: 
        !            32: /*
        !            33:  * For the HI and LO relocation types the two parts of the relocated expression
        !            34:  * (symbol + offset) are calculated as follows:
        !            35:  *
        !            36:  *     rounded = round(offset, 0x2000);
        !            37:  *     left21 =   (symbol + rounded) & 0xfffff800;
        !            38:  *     right14 = ((symbol + rounded) & 0x000007ff) + (offset - rounded);
        !            39:  *
        !            40:  * This allows the left part to be shared between references with different
        !            41:  * offsets as long as the rounded offsets are the same.
        !            42:  *
        !            43:  * The HPPA_RELOC_BR17 r_type also uses the above calculation and the right14
        !            44:  * bits, sign extened to fill the displacement, and converted to a word
        !            45:  * displacement by droping the low bits (after checking they are zero).
        !            46:  */
        !            47: 
        !            48: /*
        !            49:  * For relocation types that use pairs the part of the relocated expression that
        !            50:  * is not stored in the instruction is stored in the r_address feild of the
        !            51:  * PAIR's entry.
        !            52:  *
        !            53:  * All low parts are stored as sign extened byte addressed values in the PAIR's
        !            54:  * r_address field as 32 bit values.  This allows the HI21 not to have to know
        !            55:  * which type of low it is used with.
        !            56:  *
        !            57:  * The high parts are left justified 21 bit values zero filled to 32 bits and 
        !            58:  * stored in the PAIR's r_address field.
        !            59:  */
        !            60: 
        !            61: /*
        !            62:  * The instructions that use the non-RELOC_VANILLA r_types are and the r_types
        !            63:  * they use are as follows:
        !            64:  *     instructions    r_type
        !            65:  *
        !            66:  *     LDIL,ADDIL      HPPA_RELOC_HI21
        !            67:  *     LDx, STx, LDO   HPPA_RELOC_LO14
        !            68:  *     BE, BLE         HPPA_RELOC_BR17
        !            69:  *     BL              HPPA_RELOC_BL17
        !            70:  *
        !            71:  * For the HPPA_RELOC_JBSR the BL instruction must be targeted at a long branch
        !            72:  * stub that can be reached with 17 bits of signed word displacement.  Also the
        !            73:  * stub must be in the same block as the BL instruction so that scattered
        !            74:  * loading done by the link editor will not move them apart.  For example in
        !            75:  * assembly code:
        !            76:  *     jbsr    foo,%r2,L1      ; creates a bl inst with a HPPA_RELOC_JBSR
        !            77:  *                             ;  relocation entry for the symbol foo and the
        !            78:  *                             ;  instruction is targeted to L1
        !            79:  *     ...
        !            80:  * L1: ldil    L'foo,%r1       ; a HPPA_RELOC_HI21 entry for symbol foo
        !            81:  *     ble,n   R'foo(%sr4,%r1) ; a HPPA_RELOC_BR17 entry for symbol foo
        !            82:  */
        !            83: 
        !            84: #endif    /* HPPA_RELOC_INCLUDED */

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