gas/frags.c

   1 /* frags.c - manage frags -
   2    Copyright (C) 1987-2018 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 (ngettext ("can't extend frag %lu char",
 116                             "can't extend frag %lu chars",
 117                             (unsigned long) nchars),
 118                   (unsigned long) nchars);
 119
 120       /* Force to allocate at least NEWC bytes, but not less than the
 121          default.  */
 122       oldc = obstack_chunk_size (&frchain_now->frch_obstack);
 123       if (newc > oldc)
 124         obstack_chunk_size (&frchain_now->frch_obstack) = newc;
 125
 126       while (obstack_room (&frchain_now->frch_obstack) < nchars)
 127         {
 128           /* Not enough room in this frag.  Close it and start a new one.
 129              This must be done in a loop because the created frag may not
 130              be big enough if the current obstack chunk is used.  */
 131           frag_wane (frag_now);
 132           frag_new (0);
 133         }
 134
 135       /* Restore the old chunk size.  */
 136       obstack_chunk_size (&frchain_now->frch_obstack) = oldc;
 137     }
 138 }
 139 \f
 140 /* Call this to close off a completed frag, and start up a new (empty)
 141    frag, in the same subsegment as the old frag.
 142    [frchain_now remains the same but frag_now is updated.]
 143    Because this calculates the correct value of fr_fix by
 144    looking at the obstack 'frags', it needs to know how many
 145    characters at the end of the old frag belong to the maximal
 146    variable part;  The rest must belong to fr_fix.
 147    It doesn't actually set up the old frag's fr_var.  You may have
 148    set fr_var == 1, but allocated 10 chars to the end of the frag;
 149    In this case you pass old_frags_var_max_size == 10.
 150    In fact, you may use fr_var for something totally unrelated to the
 151    size of the variable part of the frag;  None of the generic frag
 152    handling code makes use of fr_var.
 153
 154    Make a new frag, initialising some components. Link new frag at end
 155    of frchain_now.  */
 156
 157 void
 158 frag_new (size_t old_frags_var_max_size
 159           /* Number of chars (already allocated on obstack frags) in
 160              variable_length part of frag.  */)
 161 {
 162   fragS *former_last_fragP;
 163   frchainS *frchP;
 164
 165   gas_assert (frchain_now->frch_last == frag_now);
 166
 167   /* Fix up old frag's fr_fix.  */
 168   frag_now->fr_fix = frag_now_fix_octets () - old_frags_var_max_size;
 169   /* Make sure its type is valid.  */
 170   gas_assert (frag_now->fr_type != 0);
 171
 172   /* This will align the obstack so the next struct we allocate on it
 173      will begin at a correct boundary.  */
 174   obstack_finish (&frchain_now->frch_obstack);
 175   frchP = frchain_now;
 176   know (frchP);
 177   former_last_fragP = frchP->frch_last;
 178   gas_assert (former_last_fragP != 0);
 179   gas_assert (former_last_fragP == frag_now);
 180   frag_now = frag_alloc (&frchP->frch_obstack);
 181
 182   frag_now->fr_file = as_where (&frag_now->fr_line);
 183
 184   /* Generally, frag_now->points to an address rounded up to next
 185      alignment.  However, characters will add to obstack frags
 186      IMMEDIATELY after the struct frag, even if they are not starting
 187      at an alignment address.  */
 188   former_last_fragP->fr_next = frag_now;
 189   frchP->frch_last = frag_now;
 190
 191 #ifndef NO_LISTING
 192   {
 193     extern struct list_info_struct *listing_tail;
 194     frag_now->line = listing_tail;
 195   }
 196 #endif
 197
 198   gas_assert (frchain_now->frch_last == frag_now);
 199
 200   frag_now->fr_next = NULL;
 201 }
 202 \f
 203 /* Start a new frag unless we have n more chars of room in the current frag.
 204    Close off the old frag with a .fill 0.
 205
 206    Return the address of the 1st char to write into. Advance
 207    frag_now_growth past the new chars.  */
 208
 209 char *
 210 frag_more (size_t nchars)
 211 {
 212   char *retval;
 213
 214   frag_alloc_check (&frchain_now->frch_obstack);
 215   frag_grow (nchars);
 216   retval = obstack_next_free (&frchain_now->frch_obstack);
 217   obstack_blank_fast (&frchain_now->frch_obstack, nchars);
 218   return retval;
 219 }
 220 \f
 221 /* Close the current frag, setting its fields for a relaxable frag.  Start a
 222    new frag.  */
 223
 224 static void
 225 frag_var_init (relax_stateT type, size_t max_chars, size_t var,
 226                relax_substateT subtype, symbolS *symbol, offsetT offset,
 227                char *opcode)
 228 {
 229   frag_now->fr_var = var;
 230   frag_now->fr_type = type;
 231   frag_now->fr_subtype = subtype;
 232   frag_now->fr_symbol = symbol;
 233   frag_now->fr_offset = offset;
 234   frag_now->fr_opcode = opcode;
 235 #ifdef USING_CGEN
 236   frag_now->fr_cgen.insn = 0;
 237   frag_now->fr_cgen.opindex = 0;
 238   frag_now->fr_cgen.opinfo = 0;
 239 #endif
 240 #ifdef TC_FRAG_INIT
 241   TC_FRAG_INIT (frag_now);
 242 #endif
 243   frag_now->fr_file = as_where (&frag_now->fr_line);
 244
 245   frag_new (max_chars);
 246 }
 247
 248 /* Start a new frag unless we have max_chars more chars of room in the
 249    current frag.  Close off the old frag with a .fill 0.
 250
 251    Set up a machine_dependent relaxable frag, then start a new frag.
 252    Return the address of the 1st char of the var part of the old frag
 253    to write into.  */
 254
 255 char *
 256 frag_var (relax_stateT type, size_t max_chars, size_t var,
 257           relax_substateT subtype, symbolS *symbol, offsetT offset,
 258           char *opcode)
 259 {
 260   char *retval;
 261
 262   frag_grow (max_chars);
 263   retval = obstack_next_free (&frchain_now->frch_obstack);
 264   obstack_blank_fast (&frchain_now->frch_obstack, max_chars);
 265   frag_var_init (type, max_chars, var, subtype, symbol, offset, opcode);
 266   return retval;
 267 }
 268 \f
 269 /* OVE: This variant of frag_var assumes that space for the tail has been
 270         allocated by caller.
 271         No call to frag_grow is done.  */
 272
 273 char *
 274 frag_variant (relax_stateT type, size_t max_chars, size_t var,
 275               relax_substateT subtype, symbolS *symbol, offsetT offset,
 276               char *opcode)
 277 {
 278   char *retval;
 279
 280   retval = obstack_next_free (&frchain_now->frch_obstack);
 281   frag_var_init (type, max_chars, var, subtype, symbol, offset, opcode);
 282
 283   return retval;
 284 }
 285 \f
 286 /* Reduce the variable end of a frag to a harmless state.  */
 287
 288 void
 289 frag_wane (fragS *fragP)
 290 {
 291   fragP->fr_type = rs_fill;
 292   fragP->fr_offset = 0;
 293   fragP->fr_var = 0;
 294 }
 295 \f
 296 /* Return the number of bytes by which the current frag can be grown.  */
 297
 298 size_t
 299 frag_room (void)
 300 {
 301   return obstack_room (&frchain_now->frch_obstack);
 302 }
 303 \f
 304 /* Make an alignment frag.  The size of this frag will be adjusted to
 305    force the next frag to have the appropriate alignment.  ALIGNMENT
 306    is the power of two to which to align.  FILL_CHARACTER is the
 307    character to use to fill in any bytes which are skipped.  MAX is
 308    the maximum number of characters to skip when doing the alignment,
 309    or 0 if there is no maximum.  */
 310
 311 void
 312 frag_align (int alignment, int fill_character, int max)
 313 {
 314   if (now_seg == absolute_section)
 315     {
 316       addressT new_off;
 317       addressT mask;
 318
 319       mask = (~(addressT) 0) << alignment;
 320       new_off = (abs_section_offset + ~mask) & mask;
 321       if (max == 0 || new_off - abs_section_offset <= (addressT) max)
 322         abs_section_offset = new_off;
 323     }
 324   else
 325     {
 326       char *p;
 327
 328       p = frag_var (rs_align, 1, 1, (relax_substateT) max,
 329                     (symbolS *) 0, (offsetT) alignment, (char *) 0);
 330       *p = fill_character;
 331     }
 332 }
 333
 334 /* Make an alignment frag like frag_align, but fill with a repeating
 335    pattern rather than a single byte.  ALIGNMENT is the power of two
 336    to which to align.  FILL_PATTERN is the fill pattern to repeat in
 337    the bytes which are skipped.  N_FILL is the number of bytes in
 338    FILL_PATTERN.  MAX is the maximum number of characters to skip when
 339    doing the alignment, or 0 if there is no maximum.  */
 340
 341 void
 342 frag_align_pattern (int alignment, const char *fill_pattern,
 343                     size_t n_fill, int max)
 344 {
 345   char *p;
 346
 347   p = frag_var (rs_align, n_fill, n_fill, (relax_substateT) max,
 348                 (symbolS *) 0, (offsetT) alignment, (char *) 0);
 349   memcpy (p, fill_pattern, n_fill);
 350 }
 351
 352 /* The NOP_OPCODE is for the alignment fill value.  Fill it with a nop
 353    instruction so that the disassembler does not choke on it.  */
 354 #ifndef NOP_OPCODE
 355 #define NOP_OPCODE 0x00
 356 #endif
 357
 358 /* Use this to restrict the amount of memory allocated for representing
 359    the alignment code.  Needs to be large enough to hold any fixed sized
 360    prologue plus the replicating portion.  */
 361 #ifndef MAX_MEM_FOR_RS_ALIGN_CODE
 362   /* Assume that if HANDLE_ALIGN is not defined then no special action
 363      is required to code fill, which means that we get just repeat the
 364      one NOP_OPCODE byte.  */
 365 # ifndef HANDLE_ALIGN
 366 #  define MAX_MEM_FOR_RS_ALIGN_CODE  1
 367 # else
 368 #  define MAX_MEM_FOR_RS_ALIGN_CODE  ((1 << alignment) - 1)
 369 # endif
 370 #endif
 371
 372 void
 373 frag_align_code (int alignment, int max)
 374 {
 375   char *p;
 376
 377   p = frag_var (rs_align_code, MAX_MEM_FOR_RS_ALIGN_CODE, 1,
 378                 (relax_substateT) max, (symbolS *) 0,
 379                 (offsetT) alignment, (char *) 0);
 380   *p = NOP_OPCODE;
 381 }
 382
 383 addressT
 384 frag_now_fix_octets (void)
 385 {
 386   if (now_seg == absolute_section)
 387     return abs_section_offset;
 388
 389   return ((char *) obstack_next_free (&frchain_now->frch_obstack)
 390           - frag_now->fr_literal);
 391 }
 392
 393 addressT
 394 frag_now_fix (void)
 395 {
 396   return frag_now_fix_octets () / OCTETS_PER_BYTE;
 397 }
 398
 399 void
 400 frag_append_1_char (int datum)
 401 {
 402   frag_alloc_check (&frchain_now->frch_obstack);
 403   if (obstack_room (&frchain_now->frch_obstack) <= 1)
 404     {
 405       frag_wane (frag_now);
 406       frag_new (0);
 407     }
 408   obstack_1grow (&frchain_now->frch_obstack, datum);
 409 }
 410
 411 /* Return TRUE if FRAG1 and FRAG2 have a fixed relationship between
 412    their start addresses.  Set OFFSET to the difference in address
 413    not already accounted for in the frag FR_ADDRESS.  */
 414
 415 bfd_boolean
 416 frag_offset_fixed_p (const fragS *frag1, const fragS *frag2, offsetT *offset)
 417 {
 418   const fragS *frag;
 419   offsetT off;
 420
 421   /* Start with offset initialised to difference between the two frags.
 422      Prior to assigning frag addresses this will be zero.  */
 423   off = frag1->fr_address - frag2->fr_address;
 424   if (frag1 == frag2)
 425     {
 426       *offset = off;
 427       return TRUE;
 428     }
 429
 430   /* Maybe frag2 is after frag1.  */
 431   frag = frag1;
 432   while (frag->fr_type == rs_fill)
 433     {
 434       off += frag->fr_fix + frag->fr_offset * frag->fr_var;
 435       frag = frag->fr_next;
 436       if (frag == NULL)
 437         break;
 438       if (frag == frag2)
 439         {
 440           *offset = off;
 441           return TRUE;
 442         }
 443     }
 444
 445   /* Maybe frag1 is after frag2.  */
 446   off = frag1->fr_address - frag2->fr_address;
 447   frag = frag2;
 448   while (frag->fr_type == rs_fill)
 449     {
 450       off -= frag->fr_fix + frag->fr_offset * frag->fr_var;
 451       frag = frag->fr_next;
 452       if (frag == NULL)
 453         break;
 454       if (frag == frag1)
 455         {
 456           *offset = off;
 457           return TRUE;
 458         }
 459     }
 460
 461   return FALSE;
 462 }