Initial revision

1 files changed, 1162 insertions, 0 deletions

diff --git a/gas/write.c b/gas/write.c
new file mode 100644
index 0000000..a0b36c3
--- /dev/null
+++ b/gas/write.c
@@ -0,0 +1,1162 @@
+/* write.c - emit .o file
+   Copyright (C) 1986, 1987, 1990, 1991 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 1, 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, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+/* static const char rcsid[] = "$Id$"; */
+
+/* 
+
+   This thing should be set up to do byteordering correctly.  But...
+
+   In order to cross-assemble the target machine must have an a.out header
+   similar to the one in a.out.h on THIS machine.  Byteorder doesn't matter,
+   we take special care of it, but the numbers must be the same SIZE (# of
+   bytes) and in the same PLACE.  If this is not true, you will have some
+   trouble.
+ */
+
+#include "as.h"
+
+#include "subsegs.h"
+#include "obstack.h"
+#include "output-file.h"
+
+/* Hook for machine dependent relocation information output routine.
+   If not defined, the variable is allocated in BSS (Fortran common model).
+   If some other module defines it, we will see their value.  */
+
+void (*md_emit_relocations)();
+
+/*
+ * In: length of relocation (or of address) in chars: 1, 2 or 4.
+ * Out: GNU LD relocation length code: 0, 1, or 2.
+ */
+
+unsigned char
+nbytes_r_length [] = {
+  42, 0, 1, 42, 2
+  };
+
+
+static struct frag *text_frag_root;
+static struct frag *data_frag_root;
+
+static struct frag *text_last_frag;	/* Last frag in segment. */
+static struct frag *data_last_frag;	/* Last frag in segment. */
+
+static object_headers headers;
+
+long string_byte_count;
+
+static char *the_object_file;
+
+char *next_object_file_charP;	/* Tracks object file bytes. */
+
+int magic_number_for_object_file = DEFAULT_MAGIC_NUMBER_FOR_OBJECT_FILE;
+
+/* static long		length; JF unused */	/* String length, including trailing '\0'. */
+
+
+#ifdef __STDC__
+
+static int is_dnrange(struct frag *f1, struct frag *f2);
+static long fixup_segment(fixS *fixP, segT this_segment_type);
+static relax_addressT relax_align(relax_addressT address, long alignment);
+static void relax_segment(struct frag *segment_frag_root, segT segment_type);
+
+#else
+
+static int is_dnrange();
+static long fixup_segment();
+static relax_addressT relax_align();
+static void relax_segment();
+
+#endif /* __STDC__ */
+
+/*
+ *			fix_new()
+ *
+ * Create a fixS in obstack 'notes'.
+ */
+fixS *fix_new(frag, where, size, add_symbol, sub_symbol, offset, pcrel, r_type)
+fragS *frag;		/* Which frag? */
+int where;		/* Where in that frag? */
+short int size;		/* 1, 2  or 4 usually. */
+symbolS *add_symbol;	/* X_add_symbol. */
+symbolS *sub_symbol;	/* X_subtract_symbol. */
+long offset;		/* X_add_number. */
+int pcrel;		/* TRUE if PC-relative relocation. */
+enum reloc_type	r_type;	/* Relocation type */
+{
+  register fixS *	fixP;
+
+  fixP = (fixS *)obstack_alloc(&notes,sizeof(fixS));
+
+  fixP->fx_frag	= frag;
+  fixP->fx_where	= where;
+  fixP->fx_size	= size;
+  fixP->fx_addsy	= add_symbol;
+  fixP->fx_subsy	= sub_symbol;
+  fixP->fx_offset	= offset;
+  fixP->fx_pcrel	= pcrel;
+  fixP->fx_r_type	= r_type;
+  fixP->fx_next	= NULL;
+
+  /* JF these 'cuz of the NS32K stuff */
+  fixP->fx_im_disp	= 0;
+  fixP->fx_pcrel_adjust = 0;
+  fixP->fx_bsr	= 0;
+  fixP->fx_bit_fixP	= 0;
+
+  if (*seg_fix_tailP)
+    (*seg_fix_tailP)->fx_next = fixP;
+  else
+    *seg_fix_rootP = fixP;
+  *seg_fix_tailP = fixP;
+  fixP->fx_callj = 0;
+  return fixP;
+}
+
+void write_object_file() {
+  register struct frchain *	frchainP; /* Track along all frchains. */
+  register fragS *		fragP;	/* Track along all frags. */
+  register struct frchain *	next_frchainP;
+  register fragS * *		prev_fragPP;
+/*  register char *		name; */
+/*  symbolS *symbolP; */
+/*  register symbolS **		symbolPP; */
+  /* register fixS *		fixP; JF unused */
+  unsigned int data_siz;
+
+#ifdef DONTDEF
+  void gdb_emit();
+  void gdb_end();
+#endif
+  long object_file_size;
+
+#ifdef	VMS
+  /*
+   *	Under VMS we try to be compatible with VAX-11 "C".  Thus, we
+   *	call a routine to check for the definition of the procedure
+   *	"_main", and if so -- fix it up so that it can be program
+   *	entry point.
+   */
+  VMS_Check_For_Main();
+#endif /* VMS */
+  /*
+   * After every sub-segment, we fake an ".align ...". This conforms to BSD4.2
+   * brane-damage. We then fake ".fill 0" because that is the kind of frag
+   * that requires least thought. ".align" frags like to have a following
+   * frag since that makes calculating their intended length trivial.
+   */
+#define SUB_SEGMENT_ALIGN (2)
+  for (frchainP = frchain_root; frchainP; frchainP = frchainP->frch_next) {
+#ifdef	VMS
+	  /*
+	   *	Under VAX/VMS, the linker (and PSECT specifications)
+	   *	take care of correctly aligning the segments.
+	   *	Doing the alignment here (on initialized data) can
+	   *	mess up the calculation of global data PSECT sizes.
+	   */
+#undef	SUB_SEGMENT_ALIGN
+#define	SUB_SEGMENT_ALIGN ((frchainP->frch_seg != SEG_DATA) ? 2 : 0)
+#endif	/* VMS */
+	  subseg_new (frchainP->frch_seg, frchainP->frch_subseg);
+	  frag_align (SUB_SEGMENT_ALIGN, 0);
+	  /* frag_align will have left a new frag. */
+	  /* Use this last frag for an empty ".fill". */
+	  /*
+	   * For this segment ...
+	   * Create a last frag. Do not leave a "being filled in frag".
+	   */
+	  frag_wane (frag_now);
+	  frag_now->fr_fix	= 0;
+	  know( frag_now->fr_next == NULL );
+	  /* know( frags . obstack_c_base == frags . obstack_c_next_free ); */
+	  /* Above shows we haven't left a half-completed object on obstack. */
+  } /* walk the frag chain */
+
+  /*
+   * From now on, we don't care about sub-segments.
+   * Build one frag chain for each segment. Linked thru fr_next.
+   * We know that there is at least 1 text frchain & at least 1 data frchain.
+   */
+  prev_fragPP = &text_frag_root;
+  for (frchainP = frchain_root; frchainP; frchainP = next_frchainP) {
+	  know( frchainP->frch_root );
+	  * prev_fragPP = frchainP->frch_root;
+	  prev_fragPP = & frchainP->frch_last->fr_next;
+	  
+	  if (((next_frchainP = frchainP->frch_next) == NULL)
+	      || next_frchainP == data0_frchainP) {
+		  prev_fragPP = & data_frag_root;
+		  if (next_frchainP) {
+			  text_last_frag = frchainP->frch_last;
+		  } else {
+			  data_last_frag = frchainP->frch_last;
+		  }
+	  }
+  } /* walk the frag chain */
+
+  /*
+   * We have two segments. If user gave -R flag, then we must put the
+   * data frags into the text segment. Do this before relaxing so
+   * we know to take advantage of -R and make shorter addresses.
+   */
+  if (flagseen[ 'R' ]) {
+	  fixS *tmp;
+	  
+	  text_last_frag->fr_next = data_frag_root;
+	  text_last_frag = data_last_frag;
+	  data_last_frag = NULL;
+	  data_frag_root = NULL;
+	  if (text_fix_root) {
+		  for (tmp = text_fix_root; tmp->fx_next; tmp = tmp->fx_next) ;;
+		  tmp->fx_next=data_fix_root;
+	  } else
+	      text_fix_root=data_fix_root;
+	  data_fix_root=NULL;
+  }
+
+  relax_segment(text_frag_root, SEG_TEXT);
+  relax_segment(data_frag_root, SEG_DATA);
+  /*
+   * Now the addresses of frags are correct within the segment.
+   */
+
+  know(text_last_frag->fr_type == rs_fill && text_last_frag->fr_offset == 0);
+  H_SET_TEXT_SIZE(&headers,text_last_frag->fr_address);
+  text_last_frag->fr_address=H_GET_TEXT_SIZE(&headers);
+
+  /*
+   * Join the 2 segments into 1 huge segment.
+   * To do this, re-compute every rn_address in the SEG_DATA frags.
+   * Then join the data frags after the text frags.
+   *
+   * Determine a_data [length of data segment].
+   */
+  if (data_frag_root) {
+	  register relax_addressT	slide;
+	  
+	  know(   text_last_frag->fr_type   == rs_fill && text_last_frag->fr_offset == 0 );
+	  H_SET_DATA_SIZE(&headers, data_last_frag->fr_address);
+	  data_last_frag->fr_address = H_GET_DATA_SIZE(&headers);
+	  slide = H_GET_TEXT_SIZE(&headers); /* & in file of the data segment. */
+	  
+	  for (fragP = data_frag_root;
+	       fragP;
+	       fragP = fragP->fr_next)
+	      {
+		      fragP->fr_address += slide;
+	      }
+	  know( text_last_frag );
+	  text_last_frag->fr_next = data_frag_root;
+  } else {
+	  H_SET_DATA_SIZE(&headers,0);
+	  data_siz = 0;
+  }
+
+  bss_address_frag.fr_address = H_GET_TEXT_SIZE(&headers) + 
+                                  H_GET_DATA_SIZE(&headers);
+
+  H_SET_BSS_SIZE(&headers,local_bss_counter);
+	      
+  /*
+   *
+   * Crawl the symbol chain.
+   *
+   * For each symbol whose value depends on a frag, take the address of
+   * that frag and subsume it into the value of the symbol.
+   * After this, there is just one way to lookup a symbol value.
+   * Values are left in their final state for object file emission.
+   * We adjust the values of 'L' local symbols, even if we do
+   * not intend to emit them to the object file, because their values
+   * are needed for fix-ups.
+   *
+   * Unless we saw a -L flag, remove all symbols that begin with 'L'
+   * from the symbol chain.  (They are still pointed to by the fixes.)
+   *
+   * Count the remaining symbols.
+   * Assign a symbol number to each symbol.
+   * Count the number of string-table chars we will emit.
+   * Put this info into the headers as appropriate.
+   *
+   */
+  know(zero_address_frag.fr_address == 0);
+  string_byte_count = sizeof(string_byte_count);
+  
+  obj_crawl_symbol_chain(&headers);
+  
+  if (string_byte_count == sizeof(string_byte_count)) {
+	  string_byte_count = 0;
+  } /* if no strings, then no count. */
+  
+  H_SET_STRING_SIZE(&headers, string_byte_count);
+
+  /*
+   * Addresses of frags now reflect addresses we use in the object file.
+   * Symbol values are correct.
+   * Scan the frags, converting any ".org"s and ".align"s to ".fill"s.
+   * Also converting any machine-dependent frags using md_convert_frag();
+   */
+  subseg_change(SEG_TEXT, 0);
+
+  for (fragP = text_frag_root;  fragP;  fragP = fragP->fr_next) {
+	  switch (fragP->fr_type) {
+	  case rs_align:
+	  case rs_org:
+		  fragP->fr_type = rs_fill;
+		  know( fragP->fr_var == 1 );
+		  know( fragP->fr_next );
+		  fragP->fr_offset
+		      =     fragP->fr_next->fr_address
+			  -   fragP->fr_address
+			      - fragP->fr_fix;
+		  break;
+		  
+	  case rs_fill:
+		  break;
+		  
+	  case rs_machine_dependent:
+		  md_convert_frag (fragP);
+		  /*
+		   * After md_convert_frag, we make the frag into a ".space 0".
+		   * Md_convert_frag() should set up any fixSs and constants
+		   * required.
+		   */
+		  frag_wane (fragP);
+		  break;
+		  
+#ifndef WORKING_DOT_WORD
+	  case rs_broken_word: {
+		  struct broken_word *lie;
+		  extern md_short_jump_size;
+		  extern md_long_jump_size;
+		  
+		  if (fragP->fr_subtype) {
+			  fragP->fr_fix+=md_short_jump_size;
+			  for (lie=(struct broken_word *)(fragP->fr_symbol);lie && lie->dispfrag==fragP;lie=lie->next_broken_word)
+			      if (lie->added==1)
+				  fragP->fr_fix+=md_long_jump_size;
+		  }
+		  frag_wane(fragP);
+	  }
+		  break;
+#endif
+		  
+	  default:
+		  BAD_CASE( fragP->fr_type );
+		  break;
+	  } /* switch (fr_type) */
+  } /* for each frag. */
+
+#ifndef WORKING_DOT_WORD
+  {
+	  struct broken_word *lie;
+	  struct broken_word **prevP;
+	  
+	  prevP= &broken_words;
+	  for (lie=broken_words; lie; lie=lie->next_broken_word)
+	      if (!lie->added) {
+#ifdef TC_NS32K
+		      fix_new_ns32k(lie->frag,
+				    lie->word_goes_here - lie->frag->fr_literal,
+				    2,
+				    lie->add,
+				    lie->sub,
+				    lie->addnum,
+				    0, 0, 2, 0, 0);
+#else /* TC_NS32K */
+		      fix_new(	lie->frag,  lie->word_goes_here - lie->frag->fr_literal,
+			      2,  lie->add,
+			      lie->sub,  lie->addnum,
+			      0,  NO_RELOC);
+#endif /* TC_NS32K */
+		      /* md_number_to_chars(lie->word_goes_here,
+			 S_GET_VALUE(lie->add)
+			 + lie->addnum
+			 - S_GET_VALUE(lie->sub),
+			 2); */
+		      *prevP=lie->next_broken_word;
+	      } else
+		  prevP= &(lie->next_broken_word);
+	  
+	  for (lie=broken_words;lie;) {
+		  struct broken_word *untruth;
+		  char	*table_ptr;
+		  long	table_addr;
+		  long	from_addr,
+		  to_addr;
+		  int	n,
+		  m;
+		  
+		  extern md_short_jump_size;
+		  extern md_long_jump_size;
+		  
+		  fragP=lie->dispfrag;
+		  
+		  /* Find out how many broken_words go here */
+		  n=0;
+		  for (untruth=lie;untruth && untruth->dispfrag==fragP;untruth=untruth->next_broken_word)
+		      if (untruth->added==1)
+			  n++;
+		  
+		  table_ptr=lie->dispfrag->fr_opcode;
+		  table_addr=lie->dispfrag->fr_address+(table_ptr - lie->dispfrag->fr_literal);
+		  /* Create the jump around the long jumps */
+		  /* This is a short jump from table_ptr+0 to table_ptr+n*long_jump_size */
+		  from_addr=table_addr;
+		  to_addr = table_addr + md_short_jump_size + n * md_long_jump_size;
+		  md_create_short_jump(table_ptr, from_addr, to_addr, lie->dispfrag, lie->add);
+		  table_ptr+=md_short_jump_size;
+		  table_addr+=md_short_jump_size;
+		  
+		  for (m=0;lie && lie->dispfrag==fragP;m++,lie=lie->next_broken_word) {
+			  if (lie->added==2)
+			      continue;
+			  /* Patch the jump table */
+			  /* This is the offset from ??? to table_ptr+0 */
+			  to_addr =   table_addr
+			      - S_GET_VALUE(lie->sub);
+			  md_number_to_chars(lie->word_goes_here,to_addr,2);
+			  for (untruth=lie->next_broken_word;untruth && untruth->dispfrag==fragP;untruth=untruth->next_broken_word) {
+				  if (untruth->use_jump==lie)
+				      md_number_to_chars(untruth->word_goes_here,to_addr,2);
+			  }
+			  
+			  /* Install the long jump */
+			  /* this is a long jump from table_ptr+0 to the final target */
+			  from_addr=table_addr;
+			  to_addr=S_GET_VALUE(lie->add) + lie->addnum;
+			  md_create_long_jump(table_ptr,from_addr,to_addr,lie->dispfrag,lie->add);
+			  table_ptr+=md_long_jump_size;
+			  table_addr+=md_long_jump_size;
+		  }
+	  }
+  }
+#endif /* not WORKING_DOT_WORD */
+
+#ifndef	VMS
+  { /* not vms */
+	  /*
+	   * Scan every FixS performing fixups. We had to wait until now to do
+	   * this because md_convert_frag() may have made some fixSs.
+	   */
+	  H_SET_RELOCATION_SIZE(&headers,
+				md_reloc_size * fixup_segment(text_fix_root, SEG_TEXT),
+				md_reloc_size * fixup_segment(data_fix_root, SEG_DATA));
+	  
+ /* FIXME move this stuff into the pre-write-hook */
+	  H_SET_MAGIC_NUMBER(&headers, magic_number_for_object_file);
+	  H_SET_ENTRY_POINT(&headers,0);
+	  
+#ifdef EXEC_MACHINE_TYPE
+	  H_SET_MACHINE_TYPE(&headers,EXEC_MACHINE_TYPE);
+#endif
+#ifdef EXEC_VERSION
+	  H_SET_VERSION(&headers,EXEC_VERSION);
+#endif
+	  
+	  obj_pre_write_hook(&headers); /* extra coff stuff */
+	  
+	  if ((had_warnings() && flagseen['Z'])
+	      || had_errors() > 0) {
+		  if (flagseen['Z']) {
+			  as_warn("%d error%s, %d warning%s, generating bad object file.\n",
+				  had_errors(), had_errors() == 1 ? "" : "s",
+				  had_warnings(), had_warnings() == 1 ? "" : "s");
+		  } else {
+			  as_fatal("%d error%s, %d warning%s, no object file generated.\n",
+				  had_errors(), had_errors() == 1 ? "" : "s",
+				  had_warnings(), had_warnings() == 1 ? "" : "s");
+		  } /* on want output */
+	  } /* on error condition */
+
+	  object_file_size = H_GET_FILE_SIZE(&headers);
+	  next_object_file_charP = the_object_file = xmalloc(object_file_size);
+	  
+	  output_file_create(out_file_name);
+	  
+	  obj_header_append(&next_object_file_charP, &headers);
+	  
+	  /*
+	   * Emit code.
+	   */
+	  for (fragP = text_frag_root;  fragP;  fragP = fragP->fr_next) {
+		  register long		count;
+		  register char *		fill_literal;
+		  register long		fill_size;
+		  
+		  know( fragP->fr_type == rs_fill );
+		  append (& next_object_file_charP, fragP->fr_literal, (unsigned long)fragP->fr_fix);
+		  fill_literal= fragP->fr_literal + fragP->fr_fix;
+		  fill_size   = fragP->fr_var;
+		  know( fragP->fr_offset >= 0 );
+		  for (count = fragP->fr_offset;  count;  count --)
+		      append (& next_object_file_charP, fill_literal, (unsigned long)fill_size);
+	  } /* for each code frag. */
+	  
+	  /*
+	   * Emit relocations.
+	   */
+	  obj_emit_relocations(&next_object_file_charP, text_fix_root, (relax_addressT)0);
+	  
+#ifdef TC_I960
+	  /* Make addresses in data relocation directives relative to beginning of
+	   * first data fragment, not end of last text fragment:  alignment of the
+	   * start of the data segment may place a gap between the segments.
+	   */
+	  obj_emit_relocations(&next_object_file_charP, data_fix_root, data0_frchainP->frch_root->fr_address);
+#else /* TC_I960 */
+	  obj_emit_relocations(&next_object_file_charP, data_fix_root, text_last_frag->fr_address);
+#endif /* TC_I960 */
+	  
+	  /*
+	   * Emit line number entries.
+	   */
+	  OBJ_EMIT_LINENO(&next_object_file_charP, lineno_rootP, the_object_file);
+	  
+	  /*
+	   * Emit symbols.
+	   */
+	  obj_emit_symbols(&next_object_file_charP, symbol_rootP);
+	  
+	  /*
+	   * Emit strings.
+	   */
+	  
+	  if (string_byte_count > 0) {
+		  obj_emit_strings(&next_object_file_charP);
+	  } /* only if we have a string table */
+	  
+	  know(next_object_file_charP == the_object_file + object_file_size);
+	  /* Write the data to the file */
+	  output_file_append(the_object_file,object_file_size,out_file_name);
+	  
+#ifdef DONTDEF
+	  if (flagseen['G'])		/* GDB symbol file to be appended? */
+	      {
+		      gdb_emit (out_file_name);
+		      gdb_end ();
+	      }
+#endif /* DONTDEF */
+	  
+	  output_file_close(out_file_name);
+  } /* non vms output */
+#else	/* VMS */
+  /*
+   *	Now do the VMS-dependent part of writing the object file
+   */
+  VMS_write_object_file(text_siz, data_siz, text_frag_root, data_frag_root);
+#endif	/* VMS */
+} /* write_object_file() */
+
+/*
+ *			relax_segment()
+ *
+ * Now we have a segment, not a crowd of sub-segments, we can make fr_address
+ * values.
+ *
+ * Relax the frags.
+ *
+ * After this, all frags in this segment have addresses that are correct
+ * within the segment. Since segments live in different file addresses,
+ * these frag addresses may not be the same as final object-file addresses.
+ */
+#ifndef	VMS
+static
+#endif	/* not VMS */
+void relax_segment(segment_frag_root, segment_type)
+     struct frag *	segment_frag_root;
+     segT		segment_type; /* SEG_DATA or SEG_TEXT */
+{
+  register struct frag *	fragP;
+  register relax_addressT	address;
+  /* register relax_addressT	old_address; JF unused */
+  /* register relax_addressT	new_address; JF unused */
+
+  know( segment_type == SEG_DATA || segment_type == SEG_TEXT );
+
+  /* In case md_estimate_size_before_relax() wants to make fixSs. */
+  subseg_change(segment_type, 0);
+
+  /*
+   * For each frag in segment: count and store  (a 1st guess of) fr_address.
+   */
+  address = 0;
+  for ( fragP = segment_frag_root;   fragP;   fragP = fragP->fr_next )
+    {
+      fragP->fr_address = address;
+      address += fragP->fr_fix;
+      switch (fragP->fr_type)
+	{
+	case rs_fill:
+	  address += fragP->fr_offset * fragP->fr_var;
+	  break;
+
+	case rs_align:
+	  address += relax_align(address, fragP->fr_offset);
+	  break;
+
+	case rs_org:
+	  /*
+	   * Assume .org is nugatory. It will grow with 1st relax.
+	   */
+	  break;
+
+	case rs_machine_dependent:
+	  address += md_estimate_size_before_relax(fragP, segment_type);
+	  break;
+
+#ifndef WORKING_DOT_WORD
+		/* Broken words don't concern us yet */
+	case rs_broken_word:
+		break;
+#endif
+
+	default:
+	  BAD_CASE( fragP->fr_type );
+	  break;
+	}			/* switch(fr_type) */
+    }				/* for each frag in the segment */
+
+  /*
+   * Do relax().
+   */
+  {
+    register long	stretch; /* May be any size, 0 or negative. */
+				/* Cumulative number of addresses we have */
+				/* relaxed this pass. */
+				/* We may have relaxed more than one address. */
+    register long stretched;  /* Have we stretched on this pass? */
+				  /* This is 'cuz stretch may be zero, when,
+				     in fact some piece of code grew, and
+				     another shrank.  If a branch instruction
+				     doesn't fit anymore, we could be scrod */
+
+    do
+      {
+	stretch = stretched = 0;
+	for (fragP = segment_frag_root;  fragP;  fragP = fragP->fr_next)
+	  {
+	    register long growth = 0;
+	    register unsigned long was_address;
+	    /* register long var; */
+	    register long offset;
+	    register symbolS *symbolP;
+	    register long target;
+	    register long after;
+	    register long aim;
+
+	    was_address = fragP->fr_address;
+	    address = fragP->fr_address += stretch;
+	    symbolP = fragP->fr_symbol;
+	    offset = fragP->fr_offset;
+	    /* var = fragP->fr_var; */
+	    switch (fragP->fr_type)
+	      {
+	      case rs_fill:	/* .fill never relaxes. */
+		growth = 0;
+		break;
+
+#ifndef WORKING_DOT_WORD
+		/* JF:  This is RMS's idea.  I do *NOT* want to be blamed
+		   for it I do not want to write it.  I do not want to have
+		   anything to do with it.  This is not the proper way to
+		   implement this misfeature. */
+	      case rs_broken_word:
+	        {
+		struct broken_word *lie;
+		struct broken_word *untruth;
+		extern int md_short_jump_size;
+		extern int md_long_jump_size;
+
+			/* Yes this is ugly (storing the broken_word pointer
+			   in the symbol slot).  Still, this whole chunk of
+			   code is ugly, and I don't feel like doing anything
+			   about it.  Think of it as stubbornness in action */
+		growth=0;
+	        for (lie=(struct broken_word *)(fragP->fr_symbol);
+		    lie && lie->dispfrag==fragP;
+		    lie=lie->next_broken_word) {
+
+			if (lie->added)
+				continue;
+			offset=  lie->add->sy_frag->fr_address+ S_GET_VALUE(lie->add) + lie->addnum -
+				(lie->sub->sy_frag->fr_address+ S_GET_VALUE(lie->sub));
+			if (offset<=-32768 || offset>=32767) {
+				if (flagseen['k'])
+					as_warn(".word %s-%s+%ld didn't fit",
+						S_GET_NAME(lie->add),
+						S_GET_NAME(lie->sub),
+						lie->addnum);
+				lie->added=1;
+				if (fragP->fr_subtype==0) {
+					fragP->fr_subtype++;
+					growth+=md_short_jump_size;
+				}
+				for (untruth=lie->next_broken_word;untruth && untruth->dispfrag==lie->dispfrag;untruth=untruth->next_broken_word)
+					if ((untruth->add->sy_frag == lie->add->sy_frag)
+					    && S_GET_VALUE(untruth->add) == S_GET_VALUE(lie->add)) {
+						untruth->added=2;
+						untruth->use_jump=lie;
+					}
+				growth+=md_long_jump_size;
+			}
+		    }
+		}
+		break;
+#endif
+	      case rs_align:
+		growth = relax_align ((relax_addressT)(address + fragP->fr_fix), offset)
+		  - relax_align ((relax_addressT)(was_address +  fragP->fr_fix), offset);
+		break;
+
+	      case rs_org:
+		target = offset;
+		if (symbolP)
+		  {
+		    know((S_GET_SEGMENT(symbolP) == SEG_ABSOLUTE) ||
+			 (S_GET_SEGMENT(symbolP) == SEG_DATA) ||
+			 (S_GET_SEGMENT(symbolP) == SEG_TEXT));
+		    know(symbolP->sy_frag);
+		    know(!(S_GET_SEGMENT(symbolP) == SEG_ABSOLUTE) || 
+			 symbolP->sy_frag==&zero_address_frag );
+		    target +=
+		      S_GET_VALUE(symbolP)
+			+ symbolP->sy_frag->fr_address;
+		  }
+		know( fragP->fr_next );
+		after = fragP->fr_next->fr_address;
+		growth = ((target - after ) > 0) ? (target - after) : 0;
+				/* Growth may be -ve, but variable part */
+				/* of frag cannot have < 0 chars. */
+				/* That is, we can't .org backwards. */
+
+		growth -= stretch;	/* This is an absolute growth factor */
+		break;
+
+	      case rs_machine_dependent:
+		{
+		  register const relax_typeS *	this_type;
+		  register const relax_typeS *	start_type;
+		  register relax_substateT	next_state;
+		  register relax_substateT	this_state;
+
+		  start_type = this_type
+		    = md_relax_table + (this_state = fragP->fr_subtype);
+		target = offset;
+		if (symbolP)
+		  {
+		    know((S_GET_SEGMENT(symbolP) == SEG_ABSOLUTE) ||
+			 (S_GET_SEGMENT(symbolP) == SEG_DATA) ||
+			 (S_GET_SEGMENT(symbolP) == SEG_TEXT));
+		    know(symbolP->sy_frag);
+		    know(!(S_GET_SEGMENT(symbolP) == SEG_ABSOLUTE) || 
+			 symbolP->sy_frag==&zero_address_frag );
+		    target +=
+		      S_GET_VALUE(symbolP)
+			+ symbolP->sy_frag->fr_address;
+
+			/* If frag has yet to be reached on this pass,
+			   assume it will move by STRETCH just as we did.
+			   If this is not so, it will be because some frag
+			   between grows, and that will force another pass.  */
+
+			   	/* JF was just address */
+				/* JF also added is_dnrange hack */
+				/* There's gotta be a better/faster/etc way
+				   to do this. . . */
+			/* gnu@cygnus.com:  I changed this from > to >=
+			   because I ran into a zero-length frag (fr_fix=0)
+			   which was created when the obstack needed a new
+			   chunk JUST AFTER the opcode of a branch.  Since
+			   fr_fix is zero, fr_address of this frag is the same
+			   as fr_address of the next frag.  This
+			   zero-length frag was variable and jumped to .+2
+			   (in the next frag), but since the > comparison
+			   below failed (the two were =, not >), "stretch"
+			   was not added to the target.  Stretch was 178, so
+			   the offset appeared to be .-176 instead, which did
+			   not fit into a byte branch, so the assembler
+			   relaxed the branch to a word.  This didn't compare
+			   with what happened when the same source file was
+			   assembled on other machines, which is how I found it.
+			   You might want to think about what other places have
+			   trouble with zero length frags... */
+
+		    if (symbolP->sy_frag->fr_address >= was_address && is_dnrange(fragP,symbolP->sy_frag))
+		      target += stretch;
+
+		  }
+		  aim = target - address - fragP->fr_fix;
+		  /* The displacement is affected by the instruction size
+		   * for the 32k architecture. I think we ought to be able
+		   * to add fragP->fr_pcrel_adjust in all cases (it should be
+		   * zero if not used), but just in case it breaks something
+		   * else we'll put this inside #ifdef NS32K ... #endif
+		   */
+#ifdef TC_NS32K
+		  aim += fragP->fr_pcrel_adjust;
+#endif /* TC_NS32K */
+
+		  if (aim < 0)
+		    {
+		      /* Look backwards. */
+		      for (next_state = this_type->rlx_more;  next_state;  )
+			{
+			  if (aim >= this_type->rlx_backward)
+			      next_state = 0;
+			  else
+			    {	/* Grow to next state. */
+			      this_type = md_relax_table + (this_state = next_state);
+			      next_state = this_type->rlx_more;
+			    }
+			}
+		    }
+		  else
+		    {
+#ifdef DONTDEF
+/* JF these next few lines of code are for the mc68020 which can't handle short
+   offsets of zero in branch instructions.  What a kludge! */
+ if (aim==0 && this_state==(1<<2+0)) {	/* FOO hard encoded from m.c */
+	aim=this_type->rlx_forward+1;	/* Force relaxation into word mode */
+ }
+#endif
+/* JF end of 68020 code */
+		      /* Look forwards. */
+		      for (next_state = this_type->rlx_more;  next_state;  )
+			{
+			  if (aim <= this_type->rlx_forward)
+			      next_state = 0;
+			  else
+			    {	/* Grow to next state. */
+			      this_type = md_relax_table + (this_state = next_state);
+			      next_state = this_type->rlx_more;
+			    }
+			}
+		    }
+		  if ((growth = this_type->rlx_length - start_type->rlx_length) != 0)
+		      fragP->fr_subtype = this_state;
+		}
+		break;
+
+	      default:
+		BAD_CASE( fragP->fr_type );
+		break;
+	      }
+	    if (growth) {
+	      stretch += growth;
+	      stretched++;
+	    }
+	  }			/* For each frag in the segment. */
+      } while (stretched);	/* Until nothing further to relax. */
+  }
+
+  /*
+   * We now have valid fr_address'es for each frag.
+   */
+
+  /*
+   * All fr_address's are correct, relative to their own segment.
+   * We have made all the fixS we will ever make.
+   */
+}				/* relax_segment() */
+
+/*
+ * Relax_align. Advance location counter to next address that has 'alignment'
+ * lowest order bits all 0s.
+ */
+
+ /* How many addresses does the .align take? */
+static relax_addressT relax_align(address, alignment)
+register relax_addressT address; /* Address now. */
+register long alignment; /* Alignment (binary). */
+{
+  relax_addressT	mask;
+  relax_addressT	new_address;
+
+  mask = ~ ( (~0) << alignment );
+  new_address = (address + mask) & (~ mask);
+  return (new_address - address);
+} /* relax_align() */
+
+/* fixup_segment()
+
+   Go through all the fixS's in a segment and see which ones can be
+   handled now.  (These consist of fixS where we have since discovered
+   the value of a symbol, or the address of the frag involved.)
+   For each one, call md_apply_fix to put the fix into the frag data.
+
+   Result is a count of how many relocation structs will be needed to
+   handle the remaining fixS's that we couldn't completely handle here.
+   These will be output later by emit_relocations().  */
+
+static long fixup_segment(fixP, this_segment_type)
+register fixS *	fixP;
+segT		this_segment_type; /* N_TYPE bits for segment. */
+{
+	register long seg_reloc_count;
+	register symbolS *add_symbolP;
+	register symbolS *sub_symbolP;
+	register long add_number;
+	register int size;
+	register char *place;
+	register long where;
+	register char pcrel;
+	register fragS *fragP;
+	register segT add_symbol_segment = SEG_ABSOLUTE;
+	fixS *topP = fixP;
+	
+	
+	seg_reloc_count = 0;
+	
+	for ( ;  fixP;  fixP = fixP->fx_next) {
+		fragP       = fixP->fx_frag;
+		know(fragP);
+		where	  = fixP->fx_where;
+		place       = fragP->fr_literal + where;
+		size	  = fixP->fx_size;
+		add_symbolP = fixP->fx_addsy;
+#ifdef TC_I960
+		if (fixP->fx_callj && TC_S_IS_CALLNAME(add_symbolP)) {
+			/* Relocation should be done via the
+			   associated 'bal' entry point
+			   symbol. */
+
+			if (!TC_S_IS_BALNAME(tc_get_bal_of_call(add_symbolP))) {
+				as_bad("No 'bal' entry point for leafproc %s",
+					S_GET_NAME(add_symbolP));
+				continue;
+			}
+			fixP->fx_addsy = add_symbolP = tc_get_bal_of_call(add_symbolP);
+		}	/* callj relocation */
+#endif
+		sub_symbolP = fixP->fx_subsy;
+		add_number  = fixP->fx_offset;
+		pcrel	  = fixP->fx_pcrel;
+
+		if (add_symbolP) {
+			add_symbol_segment = S_GET_SEGMENT(add_symbolP);
+		}	/* if there is an addend */
+		
+		if (sub_symbolP) {
+			if (!add_symbolP) {
+				/* Its just -sym */
+				if (S_GET_SEGMENT(sub_symbolP) != SEG_ABSOLUTE) {
+					as_bad("Negative of non-absolute symbol %s", S_GET_NAME(sub_symbolP));
+				} /* not absolute */
+				
+				add_number -= S_GET_VALUE(sub_symbolP);
+				
+				/* if sub_symbol is in the same segment that add_symbol
+				   and add_symbol is either in DATA, TEXT, BSS or ABSOLUTE */
+			} else if ((S_GET_SEGMENT(sub_symbolP) == add_symbol_segment)
+				 && ((add_symbol_segment == SEG_DATA)
+				     || (add_symbol_segment == SEG_TEXT)
+				     || (add_symbol_segment == SEG_BSS)
+				     || (add_symbol_segment == SEG_ABSOLUTE))) {
+				/* Difference of 2 symbols from same segment. */
+				/* Can't make difference of 2 undefineds: 'value' means */
+				/* something different for N_UNDF. */
+#ifdef TC_I960
+				/* Makes no sense to use the difference of 2 arbitrary symbols
+				 * as the target of a call instruction.
+				 */
+				if (fixP->fx_callj) {
+					as_bad("callj to difference of 2 symbols");
+				}
+#endif	/* TC_I960 */
+				add_number += S_GET_VALUE(add_symbolP) - 
+				    S_GET_VALUE(sub_symbolP);
+				
+				add_symbolP = NULL;
+				fixP->fx_addsy = NULL;
+			} else {
+				/* Different segments in subtraction. */
+				know(!(S_IS_EXTERNAL(sub_symbolP) && (S_GET_SEGMENT(sub_symbolP) == SEG_ABSOLUTE)));
+				
+				if ((S_GET_SEGMENT(sub_symbolP) == SEG_ABSOLUTE)) {
+					add_number -= S_GET_VALUE(sub_symbolP);
+				} else {
+					as_bad("Can't emit reloc {- %s-seg symbol \"%s\"} @ file address %d.",
+						segment_name(S_GET_SEGMENT(sub_symbolP)),
+						S_GET_NAME(sub_symbolP), fragP->fr_address + where);
+				} /* if absolute */
+			}
+		} /* if sub_symbolP */
+
+		if (add_symbolP) {
+			if (add_symbol_segment == this_segment_type && pcrel) {
+				/*
+				 * This fixup was made when the symbol's segment was
+				 * SEG_UNKNOWN, but it is now in the local segment.
+				 * So we know how to do the address without relocation.
+				 */
+#ifdef TC_I960
+				/* reloc_callj() may replace a 'call' with a 'calls' or a 'bal',
+				 * in which cases it modifies *fixP as appropriate.  In the case
+				 * of a 'calls', no further work is required, and *fixP has been
+				 * set up to make the rest of the code below a no-op.
+				 */
+				reloc_callj(fixP);
+#endif /* TC_I960 */
+				
+				add_number += S_GET_VALUE(add_symbolP);
+				add_number -= md_pcrel_from (fixP);
+				pcrel = 0;	/* Lie. Don't want further pcrel processing. */
+				fixP->fx_addsy = NULL; /* No relocations please. */
+			} else {
+				switch (add_symbol_segment) {
+				case SEG_ABSOLUTE:
+#ifdef TC_I960
+					reloc_callj(fixP); /* See comment about reloc_callj() above*/
+#endif /* TC_I960 */
+					add_number += S_GET_VALUE(add_symbolP);
+					fixP->fx_addsy = NULL;
+					add_symbolP = NULL;
+					break;
+					
+				case SEG_BSS:
+				case SEG_DATA:
+				case SEG_TEXT:
+					seg_reloc_count ++;
+					add_number += S_GET_VALUE(add_symbolP);
+					break;
+					
+				case SEG_UNKNOWN:
+#ifdef TC_I960
+					if ((int)fixP->fx_bit_fixP == 13) {
+						/* This is a COBR instruction.  They have only a
+						 * 13-bit displacement and are only to be used
+						 * for local branches: flag as error, don't generate
+						 * relocation.
+						 */
+						as_bad("can't use COBR format with external label");
+						fixP->fx_addsy = NULL;	/* No relocations please. */
+						continue;
+					} /* COBR */
+#endif /* TC_I960 */
+ /* FIXME-SOON: I think this is trash, but I'm not sure.  xoxorich. */
+#ifdef comment
+#ifdef OBJ_COFF
+					if (S_IS_COMMON(add_symbolP))
+					    add_number += S_GET_VALUE(add_symbolP);
+#endif /* OBJ_COFF */
+#endif /* comment */
+		
+					++seg_reloc_count;
+					break;
+					
+				default:
+					BAD_CASE(add_symbol_segment);
+					break;
+				} /* switch on symbol seg */
+			} /* if not in local seg */
+		} /* if there was a + symbol */
+
+		if (pcrel) {
+			add_number -= md_pcrel_from(fixP);
+			if (add_symbolP == 0) {
+				fixP->fx_addsy = & abs_symbol;
+				++seg_reloc_count;
+			} /* if there's an add_symbol */
+		} /* if pcrel */
+		
+		if (!fixP->fx_bit_fixP) {
+			if ((size==1 &&
+			     (add_number& ~0xFF)   && (add_number&~0xFF!=(-1&~0xFF))) ||
+			    (size==2 &&
+			     (add_number& ~0xFFFF) && (add_number&~0xFFFF!=(-1&~0xFFFF)))) {
+				as_bad("Value of %d too large for field of %d bytes at 0x%x",
+					add_number, size, fragP->fr_address + where);
+			} /* generic error checking */
+		} /* not a bit fix */
+		
+		md_apply_fix(fixP, add_number);
+	} /* For each fixS in this segment. */
+	
+#ifdef OBJ_COFF
+#ifdef TC_I960
+	/* two relocs per callj under coff. */
+	for (fixP = topP; fixP; fixP = fixP->fx_next) {
+		if (fixP->fx_callj && fixP->fx_addsy != 0) {
+			++seg_reloc_count;
+		} /* if callj and not already fixed. */
+	} /* for each fix */
+#endif /* TC_I960 */
+#endif /* OBJ_COFF */
+	return(seg_reloc_count);
+} /* fixup_segment() */
+
+
+static int is_dnrange(f1,f2)
+struct frag *f1;
+struct frag *f2;
+{
+	while (f1) {
+		if (f1->fr_next==f2)
+			return 1;
+		f1=f1->fr_next;
+	}
+	return 0;
+} /* is_dnrange() */
+
+/* Append a string onto another string, bumping the pointer along.  */
+void
+append (charPP, fromP, length)
+char	**charPP;
+char	*fromP;
+unsigned long length;
+{
+	if (length) {		/* Don't trust bcopy() of 0 chars. */
+		bcopy(fromP, *charPP, (int) length);
+		*charPP += length;
+	}
+}
+
+int section_alignment[SEG_MAXIMUM_ORDINAL];
+
+/*
+ * This routine records the largest alignment seen for each segment.
+ * If the beginning of the segment is aligned on the worst-case
+ * boundary, all of the other alignments within it will work.  At
+ * least one object format really uses this info.
+ */
+void record_alignment(seg, align)
+segT seg;	/* Segment to which alignment pertains */
+int align;	/* Alignment, as a power of 2
+		 *	(e.g., 1 => 2-byte boundary, 2 => 4-byte boundary, etc.)
+		 */
+{
+	
+	if ( align > section_alignment[(int) seg] ){
+		section_alignment[(int) seg] = align;
+	} /* if highest yet */
+	
+	return;
+} /* record_alignment() */
+
+/*
+ * Local Variables:
+ * comment-column: 0
+ * fill-column: 131
+ * End:
+ */
+
+/* end of write.c */