gas/frags.h

   1 /* frags.h - Header file for the frag concept.
   2    Copyright 1987, 1992, 1993, 1994, 1995, 1997, 1998, 1999, 2000
   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 /* A code fragment (frag) is some known number of chars, followed by some
  30    unknown number of chars. Typically the unknown number of chars is an
  31    instruction address whose size is yet unknown. We always know the greatest
  32    possible size the unknown number of chars may become, and reserve that
  33    much room at the end of the frag.
  34    Once created, frags do not change address during assembly.
  35    We chain the frags in (a) forward-linked list(s). The object-file address
  36    of the 1st char of a frag is generally not known until after relax().
  37    Many things at assembly time describe an address by {object-file-address
  38    of a particular frag}+offset.
  39
  40    BUG: it may be smarter to have a single pointer off to various different
  41    notes for different frag kinds.  See how code pans.   */
  42
  43 struct frag {
  44   /* Object file address (as an octet offset).  */
  45   addressT fr_address;
  46   /* Chain forward; ascending address order.  Rooted in frch_root.  */
  47   struct frag *fr_next;
  48
  49   /* (Fixed) number of octets we know we have.  May be 0.  */
  50   offsetT fr_fix;
  51   /* May be used for (Variable) number of octets after above.
  52      The generic frag handling code no longer makes any use of fr_var.  */
  53   offsetT fr_var;
  54   /* For variable-length tail.  */
  55   symbolS *fr_symbol;
  56   /* For variable-length tail.  */
  57   offsetT fr_offset;
  58   /* Points to opcode low addr byte, for relaxation.  */
  59   char *fr_opcode;
  60
  61 #ifndef NO_LISTING
  62   struct list_info_struct *line;
  63 #endif
  64
  65   /* What state is my tail in? */
  66   relax_stateT fr_type;
  67   relax_substateT fr_subtype;
  68
  69 #ifdef USING_CGEN
  70   /* Don't include this unless using CGEN to keep frag size down.  */
  71   struct {
  72     /* CGEN_INSN entry for this instruction.  */
  73     const struct cgen_insn *insn;
  74     /* Index into operand table.  */
  75     int opindex;
  76     /* Target specific data, usually reloc number.  */
  77     int opinfo;
  78   } fr_cgen;
  79 #endif
  80
  81 #ifdef TC_FRAG_TYPE
  82   TC_FRAG_TYPE tc_frag_data;
  83 #endif
  84
  85   /* Where the frag was created, or where it became a variant frag.  */
  86   char *fr_file;
  87   unsigned int fr_line;
  88
  89   /* Data begins here.  */
  90   char fr_literal[1];
  91 };
  92
  93 #define SIZEOF_STRUCT_FRAG \
  94 ((char *) zero_address_frag.fr_literal - (char *) &zero_address_frag)
  95 /* We want to say fr_literal[0] above.  */
  96
  97 /* Current frag we are building.  This frag is incomplete.  It is,
  98    however, included in frchain_now.  The fr_fix field is bogus;
  99    instead, use frag_now_fix ().  */
 100 COMMON fragS *frag_now;
 101 extern addressT frag_now_fix PARAMS ((void));
 102 extern addressT frag_now_fix_octets PARAMS ((void));
 103
 104 /* For foreign-segment symbol fixups.  */
 105 COMMON fragS zero_address_frag;
 106 /* For local common (N_BSS segment) fixups.  */
 107 COMMON fragS bss_address_frag;
 108
 109 #if 0
 110 /* A macro to speed up appending exactly 1 char to current frag.  */
 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     {                                                   \
 116       frag_wane (frag_now);                             \
 117       frag_new (0);                                     \
 118     }                                                   \
 119   obstack_1grow (&frags, datum);                        \
 120 }
 121 #else
 122 extern void frag_append_1_char PARAMS ((int));
 123 #define FRAG_APPEND_1_CHAR(X) frag_append_1_char (X)
 124 #endif
 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_align_code PARAMS ((int alignment, int max));
 136 void frag_new PARAMS ((int old_frags_var_max_size));
 137 void frag_wane PARAMS ((fragS * fragP));
 138
 139 char *frag_variant PARAMS ((relax_stateT type,
 140                             int max_chars,
 141                             int var,
 142                             relax_substateT subtype,
 143                             symbolS * symbol,
 144                             offsetT offset,
 145                             char *opcode));
 146
 147 char *frag_var PARAMS ((relax_stateT type,
 148                         int max_chars,
 149                         int var,
 150                         relax_substateT subtype,
 151                         symbolS * symbol,
 152                         offsetT offset,
 153                         char *opcode));
 154
 155 #endif /* FRAGS_H */