[deliverable/binutils-gdb.git] / gas / frags.c

/* frags.c - manage frags -
   Copyright 1987, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
   1999, 2000, 2001, 2003
   Free Software Foundation, Inc.

   This file is part of GAS, the GNU Assembler.

   GAS is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2, or (at your option)
   any later version.

   GAS is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with GAS; see the file COPYING.  If not, write to the Free
   Software Foundation, 59 Temple Place - Suite 330, Boston, MA
   02111-1307, USA.  */

#include "as.h"
#include "subsegs.h"
#include "obstack.h"

extern fragS zero_address_frag;
extern fragS bss_address_frag;
\f
/* Initialization for frag routines.  */

void
frag_init ()
{
  zero_address_frag.fr_type = rs_fill;
  bss_address_frag.fr_type = rs_fill;
}
\f
/* Check that we're not trying to assemble into a section that can't
   allocate frags (currently, this is only possible in the absolute
   section), or into an mri common.  */

static void
frag_alloc_check (const struct obstack *ob)
{
  if (ob->chunk_size == 0)
    {
      as_bad (_("attempt to allocate data in absolute section"));
      subseg_set (text_section, 0);
    }

  if (mri_common_symbol != NULL)
    {
      as_bad (_("attempt to allocate data in common section"));
      mri_common_symbol = NULL;
    }
}

/* Allocate a frag on the specified obstack.
   Call this routine from everywhere else, so that all the weird alignment
   hackery can be done in just one place.  */

fragS *
frag_alloc (ob)
     struct obstack *ob;
{
  fragS *ptr;
  int oalign;

  (void) obstack_alloc (ob, 0);
  oalign = obstack_alignment_mask (ob);
  obstack_alignment_mask (ob) = 0;
  ptr = (fragS *) obstack_alloc (ob, SIZEOF_STRUCT_FRAG);
  obstack_alignment_mask (ob) = oalign;
  memset (ptr, 0, SIZEOF_STRUCT_FRAG);
  return ptr;
}
\f
/* Try to augment current frag by nchars chars.
   If there is no room, close of the current frag with a ".fill 0"
   and begin a new frag. Unless the new frag has nchars chars available
   do not return. Do not set up any fields of *now_frag.  */

void
frag_grow (nchars)
     unsigned int nchars;
{
  if (obstack_room (&frchain_now->frch_obstack) < nchars)
    {
      unsigned int n;
      long oldc;

      frag_wane (frag_now);
      frag_new (0);
      oldc = frchain_now->frch_obstack.chunk_size;
      frchain_now->frch_obstack.chunk_size = 2 * nchars + SIZEOF_STRUCT_FRAG;
      if (frchain_now->frch_obstack.chunk_size > 0)
	while ((n = obstack_room (&frchain_now->frch_obstack)) < nchars
	       && (unsigned long) frchain_now->frch_obstack.chunk_size > nchars)
	  {
	    frag_wane (frag_now);
	    frag_new (0);
	  }
      frchain_now->frch_obstack.chunk_size = oldc;
    }
  if (obstack_room (&frchain_now->frch_obstack) < nchars)
    as_fatal (_("can't extend frag %u chars"), nchars);
}
\f
/* Call this to close off a completed frag, and start up a new (empty)
   frag, in the same subsegment as the old frag.
   [frchain_now remains the same but frag_now is updated.]
   Because this calculates the correct value of fr_fix by
   looking at the obstack 'frags', it needs to know how many
   characters at the end of the old frag belong to the maximal
   variable part;  The rest must belong to fr_fix.
   It doesn't actually set up the old frag's fr_var.  You may have
   set fr_var == 1, but allocated 10 chars to the end of the frag;
   In this case you pass old_frags_var_max_size == 10.
   In fact, you may use fr_var for something totally unrelated to the
   size of the variable part of the frag;  None of the generic frag
   handling code makes use of fr_var.

   Make a new frag, initialising some components. Link new frag at end
   of frchain_now.  */

