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