[binutils.git] / gas / config / obj-bout.c

/* b.out object file format
   Copyright 1989, 1990, 1991, 1992, 1993, 1994, 1996, 2000, 2001, 2002
   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 "obstack.h"

/* In: segT   Out: N_TYPE bits  */
const short seg_N_TYPE[] =
{
  N_ABS,
  N_TEXT,
  N_DATA,
  N_BSS,
  N_UNDF,			/* unknown  */
  N_UNDF,			/* error  */
  N_UNDF,			/* expression  */
  N_UNDF,			/* debug  */
  N_UNDF,			/* ntv  */
  N_UNDF,			/* ptv  */
  N_REGISTER,			/* register  */
};

const segT N_TYPE_seg[N_TYPE + 2] =
{				/* N_TYPE == 0x1E = 32-2  */
  SEG_UNKNOWN,			/* N_UNDF == 0  */
  SEG_GOOF,
  SEG_ABSOLUTE,			/* N_ABS == 2  */
  SEG_GOOF,
  SEG_TEXT,			/* N_TEXT == 4  */
  SEG_GOOF,
  SEG_DATA,			/* N_DATA == 6  */
  SEG_GOOF,
  SEG_BSS,			/* N_BSS == 8  */
  SEG_GOOF,
  SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF,
  SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF,
  SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF,
  SEG_REGISTER,			/* dummy N_REGISTER for regs = 30  */
  SEG_GOOF,
};

static void obj_bout_line PARAMS ((int));

const pseudo_typeS obj_pseudo_table[] =
{
  {"line", obj_bout_line, 0},	/* Source code line number.  */

/* coff debugging directives.  Currently ignored silently.  */
  {"def", s_ignore, 0},
  {"dim", s_ignore, 0},
  {"endef", s_ignore, 0},
  {"ln", s_ignore, 0},
  {"scl", s_ignore, 0},
  {"size", s_ignore, 0},
  {"tag", s_ignore, 0},
  {"type", s_ignore, 0},
  {"val", s_ignore, 0},

/* other stuff we don't handle */
  {"ABORT", s_ignore, 0},
  {"ident", s_ignore, 0},

  {NULL, NULL, 0}		/* End sentinel.  */
};

/* Relocation.  */

/* Crawl along a fixS chain. Emit the segment's relocations.  */

void
obj_emit_relocations (where, fixP, segment_address_in_file)
     char **where;
     fixS *fixP;		/* Fixup chain for this segment.  */
     relax_addressT segment_address_in_file;
{
  for (; fixP; fixP = fixP->fx_next)
    {
      if (fixP->fx_done == 0
	  || fixP->fx_r_type != NO_RELOC)
	{
	  symbolS *sym;

	  sym = fixP->fx_addsy;
	  while (sym->sy_value.X_op == O_symbol
		 && (! S_IS_DEFINED (sym) || S_IS_COMMON (sym)))
	    sym = sym->sy_value.X_add_symbol;
	  fixP->fx_addsy = sym;

	  tc_bout_fix_to_chars (*where, fixP, segment_address_in_file);
	  *where += sizeof (struct relocation_info);
	}			/* if there's a symbol  */
    }				/* for each fixup  */
}

/* Aout file generation & utilities .  */

/* Convert a lvalue to machine dependent data.  */

