Return to frags.h CVS log

Up to [Apple XNU] / GNUtools / cctools / as

Annotation of GNUtools/cctools/as/frags.h, revision 1.1

1.1     ! root        1: /* frags.h - Header file for the frag concept.
        !             2:    Copyright (C) 1987 Free Software Foundation, Inc.
        !             3: 
        !             4: This file is part of GAS, the GNU Assembler.
        !             5: 
        !             6: GAS is free software; you can redistribute it and/or modify
        !             7: it under the terms of the GNU General Public License as published by
        !             8: the Free Software Foundation; either version 1, or (at your option)
        !             9: any later version.
        !            10: 
        !            11: GAS is distributed in the hope that it will be useful,
        !            12: but WITHOUT ANY WARRANTY; without even the implied warranty of
        !            13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        !            14: GNU General Public License for more details.
        !            15: 
        !            16: You should have received a copy of the GNU General Public License
        !            17: along with GAS; see the file COPYING.  If not, write to
        !            18: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
        !            19: 
        !            20: #import "relax.h"
        !            21: #import "struc-symbol.h"
        !            22: 
        !            23: /*
        !            24:  * A code fragment (frag) is some known number of chars, followed by some
        !            25:  * unknown number of chars. Typically the unknown number of chars is an
        !            26:  * instruction address whose size is yet unknown. We always know the greatest
        !            27:  * possible size the unknown number of chars may become, and reserve that
        !            28:  * much room at the end of the frag.
        !            29:  * Once created, frags do not change address during assembly.
        !            30:  * We chain the frags in (a) forward-linked list(s). The object-file address
        !            31:  * of the 1st char of a frag is generally not known until after relax().
        !            32:  * Many things at assembly time describe an address by {object-file-address
        !            33:  * of a particular frag}+offset.
        !            34: 
        !            35:  BUG: it may be smarter to have a single pointer off to various different
        !            36: notes for different frag kinds. See how code pans out.
        !            37: 
        !            38:  */
        !            39: struct frag                    /* a code fragment */
        !            40: {
        !            41:     unsigned long fr_address;  /* Object file address. */
        !            42:     struct frag *fr_next;      /* Chain forward; ascending address order. */
        !            43:                                /* Rooted in frch_root. */
        !            44: 
        !            45:     long fr_fix;               /* (Fixed) number of chars we know we have. */
        !            46:                                /* May be 0. */
        !            47:     long fr_var;               /* (Variable) number of chars after above. */
        !            48:                                /* May be 0. */
        !            49:     struct symbol *fr_symbol;  /* For variable-length tail. */
        !            50:     long fr_offset;            /* For variable-length tail. */
        !            51:     char *fr_opcode;           /* ->opcode low addr byte,for relax()ation*/
        !            52:     relax_stateT fr_type;      /* What state is my tail in? */
        !            53:     relax_substateT fr_subtype;        /* Used to index in to md_relax_table for */
        !            54:                                /*  fr_type == rs_machine_dependent frags. */
        !            55:     char fr_literal[1];                /* Chars begin here. */
        !            56:                                /* One day we will compile fr_literal[0]. */
        !            57: };
        !            58: typedef struct frag fragS;
        !            59: 
        !            60: /* We want to say fr_literal[0] below */
        !            61: #define SIZEOF_STRUCT_FRAG \
        !            62:  ((int)zero_address_frag.fr_literal - (int)&zero_address_frag)
        !            63: 
        !            64: /*
        !            65:  * frag_now points at the current frag we are building. This frag is incomplete.
        !            66:  * It is, however, included in frchain_now. Frag_now->fr_fix is not the total
        !            67:  * bytes in use for the frag.  For that use:
        !            68:  * frag_now->fr_fix + obstack_next_free(&frags) - frag_now->fr_literal.
        !            69:  */
        !            70: extern fragS *frag_now;
        !            71: 
        !            72: /*
        !            73:  * Frags ONLY live in this obstack.  We use obstack_next_free() macro 
        !            74:  * so please don't put any other objects on this stack!
        !            75:  */
        !            76: extern struct obstack frags;
        !            77: 
        !            78: /* For foreign-segment symbol fixups. */
        !            79: extern fragS zero_address_frag;
        !            80: 
        !            81: extern void frag_new(
        !            82:     int old_frags_var_max_size);
        !            83: extern char * frag_more(
        !            84:     int nchars);
        !            85: extern char *frag_var(
        !            86:     relax_stateT type,
        !            87:     int max_chars,
        !            88:     int var,
        !            89:     relax_substateT subtype,
        !            90:     symbolS *symbol,
        !            91:     long offset,
        !            92:     char *opcode);
        !            93: extern void frag_wane(
        !            94:     fragS *fragP);
        !            95: extern void frag_align(
        !            96:     int alignment,
        !            97:     int fill_character);
        !            98: 
        !            99: /*
        !           100:  * A macro to speed up appending exactly 1 char
        !           101:  * to current frag.
        !           102:  */
        !           103: /* JF changed < 1 to <= 1 to avoid a race conditon */
        !           104: #define FRAG_APPEND_1_CHAR(datum)      \
        !           105: {                                      \
        !           106:        if (obstack_room( &frags ) <= 1) {\
        !           107:                frag_wane (frag_now);   \
        !           108:                frag_new (0);           \
        !           109:        }                               \
        !           110:        obstack_1grow( &frags, datum ); \
        !           111: }

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