[binutils.git] / gas / frags.c

/* frags.c - manage frags -
   Copyright 1987, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
   1999, 2000
   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
/* 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 %d. 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;

  if (now_seg == absolute_section)
    {
      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;
    }

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