gas/frags.c

   1 /* frags.c - manage frags -
   2    Copyright 1987, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
   3    1999, 2000
   4    Free Software Foundation, Inc.
   5
   6    This file is part of GAS, the GNU Assembler.
   7
   8    GAS is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2, or (at your option)
  11    any later version.
  12
  13    GAS is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with GAS; see the file COPYING.  If not, write to the Free
  20    Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  21    02111-1307, USA.  */
  22
  23 #include "as.h"
  24 #include "subsegs.h"
  25 #include "obstack.h"
  26
  27 extern fragS zero_address_frag;
  28 extern fragS bss_address_frag;
  29 \f
  30 /* Initialization for frag routines.  */
  31
  32 void
  33 frag_init ()
  34 {
  35   zero_address_frag.fr_type = rs_fill;
  36   bss_address_frag.fr_type = rs_fill;
  37 }
  38 \f
  39 /* Allocate a frag on the specified obstack.
  40    Call this routine from everywhere else, so that all the weird alignment
  41    hackery can be done in just one place.  */
  42
  43 fragS *
  44 frag_alloc (ob)
  45      struct obstack *ob;
  46 {
  47   fragS *ptr;
  48   int oalign;
  49
  50   (void) obstack_alloc (ob, 0);
  51   oalign = obstack_alignment_mask (ob);
  52   obstack_alignment_mask (ob) = 0;
  53   ptr = (fragS *) obstack_alloc (ob, SIZEOF_STRUCT_FRAG);
  54   obstack_alignment_mask (ob) = oalign;
  55   memset (ptr, 0, SIZEOF_STRUCT_FRAG);
  56   return ptr;
  57 }
  58 \f
  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 %u chars"), nchars);
  88 }
  89 \f
  90 /* Call this to close off a completed frag, and start up a new (empty)
  91    frag, in the same subsegment as the old frag.
  92    [frchain_now remains the same but frag_now is updated.]
  93    Because this calculates the correct value of fr_fix by
  94    looking at the obstack 'frags', it needs to know how many
  95    characters at the end of the old frag belong to the maximal
  96    variable part;  The rest must belong to fr_fix.
  97    It doesn't actually set up the old frag's fr_var.  You may have
  98    set fr_var == 1, but allocated 10 chars to the end of the frag;
  99    In this case you pass old_frags_var_max_size == 10.
 100    In fact, you may use fr_var for something totally unrelated to the
 101    size of the variable part of the frag;  None of the generic frag
 102    handling code makes use of fr_var.
 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 }
 153 \f
 154 /* Start a new frag unless we have n more chars of room in the current frag.
 155    Close off the old frag with a .fill 0.
 156
 157    Return the address of the 1st char to write into. Advance
 158    frag_now_growth past the new chars.  */
 159
 160 char *
 161 frag_more (nchars)
 162      int nchars;
 163 {
 164   register char *retval;
 165
 166   if (now_seg == absolute_section)
 167     {
 168       as_bad (_("attempt to allocate data in absolute section"));
 169       subseg_set (text_section, 0);
 170     }
 171
 172   if (mri_common_symbol != NULL)
 173     {
 174       as_bad (_("attempt to allocate data in common section"));
 175       mri_common_symbol = NULL;
 176     }
 177
 178   frag_grow (nchars);
 179   retval = obstack_next_free (&frchain_now->frch_obstack);
 180   obstack_blank_fast (&frchain_now->frch_obstack, nchars);
 181   return (retval);
 182 }
 183 \f
 184 /* Start a new frag unless we have max_chars more chars of room in the
 185    current frag.  Close off the old frag with a .fill 0.
 186
 187    Set up a machine_dependent relaxable frag, then start a new frag.
 188    Return the address of the 1st char of the var part of the old frag
 189    to write into.  */
 190
 191 char *
 192 frag_var (type, max_chars, var, subtype, symbol, offset, opcode)
 193      relax_stateT type;
 194      int max_chars;
 195      int var;
 196      relax_substateT subtype;
 197      symbolS *symbol;
 198      offsetT offset;
 199      char *opcode;
 200 {
 201   register char *retval;
 202
 203   frag_grow (max_chars);
 204   retval = obstack_next_free (&frchain_now->frch_obstack);
 205   obstack_blank_fast (&frchain_now->frch_obstack, max_chars);
 206   frag_now->fr_var = var;
 207   frag_now->fr_type = type;
 208   frag_now->fr_subtype = subtype;
 209   frag_now->fr_symbol = symbol;
 210   frag_now->fr_offset = offset;
 211   frag_now->fr_opcode = opcode;
 212 #ifdef USING_CGEN
 213   frag_now->fr_cgen.insn = 0;
 214   frag_now->fr_cgen.opindex = 0;
 215   frag_now->fr_cgen.opinfo = 0;
 216 #endif
 217 #ifdef TC_FRAG_INIT
 218   TC_FRAG_INIT (frag_now);
 219 #endif
 220   as_where (&frag_now->fr_file, &frag_now->fr_line);
 221   frag_new (max_chars);
 222   return (retval);
 223 }
 224 \f
 225 /* OVE: This variant of frag_var assumes that space for the tail has been
 226         allocated by caller.
 227         No call to frag_grow is done.  */
 228
 229 char *
 230 frag_variant (type, max_chars, var, subtype, symbol, offset, opcode)
 231      relax_stateT type;
 232      int max_chars;
 233      int var;
 234      relax_substateT subtype;
 235      symbolS *symbol;
 236      offsetT offset;
 237      char *opcode;
 238 {
 239   register char *retval;
 240
 241   retval = obstack_next_free (&frchain_now->frch_obstack);
 242   frag_now->fr_var = var;
 243   frag_now->fr_type = type;
 244   frag_now->fr_subtype = subtype;
 245   frag_now->fr_symbol = symbol;
 246   frag_now->fr_offset = offset;
 247   frag_now->fr_opcode = opcode;
 248 #ifdef USING_CGEN
 249   frag_now->fr_cgen.insn = 0;
 250   frag_now->fr_cgen.opindex = 0;
 251   frag_now->fr_cgen.opinfo = 0;
 252 #endif
 253 #ifdef TC_FRAG_INIT
 254   TC_FRAG_INIT (frag_now);
 255 #endif
 256   as_where (&frag_now->fr_file, &frag_now->fr_line);
 257   frag_new (max_chars);
 258   return (retval);
 259 }
 260 \f
 261 /* Reduce the variable end of a frag to a harmless state.  */
 262
 263 void
 264 frag_wane (fragP)
 265      register fragS *fragP;
 266 {
 267   fragP->fr_type = rs_fill;
 268   fragP->fr_offset = 0;
 269   fragP->fr_var = 0;
 270 }
 271 \f
 272 /* Make an alignment frag.  The size of this frag will be adjusted to
 273    force the next frag to have the appropriate alignment.  ALIGNMENT
 274    is the power of two to which to align.  FILL_CHARACTER is the
 275    character to use to fill in any bytes which are skipped.  MAX is
 276    the maximum number of characters to skip when doing the alignment,
 277    or 0 if there is no maximum.  */
 278
 279 void
 280 frag_align (alignment, fill_character, max)
 281      int alignment;
 282      int fill_character;
 283      int max;
 284 {
 285   if (now_seg == absolute_section)
 286     {
 287       addressT new_off;
 288       addressT mask;
 289
 290       mask = (~(addressT) 0) << alignment;
 291       new_off = (abs_section_offset + ~mask) & mask;
 292       if (max == 0 || new_off - abs_section_offset <= (addressT) max)
 293         abs_section_offset = new_off;
 294     }
 295   else
 296     {
 297       char *p;
 298
 299       p = frag_var (rs_align, 1, 1, (relax_substateT) max,
 300                     (symbolS *) 0, (offsetT) alignment, (char *) 0);
 301       *p = fill_character;
 302     }
 303 }
 304
 305 /* Make an alignment frag like frag_align, but fill with a repeating
 306    pattern rather than a single byte.  ALIGNMENT is the power of two
 307    to which to align.  FILL_PATTERN is the fill pattern to repeat in
 308    the bytes which are skipped.  N_FILL is the number of bytes in
 309    FILL_PATTERN.  MAX is the maximum number of characters to skip when
 310    doing the alignment, or 0 if there is no maximum.  */
 311
 312 void
 313 frag_align_pattern (alignment, fill_pattern, n_fill, max)
 314      int alignment;
 315      const char *fill_pattern;
 316      int n_fill;
 317      int max;
 318 {
 319   char *p;
 320
 321   p = frag_var (rs_align, n_fill, n_fill, (relax_substateT) max,
 322                 (symbolS *) 0, (offsetT) alignment, (char *) 0);
 323   memcpy (p, fill_pattern, n_fill);
 324 }
 325
 326 /* The NOP_OPCODE is for the alignment fill value.  Fill it with a nop
 327    instruction so that the disassembler does not choke on it.  */
 328 #ifndef NOP_OPCODE
 329 #define NOP_OPCODE 0x00
 330 #endif
 331
 332 /* Use this to restrict the amount of memory allocated for representing
 333    the alignment code.  Needs to be large enough to hold any fixed sized
 334    prologue plus the replicating portion.  */
 335 #ifndef MAX_MEM_FOR_RS_ALIGN_CODE
 336   /* Assume that if HANDLE_ALIGN is not defined then no special action
 337      is required to code fill, which means that we get just repeat the
 338      one NOP_OPCODE byte.  */
 339 # ifndef HANDLE_ALIGN
 340 #  define MAX_MEM_FOR_RS_ALIGN_CODE  1
 341 # else
 342 #  define MAX_MEM_FOR_RS_ALIGN_CODE  ((1 << alignment) - 1)
 343 # endif
 344 #endif
 345
 346 void
 347 frag_align_code (alignment, max)
 348      int alignment;
 349      int max;
 350 {
 351   char *p;
 352
 353   p = frag_var (rs_align_code, MAX_MEM_FOR_RS_ALIGN_CODE, 1,
 354                 (relax_substateT) max, (symbolS *) 0,
 355                 (offsetT) alignment, (char *) 0);
 356   *p = NOP_OPCODE;
 357 }
 358
 359 addressT
 360 frag_now_fix_octets ()
 361 {
 362   if (now_seg == absolute_section)
 363     return abs_section_offset;
 364
 365   return ((char *) obstack_next_free (&frchain_now->frch_obstack)
 366           - frag_now->fr_literal);
 367 }
 368
 369 addressT
 370 frag_now_fix ()
 371 {
 372   return frag_now_fix_octets () / OCTETS_PER_BYTE;
 373 }
 374
 375 void
 376 frag_append_1_char (datum)
 377      int datum;
 378 {
 379   if (obstack_room (&frchain_now->frch_obstack) <= 1)
 380     {
 381       frag_wane (frag_now);
 382       frag_new (0);
 383     }
 384   obstack_1grow (&frchain_now->frch_obstack, datum);
 385 }