gas/frags.c

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