void
obj_header_append (where, headers)
     char **where;
     object_headers *headers;
{
  /* Always leave in host byte order.  */

  headers->header.a_talign = section_alignment[SEG_TEXT];

  /* Force to at least 2.  */
  if (headers->header.a_talign < 2)
    {
      headers->header.a_talign = 2;
    }

  headers->header.a_dalign = section_alignment[SEG_DATA];
  headers->header.a_balign = section_alignment[SEG_BSS];

  headers->header.a_tload = 0;
  headers->header.a_dload =
    md_section_align (SEG_DATA, H_GET_TEXT_SIZE (headers));

  headers->header.a_relaxable = linkrelax;

#ifdef CROSS_COMPILE
  md_number_to_chars (*where, headers->header.a_magic, sizeof (headers->header.a_magic));
  *where += sizeof (headers->header.a_magic);
  md_number_to_chars (*where, headers->header.a_text, sizeof (headers->header.a_text));
  *where += sizeof (headers->header.a_text);
  md_number_to_chars (*where, headers->header.a_data, sizeof (headers->header.a_data));
  *where += sizeof (headers->header.a_data);
  md_number_to_chars (*where, headers->header.a_bss, sizeof (headers->header.a_bss));
  *where += sizeof (headers->header.a_bss);
  md_number_to_chars (*where, headers->header.a_syms, sizeof (headers->header.a_syms));
  *where += sizeof (headers->header.a_syms);
  md_number_to_chars (*where, headers->header.a_entry, sizeof (headers->header.a_entry));
  *where += sizeof (headers->header.a_entry);
  md_number_to_chars (*where, headers->header.a_trsize, sizeof (headers->header.a_trsize));
  *where += sizeof (headers->header.a_trsize);
  md_number_to_chars (*where, headers->header.a_drsize, sizeof (headers->header.a_drsize));
  *where += sizeof (headers->header.a_drsize);
  md_number_to_chars (*where, headers->header.a_tload, sizeof (headers->header.a_tload));
  *where += sizeof (headers->header.a_tload);
  md_number_to_chars (*where, headers->header.a_dload, sizeof (headers->header.a_dload));
  *where += sizeof (headers->header.a_dload);
  md_number_to_chars (*where, headers->header.a_talign, sizeof (headers->header.a_talign));
  *where += sizeof (headers->header.a_talign);
  md_number_to_chars (*where, headers->header.a_dalign, sizeof (headers->header.a_dalign));
  *where += sizeof (headers->header.a_dalign);
  md_number_to_chars (*where, headers->header.a_balign, sizeof (headers->header.a_balign));
  *where += sizeof (headers->header.a_balign);
  md_number_to_chars (*where, headers->header.a_relaxable, sizeof (headers->header.a_relaxable));
  *where += sizeof (headers->header.a_relaxable);
#else /* ! CROSS_COMPILE */
  append (where, (char *) &headers->header, sizeof (headers->header));
#endif /* ! CROSS_COMPILE */
}

void
obj_symbol_to_chars (where, symbolP)
     char **where;
     symbolS *symbolP;
{
  md_number_to_chars ((char *) &(S_GET_OFFSET (symbolP)),
		      S_GET_OFFSET (symbolP),
		      sizeof (S_GET_OFFSET (symbolP)));

  md_number_to_chars ((char *) &(S_GET_DESC (symbolP)),
		      S_GET_DESC (symbolP),
		      sizeof (S_GET_DESC (symbolP)));

  md_number_to_chars ((char *) &symbolP->sy_symbol.n_value,
		      S_GET_VALUE (symbolP),
		      sizeof (symbolP->sy_symbol.n_value));

  append (where, (char *) &symbolP->sy_symbol, sizeof (obj_symbol_type));
}

void
obj_emit_symbols (where, symbol_rootP)
     char **where;
     symbolS *symbol_rootP;
{
  symbolS *symbolP;

  /* Emit all symbols left in the symbol chain.  */
  for (symbolP = symbol_rootP; symbolP; symbolP = symbol_next (symbolP))
    {
      /* Used to save the offset of the name.  It is used to point to
	 the string in memory but must be a file offset.  */
      char *temp;

      temp = S_GET_NAME (symbolP);
      S_SET_OFFSET (symbolP, symbolP->sy_name_offset);

      /* Any symbol still undefined and is not a dbg symbol is made N_EXT.  */
      if (!S_IS_DEBUG (symbolP) && !S_IS_DEFINED (symbolP))
	S_SET_EXTERNAL (symbolP);

      obj_symbol_to_chars (where, symbolP);
      S_SET_NAME (symbolP, temp);
    }
}

void
obj_symbol_new_hook (symbolP)
     symbolS *symbolP;
{
  S_SET_OTHER (symbolP, 0);
  S_SET_DESC (symbolP, 0);
}

static void
obj_bout_line (ignore)
     int ignore ATTRIBUTE_UNUSED;
{
  /* Assume delimiter is part of expression.  */
  /* BSD4.2 as fails with delightful bug, so we are not being
     incompatible here.  */
  new_logical_line ((char *) NULL, (int) (get_absolute_expression ()));
  demand_empty_rest_of_line ();
}

