gas/frags.c

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