contrib/binutils/gas/frags.h

   1 /* frags.h - Header file for the frag concept.
   2    Copyright (C) 1987, 92, 93, 94, 95, 97, 1998
   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. */
  48   addressT fr_address;
  49   /* Chain forward; ascending address order.  Rooted in frch_root. */
  50   struct frag *fr_next;
  51
  52   /* (Fixed) number of chars we know we have.  May be 0. */
  53   offsetT fr_fix;
  54   /* (Variable) number of chars after above.  May be 0. */
  55   offsetT fr_var;
  56   /* For variable-length tail. */
  57   struct symbol *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     const struct cgen_insn *insn;
  75     unsigned char opindex, opinfo;
  76   } fr_cgen;
  77 #endif
  78
  79 #ifdef TC_FRAG_TYPE
  80   TC_FRAG_TYPE tc_frag_data;
  81 #endif
  82
  83   /* Where the frag was created, or where it became a variant frag.  */
  84   char *fr_file;
  85   unsigned int fr_line;
  86
  87   /* Data begins here.  */
  88   char fr_literal[1];
  89 };
  90
  91 #define SIZEOF_STRUCT_FRAG \
  92 ((char *)zero_address_frag.fr_literal-(char *)&zero_address_frag)
  93 /* We want to say fr_literal[0] above. */
  94
  95 /* Current frag we are building.  This frag is incomplete.  It is,
  96    however, included in frchain_now.  The fr_fix field is bogus;
  97    instead, use frag_now_fix ().  */
  98 COMMON fragS *frag_now;
  99 extern addressT frag_now_fix PARAMS ((void));
 100
 101 /* For foreign-segment symbol fixups. */
 102 COMMON fragS zero_address_frag;
 103 /* For local common (N_BSS segment) fixups. */
 104 COMMON fragS bss_address_frag;
 105
 106 #if 0
 107 /*
 108  * A macro to speed up appending exactly 1 char
 109  * to current frag.
 110  */
 111 /* JF changed < 1 to <= 1 to avoid a race conditon */
 112 #define FRAG_APPEND_1_CHAR(datum)       \
 113 {                                       \
 114   if (obstack_room( &frags ) <= 1) {\
 115     frag_wane (frag_now);       \
 116     frag_new (0);               \
 117   }                             \
 118   obstack_1grow( &frags, datum );       \
 119 }
 120 #else
 121 extern void frag_append_1_char PARAMS ((int));
 122 #define FRAG_APPEND_1_CHAR(X) frag_append_1_char (X)
 123 #endif
 124
 125
 126 void frag_init PARAMS ((void));
 127 fragS *frag_alloc PARAMS ((struct obstack *));
 128 void frag_grow PARAMS ((unsigned int nchars));
 129 char *frag_more PARAMS ((int nchars));
 130 void frag_align PARAMS ((int alignment, int fill_character, int max));
 131 void frag_align_pattern PARAMS ((int alignment,
 132                                  const char *fill_pattern,
 133                                  int n_fill,
 134                                  int max));
 135 void frag_new PARAMS ((int old_frags_var_max_size));
 136 void frag_wane PARAMS ((fragS * fragP));
 137
 138 char *frag_variant PARAMS ((relax_stateT type,
 139                             int max_chars,
 140                             int var,
 141                             relax_substateT subtype,
 142                             symbolS * symbol,
 143                             offsetT offset,
 144                             char *opcode));
 145
 146 char *frag_var PARAMS ((relax_stateT type,
 147                         int max_chars,
 148                         int var,
 149                         relax_substateT subtype,
 150                         symbolS * symbol,
 151                         offsetT offset,
 152                         char *opcode));
 153
 154 #endif /* FRAGS_H */