void
obj_read_begin_hook ()
{
}

void
obj_crawl_symbol_chain (headers)
     object_headers *headers;
{
  symbolS **symbolPP;
  symbolS *symbolP;
  int symbol_number = 0;

  tc_crawl_symbol_chain (headers);

  symbolPP = &symbol_rootP;	/* -> last symbol chain link.  */
  while ((symbolP = *symbolPP) != NULL)
    {
      if (flag_readonly_data_in_text && (S_GET_SEGMENT (symbolP) == SEG_DATA))
	{
	  S_SET_SEGMENT (symbolP, SEG_TEXT);
	}			/* if pusing data into text  */

      resolve_symbol_value (symbolP);

      /* Skip symbols which were equated to undefined or common
	 symbols.  */
      if (symbolP->sy_value.X_op == O_symbol
	  && (! S_IS_DEFINED (symbolP) || S_IS_COMMON (symbolP)))
	{
	  *symbolPP = symbol_next (symbolP);
	  continue;
	}

      /* OK, here is how we decide which symbols go out into the
	 brave new symtab.  Symbols that do are:

	 * symbols with no name (stabd's?)
	 * symbols with debug info in their N_TYPE

	 Symbols that don't are:
	 * symbols that are registers
	 * symbols with \1 as their 3rd character (numeric labels)
	 * "local labels" as defined by S_LOCAL_NAME(name)
	 if the -L switch was passed to gas.

	 All other symbols are output.  We complain if a deleted
	 symbol was marked external.  */

      if (1
	  && !S_IS_REGISTER (symbolP)
	  && (!S_GET_NAME (symbolP)
	      || S_IS_DEBUG (symbolP)
#ifdef TC_I960
      /* FIXME-SOON this ifdef seems highly dubious to me.  xoxorich.  */
	      || !S_IS_DEFINED (symbolP)
	      || S_IS_EXTERNAL (symbolP)
#endif /* TC_I960 */
	      || (S_GET_NAME (symbolP)[0] != '\001'
		  && (flag_keep_locals || !S_LOCAL_NAME (symbolP)))))
	{
	  symbolP->sy_number = symbol_number++;

	  /* The + 1 after strlen account for the \0 at the end of
	     each string.  */
	  if (!S_IS_STABD (symbolP))
	    {
	      /* Ordinary case.  */
	      symbolP->sy_name_offset = string_byte_count;
	      string_byte_count += strlen (S_GET_NAME (symbolP)) + 1;
	    }
	  else			/* .Stabd case.  */
	    symbolP->sy_name_offset = 0;
	  symbolPP = &(symbolP->sy_next);
	}
      else
	{
	  if (S_IS_EXTERNAL (symbolP) || !S_IS_DEFINED (symbolP))
	    {
	      as_bad (_("Local symbol %s never defined"),
		      S_GET_NAME (symbolP));
	    }			/* Oops.  */

	  /* Unhook it from the chain.  */
	  *symbolPP = symbol_next (symbolP);
	}			/* if this symbol should be in the output  */
    }				/* for each symbol  */

  H_SET_SYMBOL_TABLE_SIZE (headers, symbol_number);
}

/* Find strings by crawling along symbol table chain.  */

void
obj_emit_strings (where)
     char **where;
{
  symbolS *symbolP;

#ifdef CROSS_COMPILE
  /* Gotta do md_ byte-ordering stuff for string_byte_count first - KWK */
  md_number_to_chars (*where, string_byte_count, sizeof (string_byte_count));
  *where += sizeof (string_byte_count);
#else /* CROSS_COMPILE */
  append (where, (char *) &string_byte_count,
	  (unsigned long) sizeof (string_byte_count));
#endif /* CROSS_COMPILE */

  for (symbolP = symbol_rootP; symbolP; symbolP = symbol_next (symbolP))
    {
      if (S_GET_NAME (symbolP))
	append (where, S_GET_NAME (symbolP),
		(unsigned long) (strlen (S_GET_NAME (symbolP)) + 1));
    }				/* Walk symbol chain.  */
}
Commit	Line	Data
252b5132	1	/* b.out object file format
70658493	2	Copyright 1989, 1990, 1991, 1992, 1993, 1994, 1996, 2000, 2001, 2002
252b5132 RH	3	Free Software Foundation, Inc.
	4
	5	This file is part of GAS, the GNU Assembler.
	6
	7	GAS is free software; you can redistribute it and/or modify
	8	it under the terms of the GNU General Public License as
	9	published by the Free Software Foundation; either version 2,
	10	or (at your option) any later version.
	11
	12	GAS is distributed in the hope that it will be useful, but
	13	WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
	15	the GNU General Public License for more details.
	16
8fc2b121 ILT	17	You should have received a copy of the GNU General Public License
	18	along with GAS; see the file COPYING. If not, write to the Free
	19	Software Foundation, 59 Temple Place - Suite 330, Boston, MA
351aa9f6	20	02111-1307, USA. */
252b5132 RH	21
	22	#include "as.h"
	23	#include "obstack.h"
