gas/frags.c

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