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