351aa9f6 KH	24
	25	/* In: segT Out: N_TYPE bits */
	26	const short seg_N_TYPE[] =
252b5132 RH	27	{
	28	N_ABS,
	29	N_TEXT,
	30	N_DATA,
	31	N_BSS,
351aa9f6 KH	32	N_UNDF, /* unknown */
	33	N_UNDF, /* error */
	34	N_UNDF, /* expression */
	35	N_UNDF, /* debug */
	36	N_UNDF, /* ntv */
	37	N_UNDF, /* ptv */
	38	N_REGISTER, /* register */
252b5132 RH	39	};
	40
	41	const segT N_TYPE_seg[N_TYPE + 2] =
351aa9f6 KH	42	{ /* N_TYPE == 0x1E = 32-2 */
351aa9f6 KH	43	SEG_UNKNOWN, /* N_UNDF == 0 */
252b5132	44	SEG_GOOF,
351aa9f6	45	SEG_ABSOLUTE, /* N_ABS == 2 */
252b5132	46	SEG_GOOF,
351aa9f6	47	SEG_TEXT, /* N_TEXT == 4 */
252b5132	48	SEG_GOOF,
351aa9f6	49	SEG_DATA, /* N_DATA == 6 */
252b5132	50	SEG_GOOF,
351aa9f6	51	SEG_BSS, /* N_BSS == 8 */
252b5132 RH	52	SEG_GOOF,
	53	SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF,
	54	SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF,
	55	SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF,
351aa9f6	56	SEG_REGISTER, /* dummy N_REGISTER for regs = 30 */
252b5132 RH	57	SEG_GOOF,
	58	};
	59
	60	static void obj_bout_line PARAMS ((int));
	61
	62	const pseudo_typeS obj_pseudo_table[] =
	63	{
351aa9f6	64	{"line", obj_bout_line, 0}, /* Source code line number. */
252b5132	65
351aa9f6	66	/* coff debugging directives. Currently ignored silently. */
252b5132 RH	67	{"def", s_ignore, 0},
	68	{"dim", s_ignore, 0},
	69	{"endef", s_ignore, 0},
	70	{"ln", s_ignore, 0},
	71	{"scl", s_ignore, 0},
	72	{"size", s_ignore, 0},
	73	{"tag", s_ignore, 0},
	74	{"type", s_ignore, 0},
	75	{"val", s_ignore, 0},
	76
	77	/* other stuff we don't handle */
	78	{"ABORT", s_ignore, 0},
	79	{"ident", s_ignore, 0},
	80
70658493	81	{NULL, NULL, 0} /* End sentinel. */
351aa9f6 KH	82	};
	83
	84	/* Relocation. */
252b5132	85
351aa9f6	86	/* Crawl along a fixS chain. Emit the segment's relocations. */
252b5132	87
252b5132 RH	88	void
	89	obj_emit_relocations (where, fixP, segment_address_in_file)
	90	char **where;