void
frag_new (old_frags_var_max_size)
     /* Number of chars (already allocated on obstack frags) in
	variable_length part of frag.  */
     int old_frags_var_max_size;
{
  fragS *former_last_fragP;
  frchainS *frchP;

  assert (frchain_now->frch_last == frag_now);

  /* Fix up old frag's fr_fix.  */
  frag_now->fr_fix = frag_now_fix_octets () - old_frags_var_max_size;
  /* Make sure its type is valid.  */
  assert (frag_now->fr_type != 0);

  /* This will align the obstack so the next struct we allocate on it
     will begin at a correct boundary.  */
  obstack_finish (&frchain_now->frch_obstack);
  frchP = frchain_now;
  know (frchP);
  former_last_fragP = frchP->frch_last;
  assert (former_last_fragP != 0);
  assert (former_last_fragP == frag_now);
  frag_now = frag_alloc (&frchP->frch_obstack);

  as_where (&frag_now->fr_file, &frag_now->fr_line);

  /* Generally, frag_now->points to an address rounded up to next
     alignment.  However, characters will add to obstack frags
     IMMEDIATELY after the struct frag, even if they are not starting
     at an alignment address.  */
  former_last_fragP->fr_next = frag_now;
  frchP->frch_last = frag_now;

#ifndef NO_LISTING
  {
    extern struct list_info_struct *listing_tail;
    frag_now->line = listing_tail;
  }
#endif

  assert (frchain_now->frch_last == frag_now);

  frag_now->fr_next = NULL;
}
\f
/* Start a new frag unless we have n more chars of room in the current frag.
   Close off the old frag with a .fill 0.

   Return the address of the 1st char to write into. Advance
   frag_now_growth past the new chars.  */

char *
frag_more (nchars)
     int nchars;
{
  register char *retval;

  frag_alloc_check (&frchain_now->frch_obstack);
  frag_grow (nchars);
  retval = obstack_next_free (&frchain_now->frch_obstack);
  obstack_blank_fast (&frchain_now->frch_obstack, nchars);
  return (retval);
}
\f
/* Start a new frag unless we have max_chars more chars of room in the
   current frag.  Close off the old frag with a .fill 0.

   Set up a machine_dependent relaxable frag, then start a new frag.
   Return the address of the 1st char of the var part of the old frag
   to write into.  */

char *
frag_var (type, max_chars, var, subtype, symbol, offset, opcode)
     relax_stateT type;
     int max_chars;
     int var;
     relax_substateT subtype;
     symbolS *symbol;
     offsetT offset;
     char *opcode;
{
  register char *retval;

  frag_grow (max_chars);
  retval = obstack_next_free (&frchain_now->frch_obstack);
  obstack_blank_fast (&frchain_now->frch_obstack, max_chars);
  frag_now->fr_var = var;
  frag_now->fr_type = type;
  frag_now->fr_subtype = subtype;
  frag_now->fr_symbol = symbol;
  frag_now->fr_offset = offset;
  frag_now->fr_opcode = opcode;
#ifdef USING_CGEN
  frag_now->fr_cgen.insn = 0;
  frag_now->fr_cgen.opindex = 0;
  frag_now->fr_cgen.opinfo = 0;
#endif
#ifdef TC_FRAG_INIT
  TC_FRAG_INIT (frag_now);
#endif
  as_where (&frag_now->fr_file, &frag_now->fr_line);
  frag_new (max_chars);
  return (retval);
}
\f
/* OVE: This variant of frag_var assumes that space for the tail has been
	allocated by caller.
	No call to frag_grow is done.  */

char *
frag_variant (type, max_chars, var, subtype, symbol, offset, opcode)
     relax_stateT type;
     int max_chars;
     int var;
     relax_substateT subtype;
     symbolS *symbol;
     offsetT offset;
     char *opcode;
{
  register char *retval;

  retval = obstack_next_free (&frchain_now->frch_obstack);
  frag_now->fr_var = var;
  frag_now->fr_type = type;
  frag_now->fr_subtype = subtype;
  frag_now->fr_symbol = symbol;
  frag_now->fr_offset = offset;
  frag_now->fr_opcode = opcode;
#ifdef USING_CGEN
  frag_now->fr_cgen.insn = 0;
  frag_now->fr_cgen.opindex = 0;
  frag_now->fr_cgen.opinfo = 0;
#endif
#ifdef TC_FRAG_INIT
  TC_FRAG_INIT (frag_now);
#endif
  as_where (&frag_now->fr_file, &frag_now->fr_line);
  frag_new (max_chars);
  return (retval);
}
\f
/* Reduce the variable end of a frag to a harmless state.  */

