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