351aa9f6	91	fixS fixP; / Fixup chain for this segment. */
252b5132 RH	92	relax_addressT segment_address_in_file;
	93	{
	94	for (; fixP; fixP = fixP->fx_next)
	95	{
	96	if (fixP->fx_done == 0
	97	\|\| fixP->fx_r_type != NO_RELOC)
	98	{
	99	symbolS *sym;
	100
	101	sym = fixP->fx_addsy;
	102	while (sym->sy_value.X_op == O_symbol
	103	&& (! S_IS_DEFINED (sym) \|\| S_IS_COMMON (sym)))
	104	sym = sym->sy_value.X_add_symbol;
	105	fixP->fx_addsy = sym;
	106
	107	tc_bout_fix_to_chars (*where, fixP, segment_address_in_file);
	108	*where += sizeof (struct relocation_info);
351aa9f6 KH	109	} /* if there's a symbol */
	110	} /* for each fixup */
	111	}
252b5132	112
dcd619be	113	/* Aout file generation & utilities . */
252b5132	114
351aa9f6	115	/* Convert a lvalue to machine dependent data. */
252b5132	116
252b5132 RH	117	void
	118	obj_header_append (where, headers)
	119	char **where;
	120	object_headers *headers;
	121	{
351aa9f6	122	/* Always leave in host byte order. */
252b5132 RH	123
	124	headers->header.a_talign = section_alignment[SEG_TEXT];
	125
351aa9f6	126	/* Force to at least 2. */
252b5132 RH	127	if (headers->header.a_talign < 2)
	128	{
	129	headers->header.a_talign = 2;
351aa9f6	130	}
252b5132 RH	131
	132	headers->header.a_dalign = section_alignment[SEG_DATA];
	133	headers->header.a_balign = section_alignment[SEG_BSS];
	134
	135	headers->header.a_tload = 0;
351aa9f6 KH	136	headers->header.a_dload =
351aa9f6 KH	137	md_section_align (SEG_DATA, H_GET_TEXT_SIZE (headers));
252b5132 RH	138
	139	headers->header.a_relaxable = linkrelax;
	140
	141	#ifdef CROSS_COMPILE
	142	md_number_to_chars (*where, headers->header.a_magic, sizeof (headers->header.a_magic));
	143	*where += sizeof (headers->header.a_magic);
	144	md_number_to_chars (*where, headers->header.a_text, sizeof (headers->header.a_text));
	145	*where += sizeof (headers->header.a_text);
	146	md_number_to_chars (*where, headers->header.a_data, sizeof (headers->header.a_data));
	147	*where += sizeof (headers->header.a_data);
	148	md_number_to_chars (*where, headers->header.a_bss, sizeof (headers->header.a_bss));
	149	*where += sizeof (headers->header.a_bss);
	150	md_number_to_chars (*where, headers->header.a_syms, sizeof (headers->header.a_syms));
	151	*where += sizeof (headers->header.a_syms);
	152	md_number_to_chars (*where, headers->header.a_entry, sizeof (headers->header.a_entry));
	153	*where += sizeof (headers->header.a_entry);
	154	md_number_to_chars (*where, headers->header.a_trsize, sizeof (headers->header.a_trsize));
	155	*where += sizeof (headers->header.a_trsize);
	156	md_number_to_chars (*where, headers->header.a_drsize, sizeof (headers->header.a_drsize));
	157	*where += sizeof (headers->header.a_drsize);
	158	md_number_to_chars (*where, headers->header.a_tload, sizeof (headers->header.a_tload));
	159	*where += sizeof (headers->header.a_tload);
	160	md_number_to_chars (*where, headers->header.a_dload, sizeof (headers->header.a_dload));
	161	*where += sizeof (headers->header.a_dload);
	162	md_number_to_chars (*where, headers->header.a_talign, sizeof (headers->header.a_talign));
	163	*where += sizeof (headers->header.a_talign);
	164	md_number_to_chars (*where, headers->header.a_dalign, sizeof (headers->header.a_dalign));
	165	*where += sizeof (headers->header.a_dalign);
	166	md_number_to_chars (*where, headers->header.a_balign, sizeof (headers->header.a_balign));
	167	*where += sizeof (headers->header.a_balign);
	168	md_number_to_chars (*where, headers->header.a_relaxable, sizeof (headers->header.a_relaxable));
	169	*where += sizeof (headers->header.a_relaxable);
	170	#else /* ! CROSS_COMPILE */
	171	append (where, (char *) &headers->header, sizeof (headers->header));
	172	#endif /* ! CROSS_COMPILE */
351aa9f6	173	}
252b5132 RH	174
	175	void
	176	obj_symbol_to_chars (where, symbolP)
	177	char **where;
	178	symbolS *symbolP;
	179	{
351aa9f6 KH	180	md_number_to_chars ((char *) &(S_GET_OFFSET (symbolP)),
	181	S_GET_OFFSET (symbolP),
	182	sizeof (S_GET_OFFSET (symbolP)));
	183
	184	md_number_to_chars ((char *) &(S_GET_DESC (symbolP)),
	185	S_GET_DESC (symbolP),
	186	sizeof (S_GET_DESC (symbolP)));
	187
	188	md_number_to_chars ((char *) &symbolP->sy_symbol.n_value,
	189	S_GET_VALUE (symbolP),
	190	sizeof (symbolP->sy_symbol.n_value));
252b5132 RH	191
252b5132 RH	192	append (where, (char *) &symbolP->sy_symbol, sizeof (obj_symbol_type));
351aa9f6	193	}
252b5132 RH	194
	195	void
	196	obj_emit_symbols (where, symbol_rootP)
	197	char **where;
	198	symbolS *symbol_rootP;
	199	{
	200	symbolS *symbolP;
	201
351aa9f6	202	/* Emit all symbols left in the symbol chain. */
252b5132 RH	203	for (symbolP = symbol_rootP; symbolP; symbolP = symbol_next (symbolP))
252b5132 RH	204	{
351aa9f6 KH	205	/* Used to save the offset of the name. It is used to point to
351aa9f6 KH	206	the string in memory but must be a file offset. */
252b5132 RH	207	char *temp;
	208
	209	temp = S_GET_NAME (symbolP);
	210	S_SET_OFFSET (symbolP, symbolP->sy_name_offset);
	211
351aa9f6	212	/* Any symbol still undefined and is not a dbg symbol is made N_EXT. */
252b5132 RH	213	if (!S_IS_DEBUG (symbolP) && !S_IS_DEFINED (symbolP))
	214	S_SET_EXTERNAL (symbolP);
	215
	216	obj_symbol_to_chars (where, symbolP);
	217	S_SET_NAME (symbolP, temp);
	218	}
351aa9f6	219	}
252b5132 RH	220
	221	void
	222	obj_symbol_new_hook (symbolP)
	223	symbolS *symbolP;
	224	{
	225	S_SET_OTHER (symbolP, 0);
	226	S_SET_DESC (symbolP, 0);
	227	}
	228
	229	static void
	230	obj_bout_line (ignore)
