gas/frags.h

   1 /* frags.h - Header file for the frag concept.
   2    Copyright (C) 1987, 92, 93, 94, 95, 97, 98, 1999
   3    Free Software Foundation, Inc.
   4
   5    This file is part of GAS, the GNU Assembler.
   6
   7    GAS is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2, or (at your option)
  10    any later version.
  11
  12    GAS is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with GAS; see the file COPYING.  If not, write to the Free
  19    Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  20    02111-1307, USA.  */
  21
  22 #ifndef FRAGS_H
  23 #define FRAGS_H
  24
  25 #ifdef ANSI_PROTOTYPES
  26 struct obstack;
  27 #endif
  28
  29 /*
  30  * A code fragment (frag) is some known number of chars, followed by some
  31  * unknown number of chars. Typically the unknown number of chars is an
  32  * instruction address whose size is yet unknown. We always know the greatest
  33  * possible size the unknown number of chars may become, and reserve that
  34  * much room at the end of the frag.
  35  * Once created, frags do not change address during assembly.
  36  * We chain the frags in (a) forward-linked list(s). The object-file address
  37  * of the 1st char of a frag is generally not known until after relax().
  38  * Many things at assembly time describe an address by {object-file-address
  39  * of a particular frag}+offset.
  40
  41  BUG: it may be smarter to have a single pointer off to various different
  42  notes for different frag kinds. See how code pans
  43  */
  44
  45 struct frag
  46 {
  47   /* Object file address (as an octet offset). */
  48   addressT fr_address;
  49   /* Chain forward; ascending address order.  Rooted in frch_root. */
  50   struct frag *fr_next;
  51
  52   /* (Fixed) number of octets we know we have.  May be 0. */
  53   offsetT fr_fix;
  54   /* (Variable) number of octets after above.  May be 0. */
  55   offsetT fr_var;
  56   /* For variable-length tail. */
  57   symbolS *fr_symbol;
  58   /* For variable-length tail. */
  59   offsetT fr_offset;
  60   /* Points to opcode low addr byte, for relaxation.  */
  61   char *fr_opcode;
  62
  63 #ifndef NO_LISTING
  64   struct list_info_struct *line;
  65 #endif
  66
  67   /* What state is my tail in? */
  68   relax_stateT fr_type;
  69   relax_substateT fr_subtype;
  70
  71 #ifdef USING_CGEN
  72   /* Don't include this unless using CGEN to keep frag size down.  */
  73   struct {
  74     /* CGEN_INSN entry for this instruction.  */
  75     const struct cgen_insn *insn;
  76     /* Index into operand table.  */
  77     int opindex;
  78     /* Target specific data, usually reloc number.  */
  79     int opinfo;
  80   } fr_cgen;
  81 #endif
  82
  83 #ifdef TC_FRAG_TYPE
  84   TC_FRAG_TYPE tc_frag_data;
  85 #endif
  86
  87   /* Where the frag was created, or where it became a variant frag.  */
  88   char *fr_file;
  89   unsigned int fr_line;
  90
  91   /* Data begins here.  */
  92   char fr_literal[1];
  93 };
  94
  95 #define SIZEOF_STRUCT_FRAG \
  96 ((char *)zero_address_frag.fr_literal-(char *)&zero_address_frag)
  97 /* We want to say fr_literal[0] above. */
  98
  99 /* Current frag we are building.  This frag is incomplete.  It is,
 100    however, included in frchain_now.  The fr_fix field is bogus;
 101    instead, use frag_now_fix ().  */
 102 COMMON fragS *frag_now;
 103 extern addressT frag_now_fix PARAMS ((void));
 104 extern addressT frag_now_fix_octets PARAMS ((void));
 105
 106 /* For foreign-segment symbol fixups. */
 107 COMMON fragS zero_address_frag;
 108 /* For local common (N_BSS segment) fixups. */
 109 COMMON fragS bss_address_frag;
 110
 111 #if 0
 112 /*
 113  * A macro to speed up appending exactly 1 char
 114  * to current frag.
 115  */
 116 /* JF changed < 1 to <= 1 to avoid a race conditon */
 117 #define FRAG_APPEND_1_CHAR(datum)       \
 118 {                                       \
 119   if (obstack_room( &frags ) <= 1) {\
 120     frag_wane (frag_now);       \
 121     frag_new (0);               \
 122   }                             \
 123   obstack_1grow( &frags, datum );       \
 124 }
 125 #else
 126 extern void frag_append_1_char PARAMS ((int));
 127 #define FRAG_APPEND_1_CHAR(X) frag_append_1_char (X)
 128 #endif
 129
 130
 131 void frag_init PARAMS ((void));
 132 fragS *frag_alloc PARAMS ((struct obstack *));
 133 void frag_grow PARAMS ((unsigned int nchars));
 134 char *frag_more PARAMS ((int nchars));
 135 void frag_align PARAMS ((int alignment, int fill_character, int max));
 136 void frag_align_pattern PARAMS ((int alignment,
 137                                  const char *fill_pattern,
 138                                  int n_fill,
 139                                  int max));
 140 void frag_new PARAMS ((int old_frags_var_max_size));
 141 void frag_wane PARAMS ((fragS * fragP));
 142
 143 char *frag_variant PARAMS ((relax_stateT type,
 144                             int max_chars,
 145                             int var,
 146                             relax_substateT subtype,
 147                             symbolS * symbol,
 148                             offsetT offset,
 149                             char *opcode));
 150
 151 char *frag_var PARAMS ((relax_stateT type,
 152                         int max_chars,
 153                         int var,
 154                         relax_substateT subtype,
 155                         symbolS * symbol,
 156                         offsetT offset,
 157                         char *opcode));
 158
 159 #endif /* FRAGS_H */