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
   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 2, 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, 59 Temple Place - Suite 330, Boston, MA
  21    02111-1307, 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       frchain_now->frch_obstack.chunk_size = 2 * nchars + SIZEOF_STRUCT_FRAG;
  95       if (frchain_now->frch_obstack.chunk_size > 0)
  96         while ((n = obstack_room (&frchain_now->frch_obstack)) < nchars
  97                && (unsigned long) frchain_now->frch_obstack.chunk_size > nchars)
  98           {
  99             frag_wane (frag_now);
 100             frag_new (0);
 101           }
 102       frchain_now->frch_obstack.chunk_size = oldc;
 103     }
 104   if (obstack_room (&frchain_now->frch_obstack) < nchars)
 105     as_fatal (_("can't extend frag %u chars"), nchars);
 106 }
 107 \f
 108 /* Call this to close off a completed frag, and start up a new (empty)
 109    frag, in the same subsegment as the old frag.
 110    [frchain_now remains the same but frag_now is updated.]
 111    Because this calculates the correct value of fr_fix by
 112    looking at the obstack 'frags', it needs to know how many
 113    characters at the end of the old frag belong to the maximal
 114    variable part;  The rest must belong to fr_fix.
 115    It doesn't actually set up the old frag's fr_var.  You may have
 116    set fr_var == 1, but allocated 10 chars to the end of the frag;
 117    In this case you pass old_frags_var_max_size == 10.
 118    In fact, you may use fr_var for something totally unrelated to the
 119    size of the variable part of the frag;  None of the generic frag
 120    handling code makes use of fr_var.
 121
 122    Make a new frag, initialising some components. Link new frag at end
 123    of frchain_now.  */
 124
 125 void
 126 frag_new (int old_frags_var_max_size
 127           /* Number of chars (already allocated on obstack frags) in
 128              variable_length part of frag.  */)
 129 {
 130   fragS *former_last_fragP;
 131   frchainS *frchP;
 132
 133   assert (frchain_now->frch_last == frag_now);
 134
 135   /* Fix up old frag's fr_fix.  */
 136   frag_now->fr_fix = frag_now_fix_octets () - old_frags_var_max_size;
 137   /* Make sure its type is valid.  */
 138   assert (frag_now->fr_type != 0);
 139
 140   /* This will align the obstack so the next struct we allocate on it
 141      will begin at a correct boundary.  */
 142   obstack_finish (&frchain_now->frch_obstack);
 143   frchP = frchain_now;
 144   know (frchP);
 145   former_last_fragP = frchP->frch_last;
 146   assert (former_last_fragP != 0);
 147   assert (former_last_fragP == frag_now);
 148   frag_now = frag_alloc (&frchP->frch_obstack);
 149
 150   as_where (&frag_now->fr_file, &frag_now->fr_line);
 151
 152   /* Generally, frag_now->points to an address rounded up to next
 153      alignment.  However, characters will add to obstack frags
 154      IMMEDIATELY after the struct frag, even if they are not starting
 155      at an alignment address.  */
 156   former_last_fragP->fr_next = frag_now;
 157   frchP->frch_last = frag_now;
 158
 159 #ifndef NO_LISTING
 160   {
 161     extern struct list_info_struct *listing_tail;
 162     frag_now->line = listing_tail;
 163   }
 164 #endif
 165
 166   assert (frchain_now->frch_last == frag_now);
 167
 168   frag_now->fr_next = NULL;
 169 }
 170 \f
 171 /* Start a new frag unless we have n more chars of room in the current frag.
 172    Close off the old frag with a .fill 0.
 173
 174    Return the address of the 1st char to write into. Advance
 175    frag_now_growth past the new chars.  */
 176
 177 char *
 178 frag_more (int nchars)
 179 {
 180   register char *retval;
 181
 182   frag_alloc_check (&frchain_now->frch_obstack);
 183   frag_grow (nchars);
 184   retval = obstack_next_free (&frchain_now->frch_obstack);
 185   obstack_blank_fast (&frchain_now->frch_obstack, nchars);
 186   return (retval);
 187 }
 188 \f
 189 /* Start a new frag unless we have max_chars more chars of room in the
 190    current frag.  Close off the old frag with a .fill 0.
 191
 192    Set up a machine_dependent relaxable frag, then start a new frag.
 193    Return the address of the 1st char of the var part of the old frag
 194    to write into.  */
 195
 196 char *
 197 frag_var (relax_stateT type, int max_chars, int var, relax_substateT subtype,
 198           symbolS *symbol, offsetT offset, char *opcode)
 199 {
 200   register char *retval;
 201
 202   frag_grow (max_chars);
 203   retval = obstack_next_free (&frchain_now->frch_obstack);
 204   obstack_blank_fast (&frchain_now->frch_obstack, max_chars);
 205   frag_now->fr_var = var;
 206   frag_now->fr_type = type;
 207   frag_now->fr_subtype = subtype;
 208   frag_now->fr_symbol = symbol;
 209   frag_now->fr_offset = offset;
 210   frag_now->fr_opcode = opcode;
 211 #ifdef USING_CGEN
 212   frag_now->fr_cgen.insn = 0;
 213   frag_now->fr_cgen.opindex = 0;
 214   frag_now->fr_cgen.opinfo = 0;
 215 #endif
 216 #ifdef TC_FRAG_INIT
 217   TC_FRAG_INIT (frag_now);
 218 #endif
 219   as_where (&frag_now->fr_file, &frag_now->fr_line);
 220   frag_new (max_chars);
 221   return (retval);
 222 }
 223 \f
 224 /* OVE: This variant of frag_var assumes that space for the tail has been
 225         allocated by caller.
 226         No call to frag_grow is done.  */
 227
 228 char *
 229 frag_variant (relax_stateT type, int max_chars, int var,
 230               relax_substateT subtype, symbolS *symbol, offsetT offset,
 231               char *opcode)
 232 {
 233   register char *retval;
 234
 235   retval = obstack_next_free (&frchain_now->frch_obstack);
 236   frag_now->fr_var = var;
 237   frag_now->fr_type = type;
 238   frag_now->fr_subtype = subtype;
 239   frag_now->fr_symbol = symbol;
 240   frag_now->fr_offset = offset;
 241   frag_now->fr_opcode = opcode;
 242 #ifdef USING_CGEN
 243   frag_now->fr_cgen.insn = 0;
 244   frag_now->fr_cgen.opindex = 0;
 245   frag_now->fr_cgen.opinfo = 0;
 246 #endif
 247 #ifdef TC_FRAG_INIT
 248   TC_FRAG_INIT (frag_now);
 249 #endif
 250   as_where (&frag_now->fr_file, &frag_now->fr_line);
 251   frag_new (max_chars);
 252   return (retval);
 253 }
 254 \f
 255 /* Reduce the variable end of a frag to a harmless state.  */
 256
 257 void
 258 frag_wane (register fragS *fragP)
 259 {
 260   fragP->fr_type = rs_fill;
 261   fragP->fr_offset = 0;
 262   fragP->fr_var = 0;
 263 }
 264 \f
 265 /* Return the number of bytes by which the current frag can be grown.  */
 266
 267 int
 268 frag_room (void)
 269 {
 270   return obstack_room (&frchain_now->frch_obstack);
 271 }
 272 \f
 273 /* Make an alignment frag.  The size of this frag will be adjusted to
 274    force the next frag to have the appropriate alignment.  ALIGNMENT
 275    is the power of two to which to align.  FILL_CHARACTER is the
 276    character to use to fill in any bytes which are skipped.  MAX is
 277    the maximum number of characters to skip when doing the alignment,
 278    or 0 if there is no maximum.  */
 279
 280 void
 281 frag_align (int alignment, int fill_character, int max)
 282 {
 283   if (now_seg == absolute_section)
 284     {
 285       addressT new_off;
 286       addressT mask;
 287
 288       mask = (~(addressT) 0) << alignment;
 289       new_off = (abs_section_offset + ~mask) & mask;
 290       if (max == 0 || new_off - abs_section_offset <= (addressT) max)
 291         abs_section_offset = new_off;
 292     }
 293   else
 294     {
 295       char *p;
 296
 297       p = frag_var (rs_align, 1, 1, (relax_substateT) max,
 298                     (symbolS *) 0, (offsetT) alignment, (char *) 0);
 299       *p = fill_character;
 300     }
 301 }
 302
 303 /* Make an alignment frag like frag_align, but fill with a repeating
 304    pattern rather than a single byte.  ALIGNMENT is the power of two
 305    to which to align.  FILL_PATTERN is the fill pattern to repeat in
 306    the bytes which are skipped.  N_FILL is the number of bytes in
 307    FILL_PATTERN.  MAX is the maximum number of characters to skip when
 308    doing the alignment, or 0 if there is no maximum.  */
 309
 310 void
 311 frag_align_pattern (int alignment, const char *fill_pattern,
 312                     int n_fill, int max)
 313 {
 314   char *p;
 315
 316   p = frag_var (rs_align, n_fill, n_fill, (relax_substateT) max,
 317                 (symbolS *) 0, (offsetT) alignment, (char *) 0);
 318   memcpy (p, fill_pattern, n_fill);
 319 }
 320
 321 /* The NOP_OPCODE is for the alignment fill value.  Fill it with a nop
 322    instruction so that the disassembler does not choke on it.  */
 323 #ifndef NOP_OPCODE
 324 #define NOP_OPCODE 0x00
 325 #endif
 326
 327 /* Use this to restrict the amount of memory allocated for representing
 328    the alignment code.  Needs to be large enough to hold any fixed sized
 329    prologue plus the replicating portion.  */
 330 #ifndef MAX_MEM_FOR_RS_ALIGN_CODE
 331   /* Assume that if HANDLE_ALIGN is not defined then no special action
 332      is required to code fill, which means that we get just repeat the
 333      one NOP_OPCODE byte.  */
 334 # ifndef HANDLE_ALIGN
 335 #  define MAX_MEM_FOR_RS_ALIGN_CODE  1
 336 # else
 337 #  define MAX_MEM_FOR_RS_ALIGN_CODE  ((1 << alignment) - 1)
 338 # endif
 339 #endif
 340
 341 void
 342 frag_align_code (int alignment, int max)
 343 {
 344   char *p;
 345
 346   p = frag_var (rs_align_code, MAX_MEM_FOR_RS_ALIGN_CODE, 1,
 347                 (relax_substateT) max, (symbolS *) 0,
 348                 (offsetT) alignment, (char *) 0);
 349   *p = NOP_OPCODE;
 350 }
 351
 352 addressT
 353 frag_now_fix_octets (void)
 354 {
 355   if (now_seg == absolute_section)
 356     return abs_section_offset;
 357
 358   return ((char *) obstack_next_free (&frchain_now->frch_obstack)
 359           - frag_now->fr_literal);
 360 }
 361
 362 addressT
 363 frag_now_fix (void)
 364 {
 365   return frag_now_fix_octets () / OCTETS_PER_BYTE;
 366 }
 367
 368 void
 369 frag_append_1_char (int datum)
 370 {
 371   frag_alloc_check (&frchain_now->frch_obstack);
 372   if (obstack_room (&frchain_now->frch_obstack) <= 1)
 373     {
 374       frag_wane (frag_now);
 375       frag_new (0);
 376     }
 377   obstack_1grow (&frchain_now->frch_obstack, datum);
 378 }