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