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
   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 /* Make an alignment frag.  The size of this frag will be adjusted to
 266    force the next frag to have the appropriate alignment.  ALIGNMENT
 267    is the power of two to which to align.  FILL_CHARACTER is the
 268    character to use to fill in any bytes which are skipped.  MAX is
 269    the maximum number of characters to skip when doing the alignment,
 270    or 0 if there is no maximum.  */
 271
 272 void
 273 frag_align (int alignment, int fill_character, int max)
 274 {
 275   if (now_seg == absolute_section)
 276     {
 277       addressT new_off;
 278       addressT mask;
 279
 280       mask = (~(addressT) 0) << alignment;
 281       new_off = (abs_section_offset + ~mask) & mask;
 282       if (max == 0 || new_off - abs_section_offset <= (addressT) max)
 283         abs_section_offset = new_off;
 284     }
 285   else
 286     {
 287       char *p;
 288
 289       p = frag_var (rs_align, 1, 1, (relax_substateT) max,
 290                     (symbolS *) 0, (offsetT) alignment, (char *) 0);
 291       *p = fill_character;
 292     }
 293 }
 294
 295 /* Make an alignment frag like frag_align, but fill with a repeating
 296    pattern rather than a single byte.  ALIGNMENT is the power of two
 297    to which to align.  FILL_PATTERN is the fill pattern to repeat in
 298    the bytes which are skipped.  N_FILL is the number of bytes in
 299    FILL_PATTERN.  MAX is the maximum number of characters to skip when
 300    doing the alignment, or 0 if there is no maximum.  */
 301
 302 void
 303 frag_align_pattern (int alignment, const char *fill_pattern,
 304                     int n_fill, int max)
 305 {
 306   char *p;
 307
 308   p = frag_var (rs_align, n_fill, n_fill, (relax_substateT) max,
 309                 (symbolS *) 0, (offsetT) alignment, (char *) 0);
 310   memcpy (p, fill_pattern, n_fill);
 311 }
 312
 313 /* The NOP_OPCODE is for the alignment fill value.  Fill it with a nop
 314    instruction so that the disassembler does not choke on it.  */
 315 #ifndef NOP_OPCODE
 316 #define NOP_OPCODE 0x00
 317 #endif
 318
 319 /* Use this to restrict the amount of memory allocated for representing
 320    the alignment code.  Needs to be large enough to hold any fixed sized
 321    prologue plus the replicating portion.  */
 322 #ifndef MAX_MEM_FOR_RS_ALIGN_CODE
 323   /* Assume that if HANDLE_ALIGN is not defined then no special action
 324      is required to code fill, which means that we get just repeat the
 325      one NOP_OPCODE byte.  */
 326 # ifndef HANDLE_ALIGN
 327 #  define MAX_MEM_FOR_RS_ALIGN_CODE  1
 328 # else
 329 #  define MAX_MEM_FOR_RS_ALIGN_CODE  ((1 << alignment) - 1)
 330 # endif
 331 #endif
 332
 333 void
 334 frag_align_code (int alignment, int max)
 335 {
 336   char *p;
 337
 338   p = frag_var (rs_align_code, MAX_MEM_FOR_RS_ALIGN_CODE, 1,
 339                 (relax_substateT) max, (symbolS *) 0,
 340                 (offsetT) alignment, (char *) 0);
 341   *p = NOP_OPCODE;
 342 }
 343
 344 addressT
 345 frag_now_fix_octets (void)
 346 {
 347   if (now_seg == absolute_section)
 348     return abs_section_offset;
 349
 350   return ((char *) obstack_next_free (&frchain_now->frch_obstack)
 351           - frag_now->fr_literal);
 352 }
 353
 354 addressT
 355 frag_now_fix (void)
 356 {
 357   return frag_now_fix_octets () / OCTETS_PER_BYTE;
 358 }
 359
 360 void
 361 frag_append_1_char (int datum)
 362 {
 363   frag_alloc_check (&frchain_now->frch_obstack);
 364   if (obstack_room (&frchain_now->frch_obstack) <= 1)
 365     {
 366       frag_wane (frag_now);
 367       frag_new (0);
 368     }
 369   obstack_1grow (&frchain_now->frch_obstack, datum);
 370 }