gas/frags.c

   1 /* frags.c - manage frags -
   2    Copyright (C) 1987, 90, 91, 92, 93, 94, 95, 96, 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 #include "as.h"
  23 #include "subsegs.h"
  24 #include "obstack.h"
  25
  26 extern fragS zero_address_frag;
  27 extern fragS bss_address_frag;
  28 \f
  29 /* Initialization for frag routines.  */
  30 void
  31 frag_init ()
  32 {
  33   zero_address_frag.fr_type = rs_fill;
  34   bss_address_frag.fr_type = rs_fill;
  35 }
  36 \f
  37 /* Allocate a frag on the specified obstack.
  38    Call this routine from everywhere else, so that all the weird alignment
  39    hackery can be done in just one place.  */
  40 fragS *
  41 frag_alloc (ob)
  42      struct obstack *ob;
  43 {
  44   fragS *ptr;
  45   int oalign;
  46
  47   (void) obstack_alloc (ob, 0);
  48   oalign = obstack_alignment_mask (ob);
  49   obstack_alignment_mask (ob) = 0;
  50   ptr = (fragS *) obstack_alloc (ob, SIZEOF_STRUCT_FRAG);
  51   obstack_alignment_mask (ob) = oalign;
  52   memset (ptr, 0, SIZEOF_STRUCT_FRAG);
  53   return ptr;
  54 }
  55 \f
  56 /*
  57  *                      frag_grow()
  58  *
  59  * Try to augment current frag by nchars chars.
  60  * If there is no room, close of the current frag with a ".fill 0"
  61  * and begin a new frag. Unless the new frag has nchars chars available
  62  * do not return. Do not set up any fields of *now_frag.
  63  */
  64 void
  65 frag_grow (nchars)
  66      unsigned int nchars;
  67 {
  68   if (obstack_room (&frchain_now->frch_obstack) < nchars)
  69     {
  70       unsigned int n;
  71       long oldc;
  72
  73       frag_wane (frag_now);
  74       frag_new (0);
  75       oldc = frchain_now->frch_obstack.chunk_size;
  76       frchain_now->frch_obstack.chunk_size = 2 * nchars + SIZEOF_STRUCT_FRAG;
  77       while ((n = obstack_room (&frchain_now->frch_obstack)) < nchars)
  78         {
  79           frag_wane (frag_now);
  80           frag_new (0);
  81         }
  82       frchain_now->frch_obstack.chunk_size = oldc;
  83     }
  84   if (obstack_room (&frchain_now->frch_obstack) < nchars)
  85     as_fatal (_("Can't extend frag %d. chars"), nchars);
  86 }
  87 \f
  88 /*
  89  *                      frag_new()
  90  *
  91  * Call this to close off a completed frag, and start up a new (empty)
  92  * frag, in the same subsegment as the old frag.
  93  * [frchain_now remains the same but frag_now is updated.]
  94  * Because this calculates the correct value of fr_fix by
  95  * looking at the obstack 'frags', it needs to know how many
  96  * characters at the end of the old frag belong to (the maximal)
  97  * fr_var: the rest must belong to fr_fix.
  98  * It doesn't actually set up the old frag's fr_var: you may have
  99  * set fr_var == 1, but allocated 10 chars to the end of the frag:
 100  * in this case you pass old_frags_var_max_size == 10.
 101  *
 102  * Make a new frag, initialising some components. Link new frag at end
 103  * of frchain_now.
 104  */
 105 void
 106 frag_new (old_frags_var_max_size)
 107      /* Number of chars (already allocated on obstack frags) in
 108         variable_length part of frag. */
 109      int old_frags_var_max_size;
 110 {
 111   fragS *former_last_fragP;
 112   frchainS *frchP;
 113
 114   assert (frchain_now->frch_last == frag_now);
 115
 116   /* Fix up old frag's fr_fix.  */
 117   frag_now->fr_fix = frag_now_fix_octets () - old_frags_var_max_size;
 118   /* Make sure its type is valid.  */
 119   assert (frag_now->fr_type != 0);
 120
 121   /* This will align the obstack so the next struct we allocate on it
 122      will begin at a correct boundary. */
 123   obstack_finish (&frchain_now->frch_obstack);
 124   frchP = frchain_now;
 125   know (frchP);
 126   former_last_fragP = frchP->frch_last;
 127   assert (former_last_fragP != 0);
 128   assert (former_last_fragP == frag_now);
 129   frag_now = frag_alloc (&frchP->frch_obstack);
 130
 131   as_where (&frag_now->fr_file, &frag_now->fr_line);
 132
 133   /* Generally, frag_now->points to an address rounded up to next
 134      alignment.  However, characters will add to obstack frags
 135      IMMEDIATELY after the struct frag, even if they are not starting
 136      at an alignment address. */
 137   former_last_fragP->fr_next = frag_now;
 138   frchP->frch_last = frag_now;
 139
 140 #ifndef NO_LISTING
 141   {
 142     extern struct list_info_struct *listing_tail;
 143     frag_now->line = listing_tail;
 144   }
 145 #endif
 146
 147   assert (frchain_now->frch_last == frag_now);
 148
 149   frag_now->fr_next = NULL;
 150 }                               /* frag_new() */
 151 \f
 152 /*
 153  *                      frag_more()
 154  *
 155  * Start a new frag unless we have n more chars of room in the current frag.
 156  * Close off the old frag with a .fill 0.
 157  *
 158  * Return the address of the 1st char to write into. Advance
 159  * frag_now_growth past the new chars.
 160  */
 161
 162 char *
 163 frag_more (nchars)
 164      int nchars;
 165 {
 166   register char *retval;
 167
 168   if (now_seg == absolute_section)
 169     {
 170       as_bad (_("attempt to allocate data in absolute section"));
 171       subseg_set (text_section, 0);
 172     }
 173
 174   if (mri_common_symbol != NULL)
 175     {
 176       as_bad (_("attempt to allocate data in common section"));
 177       mri_common_symbol = NULL;
 178     }
 179
 180   frag_grow (nchars);
 181   retval = obstack_next_free (&frchain_now->frch_obstack);
 182   obstack_blank_fast (&frchain_now->frch_obstack, nchars);
 183   return (retval);
 184 }                               /* frag_more() */
 185 \f
 186 /*
 187  *                      frag_var()
 188  *
 189  * Start a new frag unless we have max_chars more chars of room in the current frag.
 190  * Close off the old frag with a .fill 0.
 191  *
 192  * Set up a machine_dependent relaxable frag, then start a new frag.
 193  * Return the address of the 1st char of the var part of the old frag
 194  * to write into.
 195  */
 196
 197 char *
 198 frag_var (type, max_chars, var, subtype, symbol, offset, opcode)
 199      relax_stateT type;
 200      int max_chars;
 201      int var;
 202      relax_substateT subtype;
 203      symbolS *symbol;
 204      offsetT offset;
 205      char *opcode;
 206 {
 207   register char *retval;
 208
 209   frag_grow (max_chars);
 210   retval = obstack_next_free (&frchain_now->frch_obstack);
 211   obstack_blank_fast (&frchain_now->frch_obstack, max_chars);
 212   frag_now->fr_var = var;
 213   frag_now->fr_type = type;
 214   frag_now->fr_subtype = subtype;
 215   frag_now->fr_symbol = symbol;
 216   frag_now->fr_offset = offset;
 217   frag_now->fr_opcode = opcode;
 218 #ifdef USING_CGEN
 219   frag_now->fr_cgen.insn = 0;
 220   frag_now->fr_cgen.opindex = 0;
 221   frag_now->fr_cgen.opinfo = 0;
 222 #endif
 223 #ifdef TC_FRAG_INIT
 224   TC_FRAG_INIT (frag_now);
 225 #endif
 226   as_where (&frag_now->fr_file, &frag_now->fr_line);
 227   frag_new (max_chars);
 228   return (retval);
 229 }
 230 \f
 231 /*
 232  *                      frag_variant()
 233  *
 234  * OVE: This variant of frag_var assumes that space for the tail has been
 235  *      allocated by caller.
 236  *      No call to frag_grow is done.
 237  */
 238
 239 char *
 240 frag_variant (type, max_chars, var, subtype, symbol, offset, opcode)
 241      relax_stateT type;
 242      int max_chars;
 243      int var;
 244      relax_substateT subtype;
 245      symbolS *symbol;
 246      offsetT offset;
 247      char *opcode;
 248 {
 249   register char *retval;
 250
 251   retval = obstack_next_free (&frchain_now->frch_obstack);
 252   frag_now->fr_var = var;
 253   frag_now->fr_type = type;
 254   frag_now->fr_subtype = subtype;
 255   frag_now->fr_symbol = symbol;
 256   frag_now->fr_offset = offset;
 257   frag_now->fr_opcode = opcode;
 258 #ifdef USING_CGEN
 259   frag_now->fr_cgen.insn = 0;
 260   frag_now->fr_cgen.opindex = 0;
 261   frag_now->fr_cgen.opinfo = 0;
 262 #endif
 263 #ifdef TC_FRAG_INIT
 264   TC_FRAG_INIT (frag_now);
 265 #endif
 266   as_where (&frag_now->fr_file, &frag_now->fr_line);
 267   frag_new (max_chars);
 268   return (retval);
 269 }                               /* frag_variant() */
 270 \f
 271 /*
 272  *                      frag_wane()
 273  *
 274  * Reduce the variable end of a frag to a harmless state.
 275  */
 276 void
 277 frag_wane (fragP)
 278      register fragS *fragP;
 279 {
 280   fragP->fr_type = rs_fill;
 281   fragP->fr_offset = 0;
 282   fragP->fr_var = 0;
 283 }
 284 \f
 285 /* Make an alignment frag.  The size of this frag will be adjusted to
 286    force the next frag to have the appropriate alignment.  ALIGNMENT
 287    is the power of two to which to align.  FILL_CHARACTER is the
 288    character to use to fill in any bytes which are skipped.  MAX is
 289    the maximum number of characters to skip when doing the alignment,
 290    or 0 if there is no maximum.  */
 291
 292 void
 293 frag_align (alignment, fill_character, max)
 294      int alignment;
 295      int fill_character;
 296      int max;
 297 {
 298   if (now_seg == absolute_section)
 299     {
 300       addressT new_off;
 301
 302       new_off = ((abs_section_offset + alignment - 1)
 303                  &~ ((1 << alignment) - 1));
 304       if (max == 0 || new_off - abs_section_offset <= (addressT) max)
 305         abs_section_offset = new_off;
 306     }
 307   else
 308     {
 309       char *p;
 310
 311       p = frag_var (rs_align, 1, 1, (relax_substateT) max,
 312                     (symbolS *) 0, (offsetT) alignment, (char *) 0);
 313       *p = fill_character;
 314     }
 315 }
 316
 317 /* Make an alignment frag like frag_align, but fill with a repeating
 318    pattern rather than a single byte.  ALIGNMENT is the power of two
 319    to which to align.  FILL_PATTERN is the fill pattern to repeat in
 320    the bytes which are skipped.  N_FILL is the number of bytes in
 321    FILL_PATTERN.  MAX is the maximum number of characters to skip when
 322    doing the alignment, or 0 if there is no maximum.  */
 323
 324 void
 325 frag_align_pattern (alignment, fill_pattern, n_fill, max)
 326      int alignment;
 327      const char *fill_pattern;
 328      int n_fill;
 329      int max;
 330 {
 331   char *p;
 332
 333   p = frag_var (rs_align, n_fill, n_fill, (relax_substateT) max,
 334                 (symbolS *) 0, (offsetT) alignment, (char *) 0);
 335   memcpy (p, fill_pattern, n_fill);
 336 }
 337
 338 addressT
 339 frag_now_fix_octets ()
 340 {
 341   if (now_seg == absolute_section)
 342     return abs_section_offset;
 343
 344   return ((char*) obstack_next_free (&frchain_now->frch_obstack)
 345           - frag_now->fr_literal);
 346 }
 347
 348 addressT
 349 frag_now_fix ()
 350 {
 351   return frag_now_fix_octets() / OCTETS_PER_BYTE;
 352 }
 353
 354 void
 355 frag_append_1_char (datum)
 356      int datum;
 357 {
 358   if (obstack_room (&frchain_now->frch_obstack) <= 1)
 359     {
 360       frag_wane (frag_now);
 361       frag_new (0);
 362     }
 363   obstack_1grow (&frchain_now->frch_obstack, datum);
 364 }
 365
 366 /* end of frags.c */