void
frag_wane (fragP)
     register fragS *fragP;
{
  fragP->fr_type = rs_fill;
  fragP->fr_offset = 0;
  fragP->fr_var = 0;
}
\f
/* Make an alignment frag.  The size of this frag will be adjusted to
   force the next frag to have the appropriate alignment.  ALIGNMENT
   is the power of two to which to align.  FILL_CHARACTER is the
   character to use to fill in any bytes which are skipped.  MAX is
   the maximum number of characters to skip when doing the alignment,
   or 0 if there is no maximum.  */

void
frag_align (alignment, fill_character, max)
     int alignment;
     int fill_character;
     int max;
{
  if (now_seg == absolute_section)
    {
      addressT new_off;
      addressT mask;

      mask = (~(addressT) 0) << alignment;
      new_off = (abs_section_offset + ~mask) & mask;
      if (max == 0 || new_off - abs_section_offset <= (addressT) max)
	abs_section_offset = new_off;
    }
  else
    {
      char *p;

      p = frag_var (rs_align, 1, 1, (relax_substateT) max,
		    (symbolS *) 0, (offsetT) alignment, (char *) 0);
      *p = fill_character;
    }
}

/* Make an alignment frag like frag_align, but fill with a repeating
   pattern rather than a single byte.  ALIGNMENT is the power of two
   to which to align.  FILL_PATTERN is the fill pattern to repeat in
   the bytes which are skipped.  N_FILL is the number of bytes in
   FILL_PATTERN.  MAX is the maximum number of characters to skip when
   doing the alignment, or 0 if there is no maximum.  */

void
frag_align_pattern (alignment, fill_pattern, n_fill, max)
     int alignment;
     const char *fill_pattern;
     int n_fill;
     int max;
{
  char *p;

  p = frag_var (rs_align, n_fill, n_fill, (relax_substateT) max,
		(symbolS *) 0, (offsetT) alignment, (char *) 0);
  memcpy (p, fill_pattern, n_fill);
}

/* The NOP_OPCODE is for the alignment fill value.  Fill it with a nop
   instruction so that the disassembler does not choke on it.  */
#ifndef NOP_OPCODE
#define NOP_OPCODE 0x00
#endif

/* Use this to restrict the amount of memory allocated for representing
   the alignment code.  Needs to be large enough to hold any fixed sized
   prologue plus the replicating portion.  */
#ifndef MAX_MEM_FOR_RS_ALIGN_CODE
  /* Assume that if HANDLE_ALIGN is not defined then no special action
     is required to code fill, which means that we get just repeat the
     one NOP_OPCODE byte.  */
# ifndef HANDLE_ALIGN
#  define MAX_MEM_FOR_RS_ALIGN_CODE  1
# else
#  define MAX_MEM_FOR_RS_ALIGN_CODE  ((1 << alignment) - 1)
# endif
#endif

void
frag_align_code (alignment, max)
     int alignment;
     int max;
{
  char *p;

  p = frag_var (rs_align_code, MAX_MEM_FOR_RS_ALIGN_CODE, 1,
		(relax_substateT) max, (symbolS *) 0,
		(offsetT) alignment, (char *) 0);
  *p = NOP_OPCODE;
}

addressT
frag_now_fix_octets ()
{
  if (now_seg == absolute_section)
    return abs_section_offset;

  return ((char *) obstack_next_free (&frchain_now->frch_obstack)
	  - frag_now->fr_literal);
}

addressT
frag_now_fix ()
{
  return frag_now_fix_octets () / OCTETS_PER_BYTE;
}

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