contrib/binutils-2.24/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, 2004, 2005, 2006, 2007, 2008, 2009, 2011, 2012
   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 3, 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, 51 Franklin Street - Fifth Floor, Boston, MA
  21    02110-1301, USA.  */
  22
  23 #include "as.h"
  24 #include "subsegs.h"
  25 #include "obstack.h"
  26
  27 extern fragS zero_address_frag;
  28 extern fragS predefined_address_frag;
  29 \f
  30 /* Initialization for frag routines.  */
  31
  32 void
  33 frag_init (void)
  34 {
  35   zero_address_frag.fr_type = rs_fill;
  36   predefined_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 (struct obstack *ob)
  65 {
  66   fragS *ptr;
  67   int oalign;
  68
  69   (void) obstack_alloc (ob, 0);
  70   oalign = obstack_alignment_mask (ob);
  71   obstack_alignment_mask (ob) = 0;
  72   ptr = (fragS *) obstack_alloc (ob, SIZEOF_STRUCT_FRAG);
  73   obstack_alignment_mask (ob) = oalign;
  74   memset (ptr, 0, SIZEOF_STRUCT_FRAG);
  75   return ptr;
  76 }
  77 \f
  78 /* Try to augment current frag by nchars chars.
  79    If there is no room, close of the current frag with a ".fill 0"
  80    and begin a new frag. Unless the new frag has nchars chars available
  81    do not return. Do not set up any fields of *now_frag.  */
  82
  83 void
  84 frag_grow (unsigned int nchars)
  85 {
  86   if (obstack_room (&frchain_now->frch_obstack) < nchars)
  87     {
  88       long oldc;
  89       long newc;
  90
  91       /* Try to allocate a bit more than needed right now.  But don't do
  92          this if we would waste too much memory.  Especially necessary
  93          for extremely big (like 2GB initialized) frags.  */
  94       if (nchars < 0x10000)
  95         newc = 2 * nchars;
  96       else
  97         newc = nchars + 0x10000;
  98       newc += SIZEOF_STRUCT_FRAG;
  99
 100       /* Check for possible overflow.  */
 101       if (newc < 0)
 102         as_fatal (_("can't extend frag %u chars"), nchars);
 103
 104       /* Force to allocate at least NEWC bytes, but not less than the
 105          default.  */
 106       oldc = obstack_chunk_size (&frchain_now->frch_obstack);
 107       if (newc > oldc)
 108         obstack_chunk_size (&frchain_now->frch_obstack) = newc;
 109
 110       while (obstack_room (&frchain_now->frch_obstack) < nchars)
 111         {
 112           /* Not enough room in this frag.  Close it and start a new one.
 113              This must be done in a loop because the created frag may not
 114              be big enough if the current obstack chunk is used.  */
 115           frag_wane (frag_now);
 116           frag_new (0);
 117         }
 118
 119       /* Restore the old chunk size.  */
 120       obstack_chunk_size (&frchain_now->frch_obstack) = oldc;
 121     }
 122 }
 123 \f
 124 /* Call this to close off a completed frag, and start up a new (empty)
 125    frag, in the same subsegment as the old frag.
 126    [frchain_now remains the same but frag_now is updated.]
 127    Because this calculates the correct value of fr_fix by
 128    looking at the obstack 'frags', it needs to know how many
 129    characters at the end of the old frag belong to the maximal
 130    variable part;  The rest must belong to fr_fix.
 131    It doesn't actually set up the old frag's fr_var.  You may have
 132    set fr_var == 1, but allocated 10 chars to the end of the frag;
 133    In this case you pass old_frags_var_max_size == 10.
 134    In fact, you may use fr_var for something totally unrelated to the
 135    size of the variable part of the frag;  None of the generic frag
 136    handling code makes use of fr_var.
 137
 138    Make a new frag, initialising some components. Link new frag at end
 139    of frchain_now.  */
 140
 141 void
 142 frag_new (int old_frags_var_max_size
 143           /* Number of chars (already allocated on obstack frags) in
 144              variable_length part of frag.  */)
 145 {
 146   fragS *former_last_fragP;
 147   frchainS *frchP;
 148
 149   gas_assert (frchain_now->frch_last == frag_now);
 150
 151   /* Fix up old frag's fr_fix.  */
 152   frag_now->fr_fix = frag_now_fix_octets () - old_frags_var_max_size;
 153   /* Make sure its type is valid.  */
 154   gas_assert (frag_now->fr_type != 0);
 155
 156   /* This will align the obstack so the next struct we allocate on it
 157      will begin at a correct boundary.  */
 158   obstack_finish (&frchain_now->frch_obstack);
 159   frchP = frchain_now;
 160   know (frchP);
 161   former_last_fragP = frchP->frch_last;
 162   gas_assert (former_last_fragP != 0);
 163   gas_assert (former_last_fragP == frag_now);
 164   frag_now = frag_alloc (&frchP->frch_obstack);
 165
 166   as_where (&frag_now->fr_file, &frag_now->fr_line);
 167
 168   /* Generally, frag_now->points to an address rounded up to next
 169      alignment.  However, characters will add to obstack frags
 170      IMMEDIATELY after the struct frag, even if they are not starting
 171      at an alignment address.  */
 172   former_last_fragP->fr_next = frag_now;
 173   frchP->frch_last = frag_now;
 174
 175 #ifndef NO_LISTING
 176   {
 177     extern struct list_info_struct *listing_tail;
 178     frag_now->line = listing_tail;
 179   }
 180 #endif
 181
 182   gas_assert (frchain_now->frch_last == frag_now);
 183
 184   frag_now->fr_next = NULL;
 185 }
 186 \f
 187 /* Start a new frag unless we have n more chars of room in the current frag.
 188    Close off the old frag with a .fill 0.
 189
 190    Return the address of the 1st char to write into. Advance
 191    frag_now_growth past the new chars.  */
 192
 193 char *
 194 frag_more (int nchars)
 195 {
 196   register char *retval;
 197
 198   frag_alloc_check (&frchain_now->frch_obstack);
 199   frag_grow (nchars);
 200   retval = obstack_next_free (&frchain_now->frch_obstack);
 201   obstack_blank_fast (&frchain_now->frch_obstack, nchars);
 202   return (retval);
 203 }
 204 \f
 205 /* Close the current frag, setting its fields for a relaxable frag.  Start a
 206    new frag.  */
 207
 208 static void
 209 frag_var_init (relax_stateT type, int max_chars, int var,
 210                relax_substateT subtype, symbolS *symbol, offsetT offset,
 211                char *opcode)
 212 {
 213   frag_now->fr_var = var;
 214   frag_now->fr_type = type;
 215   frag_now->fr_subtype = subtype;
 216   frag_now->fr_symbol = symbol;
 217   frag_now->fr_offset = offset;
 218   frag_now->fr_opcode = opcode;
 219 #ifdef USING_CGEN
 220   frag_now->fr_cgen.insn = 0;
 221   frag_now->fr_cgen.opindex = 0;
 222   frag_now->fr_cgen.opinfo = 0;
 223 #endif
 224 #ifdef TC_FRAG_INIT
 225   TC_FRAG_INIT (frag_now);
 226 #endif
 227   as_where (&frag_now->fr_file, &frag_now->fr_line);
 228
 229   frag_new (max_chars);
 230 }
 231
 232 /* Start a new frag unless we have max_chars more chars of room in the
 233    current frag.  Close off the old frag with a .fill 0.
 234
 235    Set up a machine_dependent relaxable frag, then start a new frag.
 236    Return the address of the 1st char of the var part of the old frag
 237    to write into.  */
 238
 239 char *
 240 frag_var (relax_stateT type, int max_chars, int var, relax_substateT subtype,
 241           symbolS *symbol, offsetT offset, char *opcode)
 242 {
 243   register char *retval;
 244
 245   frag_grow (max_chars);
 246   retval = obstack_next_free (&frchain_now->frch_obstack);
 247   obstack_blank_fast (&frchain_now->frch_obstack, max_chars);
 248   frag_var_init (type, max_chars, var, subtype, symbol, offset, opcode);
 249   return retval;
 250 }
 251 \f
 252 /* OVE: This variant of frag_var assumes that space for the tail has been
 253         allocated by caller.
 254         No call to frag_grow is done.  */
 255
 256 char *
 257 frag_variant (relax_stateT type, int max_chars, int var,
 258               relax_substateT subtype, symbolS *symbol, offsetT offset,
 259               char *opcode)
 260 {
 261   register char *retval;
 262
 263   retval = obstack_next_free (&frchain_now->frch_obstack);
 264   frag_var_init (type, max_chars, var, subtype, symbol, offset, opcode);
 265
 266   return retval;
 267 }
 268 \f
 269 /* Reduce the variable end of a frag to a harmless state.  */
 270
 271 void
 272 frag_wane (register fragS *fragP)
 273 {
 274   fragP->fr_type = rs_fill;
 275   fragP->fr_offset = 0;
 276   fragP->fr_var = 0;
 277 }
 278 \f
 279 /* Return the number of bytes by which the current frag can be grown.  */
 280
 281 int
 282 frag_room (void)
 283 {
 284   return obstack_room (&frchain_now->frch_obstack);
 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 (int alignment, int fill_character, int max)
 296 {
 297   if (now_seg == absolute_section)
 298     {
 299       addressT new_off;
 300       addressT mask;
 301
 302       mask = (~(addressT) 0) << alignment;
 303       new_off = (abs_section_offset + ~mask) & mask;
 304       if (max == 0 || new_off - abs_section_offset <= (addressT) max)
 305         abs_section_offset = new_off;
 306     }
 307   else
 308     {
 309       char *p;
 310
 311       p = frag_var (rs_align, 1, 1, (relax_substateT) max,
 312                     (symbolS *) 0, (offsetT) alignment, (char *) 0);
 313       *p = fill_character;
 314     }
 315 }
 316
 317 /* Make an alignment frag like frag_align, but fill with a repeating
 318    pattern rather than a single byte.  ALIGNMENT is the power of two
 319    to which to align.  FILL_PATTERN is the fill pattern to repeat in
 320    the bytes which are skipped.  N_FILL is the number of bytes in
 321    FILL_PATTERN.  MAX is the maximum number of characters to skip when
 322    doing the alignment, or 0 if there is no maximum.  */
 323
 324 void
 325 frag_align_pattern (int alignment, const char *fill_pattern,
 326                     int n_fill, 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 (int alignment, int max)
 357 {
 358   char *p;
 359
 360   p = frag_var (rs_align_code, MAX_MEM_FOR_RS_ALIGN_CODE, 1,
 361                 (relax_substateT) max, (symbolS *) 0,
 362                 (offsetT) alignment, (char *) 0);
 363   *p = NOP_OPCODE;
 364 }
 365
 366 addressT
 367 frag_now_fix_octets (void)
 368 {
 369   if (now_seg == absolute_section)
 370     return abs_section_offset;
 371
 372   return ((char *) obstack_next_free (&frchain_now->frch_obstack)
 373           - frag_now->fr_literal);
 374 }
 375
 376 addressT
 377 frag_now_fix (void)
 378 {
 379   return frag_now_fix_octets () / OCTETS_PER_BYTE;
 380 }
 381
 382 void
 383 frag_append_1_char (int datum)
 384 {
 385   frag_alloc_check (&frchain_now->frch_obstack);
 386   if (obstack_room (&frchain_now->frch_obstack) <= 1)
 387     {
 388       frag_wane (frag_now);
 389       frag_new (0);
 390     }
 391   obstack_1grow (&frchain_now->frch_obstack, datum);
 392 }
 393
 394 /* Return TRUE if FRAG1 and FRAG2 have a fixed relationship between
 395    their start addresses.  Set OFFSET to the difference in address
 396    not already accounted for in the frag FR_ADDRESS.  */
 397
 398 bfd_boolean
 399 frag_offset_fixed_p (const fragS *frag1, const fragS *frag2, offsetT *offset)
 400 {
 401   const fragS *frag;
 402   offsetT off;
 403
 404   /* Start with offset initialised to difference between the two frags.
 405      Prior to assigning frag addresses this will be zero.  */
 406   off = frag1->fr_address - frag2->fr_address;
 407   if (frag1 == frag2)
 408     {
 409       *offset = off;
 410       return TRUE;
 411     }
 412
 413   /* Maybe frag2 is after frag1.  */
 414   frag = frag1;
 415   while (frag->fr_type == rs_fill)
 416     {
 417       off += frag->fr_fix + frag->fr_offset * frag->fr_var;
 418       frag = frag->fr_next;
 419       if (frag == NULL)
 420         break;
 421       if (frag == frag2)
 422         {
 423           *offset = off;
 424           return TRUE;
 425         }
 426     }
 427
 428   /* Maybe frag1 is after frag2.  */
 429   off = frag1->fr_address - frag2->fr_address;
 430   frag = frag2;
 431   while (frag->fr_type == rs_fill)
 432     {
 433       off -= frag->fr_fix + frag->fr_offset * frag->fr_var;
 434       frag = frag->fr_next;
 435       if (frag == NULL)
 436         break;
 437       if (frag == frag1)
 438         {
 439           *offset = off;
 440           return TRUE;
 441         }
 442     }
 443
 444   return FALSE;
 445 }