17fc154e	231	int ignore ATTRIBUTE_UNUSED;
252b5132	232	{
351aa9f6 KH	233	/* Assume delimiter is part of expression. */
	234	/* BSD4.2 as fails with delightful bug, so we are not being
	235	incompatible here. */
252b5132 RH	236	new_logical_line ((char *) NULL, (int) (get_absolute_expression ()));
252b5132 RH	237	demand_empty_rest_of_line ();
351aa9f6	238	}
252b5132 RH	239
	240	void
	241	obj_read_begin_hook ()
	242	{
	243	}
	244
	245	void
	246	obj_crawl_symbol_chain (headers)
	247	object_headers *headers;
	248	{
	249	symbolS **symbolPP;
	250	symbolS *symbolP;
	251	int symbol_number = 0;
	252
	253	tc_crawl_symbol_chain (headers);
	254
351aa9f6	255	symbolPP = &symbol_rootP; /* -> last symbol chain link. */
252b5132 RH	256	while ((symbolP = *symbolPP) != NULL)
	257	{
	258	if (flag_readonly_data_in_text && (S_GET_SEGMENT (symbolP) == SEG_DATA))
	259	{
	260	S_SET_SEGMENT (symbolP, SEG_TEXT);
351aa9f6	261	} /* if pusing data into text */
252b5132	262
6386f3a7	263	resolve_symbol_value (symbolP);
252b5132 RH	264
	265	/* Skip symbols which were equated to undefined or common
	266	symbols. */
	267	if (symbolP->sy_value.X_op == O_symbol
	268	&& (! S_IS_DEFINED (symbolP) \|\| S_IS_COMMON (symbolP)))
	269	{
	270	*symbolPP = symbol_next (symbolP);
	271	continue;
	272	}
	273
	274	/* OK, here is how we decide which symbols go out into the
	275	brave new symtab. Symbols that do are:
351aa9f6	276
252b5132 RH	277	* symbols with no name (stabd's?)
252b5132 RH	278	* symbols with debug info in their N_TYPE
351aa9f6	279
252b5132 RH	280	Symbols that don't are:
	281	* symbols that are registers
	282	* symbols with \1 as their 3rd character (numeric labels)
	283	* "local labels" as defined by S_LOCAL_NAME(name)
	284	if the -L switch was passed to gas.
252b5132	285
351aa9f6 KH	286	All other symbols are output. We complain if a deleted
351aa9f6 KH	287	symbol was marked external. */
252b5132 RH	288
	289	if (1
	290	&& !S_IS_REGISTER (symbolP)
	291	&& (!S_GET_NAME (symbolP)
	292	\|\| S_IS_DEBUG (symbolP)
	293	#ifdef TC_I960
351aa9f6	294	/* FIXME-SOON this ifdef seems highly dubious to me. xoxorich. */
252b5132 RH	295	\|\| !S_IS_DEFINED (symbolP)
	296	\|\| S_IS_EXTERNAL (symbolP)
	297	#endif /* TC_I960 */
351aa9f6 KH	298	\|\| (S_GET_NAME (symbolP)[0] != '\001'
351aa9f6 KH	299	&& (flag_keep_locals \|\| !S_LOCAL_NAME (symbolP)))))
252b5132 RH	300	{
	301	symbolP->sy_number = symbol_number++;
	302
351aa9f6 KH	303	/* The + 1 after strlen account for the \0 at the end of
351aa9f6 KH	304	each string. */
252b5132 RH	305	if (!S_IS_STABD (symbolP))
252b5132 RH	306	{
351aa9f6	307	/* Ordinary case. */
252b5132 RH	308	symbolP->sy_name_offset = string_byte_count;
	309	string_byte_count += strlen (S_GET_NAME (symbolP)) + 1;
	310	}
351aa9f6	311	else /* .Stabd case. */
252b5132	312	symbolP->sy_name_offset = 0;
8141c27d	313	symbolPP = &(symbolP->sy_next);
252b5132 RH	314	}
	315	else
	316	{
	317	if (S_IS_EXTERNAL (symbolP) \|\| !S_IS_DEFINED (symbolP))
	318	{
351aa9f6 KH	319	as_bad (_("Local symbol %s never defined"),
	320	S_GET_NAME (symbolP));
	321	} /* Oops. */
252b5132	322
351aa9f6	323	/* Unhook it from the chain. */
252b5132	324	*symbolPP = symbol_next (symbolP);
351aa9f6 KH	325	} /* if this symbol should be in the output */
351aa9f6 KH	326	} /* for each symbol */
252b5132 RH	327
	328	H_SET_SYMBOL_TABLE_SIZE (headers, symbol_number);
	329	}
	330
351aa9f6	331	/* Find strings by crawling along symbol table chain. */
252b5132 RH	332
	333	void
	334	obj_emit_strings (where)
	335	char **where;
	336	{
	337	symbolS *symbolP;
	338
	339	#ifdef CROSS_COMPILE
	340	/* Gotta do md_ byte-ordering stuff for string_byte_count first - KWK */
	341	md_number_to_chars (*where, string_byte_count, sizeof (string_byte_count));
	342	*where += sizeof (string_byte_count);
	343	#else /* CROSS_COMPILE */
351aa9f6 KH	344	append (where, (char *) &string_byte_count,
351aa9f6 KH	345	(unsigned long) sizeof (string_byte_count));
252b5132 RH	346	#endif /* CROSS_COMPILE */
	347
	348	for (symbolP = symbol_rootP; symbolP; symbolP = symbol_next (symbolP))
	349	{
	350	if (S_GET_NAME (symbolP))
351aa9f6 KH	351	append (where, S_GET_NAME (symbolP),
	352	(unsigned long) (strlen (S_GET_NAME (symbolP)) + 1));
	353	} /* Walk symbol chain. */
252b5132	354	}