[deliverable/binutils-gdb.git] / gas / config / obj-ecoff.c

/* ECOFF object file format.
   Copyright 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002
   Free Software Foundation, Inc.
   Contributed by Cygnus Support.
   This file was put together by Ian Lance Taylor <ian@cygnus.com>.

   This file is part of GAS.

   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.  */

#define OBJ_HEADER "obj-ecoff.h"
#include "as.h"
#include "coff/internal.h"
#include "bfd/libcoff.h"
#include "bfd/libecoff.h"

/* Almost all of the ECOFF support is actually in ecoff.c in the main
   gas directory.  This file mostly just arranges to call that one at
   the right times.  */

static int ecoff_sec_sym_ok_for_reloc PARAMS ((asection *));
static void obj_ecoff_frob_symbol PARAMS ((symbolS *, int *));
static void ecoff_pop_insert PARAMS ((void));
static int ecoff_separate_stab_sections PARAMS ((void));

/* These are the pseudo-ops we support in this file.  Only those
   relating to debugging information are supported here.

   The following pseudo-ops from the Kane and Heinrich MIPS book
   should be defined here, but are currently unsupported: .aent,
   .bgnb, .endb, .verstamp, .vreg.

   The following pseudo-ops from the Kane and Heinrich MIPS book are
   MIPS CPU specific, and should be defined by tc-mips.c: .alias,
   .extern, .galive, .gjaldef, .gjrlive, .livereg, .noalias, .option,
   .rdata, .sdata, .set.

   The following pseudo-ops from the Kane and Heinrich MIPS book are
   not MIPS CPU specific, but are also not ECOFF specific.  I have
   only listed the ones which are not already in read.c.  It's not
   completely clear where these should be defined, but tc-mips.c is
   probably the most reasonable place: .asciiz, .asm0, .endr, .err,
   .half, .lab, .repeat, .struct, .weakext.  */

const pseudo_typeS obj_pseudo_table[] =
{
  /* COFF style debugging information. .ln is not used; .loc is used
     instead.  */
  { "def",	ecoff_directive_def,	0 },
  { "dim",	ecoff_directive_dim,	0 },
  { "endef",	ecoff_directive_endef,	0 },
  { "file",	ecoff_directive_file,	0 },
  { "scl",	ecoff_directive_scl,	0 },
  { "size",	ecoff_directive_size,	0 },
  { "esize",	ecoff_directive_size,	0 },
  { "tag",	ecoff_directive_tag,	0 },
  { "type",	ecoff_directive_type,	0 },
  { "etype",	ecoff_directive_type,	0 },
  { "val",	ecoff_directive_val,	0 },

  /* ECOFF specific debugging information.  */
  { "begin",	ecoff_directive_begin,	0 },
  { "bend",	ecoff_directive_bend,	0 },
  { "end",	ecoff_directive_end,	0 },
  { "ent",	ecoff_directive_ent,	0 },
  { "fmask",	ecoff_directive_fmask,	0 },
  { "frame",	ecoff_directive_frame,	0 },
  { "loc",	ecoff_directive_loc,	0 },
  { "mask",	ecoff_directive_mask,	0 },

  /* Other ECOFF directives.  */
  { "extern",	ecoff_directive_extern,	0 },

#ifndef TC_MIPS
  /* For TC_MIPS, tc-mips.c adds this.  */
  { "weakext",	ecoff_directive_weakext, 0 },
#endif

  /* These are used on Irix.  I don't know how to implement them.  */
  { "bgnb",	s_ignore,		0 },
  { "endb",	s_ignore,		0 },
  { "verstamp",	s_ignore,		0 },

  /* Sentinel.  */
  { NULL,	s_ignore,		0 }
};

/* Set section VMAs and GP values before reloc processing.  */

void
ecoff_frob_file_before_fix ()
{
  bfd_vma addr;
  asection **sec;

  /* Set the section VMA values.  We force the .sdata and .sbss
     sections to the end to ensure that their VMA addresses are close
     together so that the GP register can address both of them.  We
     put the .bss section after the .sbss section.

     Also, for the Alpha, we must sort the sections, to make sure they
     appear in the output file in the correct order.  (Actually, maybe
     this is a job for BFD.  But the VMAs computed would be out of
     whack if we computed them given our initial, random ordering.
     It's possible that that wouldn't break things; I could do some
     experimenting sometime and find out.

     This output ordering of sections is magic, on the Alpha, at
     least.  The .lita section must come before .lit8 and .lit4,
     otherwise the OSF/1 linker may silently trash the .lit{4,8}
     section contents.  Also, .text must preceed .rdata.  These differ
     from the order described in some parts of the DEC OSF/1 Assembly
     Language Programmer's Guide, but that order doesn't seem to work
     with their linker.

     I don't know if section ordering on the MIPS is important.  */

  static const char *const names[] = {
    /* text segment */
    ".text", ".rdata", ".init", ".fini",
    /* data segment */
    ".data", ".lita", ".lit8", ".lit4", ".sdata", ".got",
    /* bss segment */
    ".sbss", ".bss",
  };
#define n_names ((int) (sizeof (names) / sizeof (names[0])))

  /* Sections that match names, order to be straightened out later.  */
  asection *secs[n_names];
  int i;

  addr = 0;
  for (i = 0; i < n_names; i++)
    secs[i] = 0;

  for (sec = &stdoutput->sections; *sec != (asection *) NULL; )
    {
      for (i = 0; i < n_names; i++)
	if (!strcmp ((*sec)->name, names[i]))
	  {
	    secs[i] = *sec;
	    bfd_section_list_remove (stdoutput, sec);
	    break;
	  }
      if (i == n_names)
	{
	  bfd_set_section_vma (stdoutput, *sec, addr);
	  addr += bfd_section_size (stdoutput, *sec);
	  sec = &(*sec)->next;
	}
    }
  for (i = 0; i < n_names; i++)
    if (secs[i])
      {
	bfd_set_section_vma (stdoutput, secs[i], addr);
	addr += bfd_section_size (stdoutput, secs[i]);
      }
  for (i = n_names - 1; i >= 0; i--)
    if (secs[i])
      bfd_section_list_insert (stdoutput, &stdoutput->sections, secs[i]);

  /* Fill in the register masks.  */
  {
    unsigned long gprmask = 0;
    unsigned long fprmask = 0;
    unsigned long *cprmask = NULL;

#ifdef TC_MIPS
    /* Fill in the MIPS register masks.  It's probably not worth
       setting up a generic interface for this.  */
    gprmask = mips_gprmask;
    cprmask = mips_cprmask;
#endif

#ifdef TC_ALPHA
    alpha_frob_ecoff_data ();

    if (! bfd_ecoff_set_gp_value (stdoutput, alpha_gp_value))
      as_fatal (_("Can't set GP value"));

    gprmask = alpha_gprmask;
    fprmask = alpha_fprmask;
#endif

    if (! bfd_ecoff_set_regmasks (stdoutput, gprmask, fprmask, cprmask))
      as_fatal (_("Can't set register masks"));
  }
}

/* Swap out the symbols and debugging information for BFD.  */

void
ecoff_frob_file ()
{
  const struct ecoff_debug_swap * const debug_swap
    = &ecoff_backend (stdoutput)->debug_swap;
  bfd_vma addr ATTRIBUTE_UNUSED;
  HDRR *hdr;
  char *buf;
  char *set;

  /* Build the ECOFF debugging information.  */
  assert (ecoff_data (stdoutput) != 0);
  hdr = &ecoff_data (stdoutput)->debug_info.symbolic_header;
  ecoff_build_debug (hdr, &buf, debug_swap);

  /* Finish up the ecoff_tdata structure.  */
  set = buf;
#define SET(ptr, count, type, size) \
  if (hdr->count == 0) \
    ecoff_data (stdoutput)->debug_info.ptr = (type) NULL; \
  else \
    { \
      ecoff_data (stdoutput)->debug_info.ptr = (type) set; \
      set += hdr->count * size; \
    }

  SET (line, cbLine, unsigned char *, sizeof (unsigned char));
  SET (external_dnr, idnMax, PTR, debug_swap->external_dnr_size);
  SET (external_pdr, ipdMax, PTR, debug_swap->external_pdr_size);
  SET (external_sym, isymMax, PTR, debug_swap->external_sym_size);
  SET (external_opt, ioptMax, PTR, debug_swap->external_opt_size);
  SET (external_aux, iauxMax, union aux_ext *, sizeof (union aux_ext));
  SET (ss, issMax, char *, sizeof (char));
  SET (ssext, issExtMax, char *, sizeof (char));
  SET (external_rfd, crfd, PTR, debug_swap->external_rfd_size);
  SET (external_fdr, ifdMax, PTR, debug_swap->external_fdr_size);
  SET (external_ext, iextMax, PTR, debug_swap->external_ext_size);
#undef SET
}

/* This is called by the ECOFF code to set the external information
   for a symbol.  We just pass it on to BFD, which expects the swapped
   information to be stored in the native field of the symbol.  */

void
obj_ecoff_set_ext (sym, ext)
     symbolS *sym;
     EXTR *ext;
{
  const struct ecoff_debug_swap * const debug_swap
    = &ecoff_backend (stdoutput)->debug_swap;
  ecoff_symbol_type *esym;

  know (bfd_asymbol_flavour (symbol_get_bfdsym (sym))
	== bfd_target_ecoff_flavour);
  esym = ecoffsymbol (symbol_get_bfdsym (sym));
  esym->local = FALSE;
  esym->native = xmalloc (debug_swap->external_ext_size);
  (*debug_swap->swap_ext_out) (stdoutput, ext, esym->native);
}

static int
ecoff_sec_sym_ok_for_reloc (sec)
     asection *sec ATTRIBUTE_UNUSED;
{
  return 1;
}

static void
obj_ecoff_frob_symbol (sym, puntp)
     symbolS *sym;
     int *puntp ATTRIBUTE_UNUSED;
{
  ecoff_frob_symbol (sym);
}

static void
ecoff_pop_insert ()
{
  pop_insert (obj_pseudo_table);
}

static int
ecoff_separate_stab_sections ()
{
  return 0;
}

const struct format_ops ecoff_format_ops =
{
  bfd_target_ecoff_flavour,
  0,	/* dfl_leading_underscore */

  /* FIXME: A comment why emit_section_symbols is different here (1) from
     the single-format definition (0) would be in order.  */
  1,	/* emit_section_symbols */
  0,	/* begin */
  ecoff_new_file,
  obj_ecoff_frob_symbol,
  ecoff_frob_file,
  0,	/* frob_file_before_adjust */
  ecoff_frob_file_before_fix,
  0,	/* frob_file_after_relocs */
  0,	/* s_get_size */
  0,	/* s_set_size */
  0,	/* s_get_align */
  0,	/* s_set_align */
  0,	/* s_get_other */
  0,	/* s_set_other */
  0,	/* s_get_desc */
  0,	/* s_set_desc */
  0,	/* s_get_type */
  0,	/* s_set_type */
  0,	/* copy_symbol_attributes */
  ecoff_generate_asm_lineno,
  ecoff_stab,
  ecoff_separate_stab_sections,
  0,	/* init_stab_section */
  ecoff_sec_sym_ok_for_reloc,
  ecoff_pop_insert,
  ecoff_set_ext,
  ecoff_read_begin_hook,
  ecoff_symbol_new_hook
};
Commit	Line	Data
252b5132	1	/* ECOFF object file format.
a161fe53	2	Copyright 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002
4c63da97	3	Free Software Foundation, Inc.
252b5132 RH	4	Contributed by Cygnus Support.
	5	This file was put together by Ian Lance Taylor <ian@cygnus.com>.
	6
	7	This file is part of GAS.
	8
	9	GAS is free software; you can redistribute it and/or modify
	10	it under the terms of the GNU General Public License as published by
	11	the Free Software Foundation; either version 2, or (at your option)
	12	any later version.
	13
	14	GAS is distributed in the hope that it will be useful,
	15	but WITHOUT ANY WARRANTY; without even the implied warranty of
	16	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	17	GNU General Public License for more details.
	18
	19	You should have received a copy of the GNU General Public License
	20	along with GAS; see the file COPYING. If not, write to the Free
	21	Software Foundation, 59 Temple Place - Suite 330, Boston, MA
	22	02111-1307, USA. */
	23
	24	#define OBJ_HEADER "obj-ecoff.h"
	25	#include "as.h"
	26	#include "coff/internal.h"
	27	#include "bfd/libcoff.h"
	28	#include "bfd/libecoff.h"
	29
	30	/* Almost all of the ECOFF support is actually in ecoff.c in the main
	31	gas directory. This file mostly just arranges to call that one at
	32	the right times. */
	33
	34	static int ecoff_sec_sym_ok_for_reloc PARAMS ((asection *));
	35	static void obj_ecoff_frob_symbol PARAMS ((symbolS , int ));
	36	static void ecoff_pop_insert PARAMS ((void));
5110c57e	37	static int ecoff_separate_stab_sections PARAMS ((void));
252b5132 RH	38
	39	/* These are the pseudo-ops we support in this file. Only those
	40	relating to debugging information are supported here.
	41
	42	The following pseudo-ops from the Kane and Heinrich MIPS book
	43	should be defined here, but are currently unsupported: .aent,
	44	.bgnb, .endb, .verstamp, .vreg.
	45
	46	The following pseudo-ops from the Kane and Heinrich MIPS book are
	47	MIPS CPU specific, and should be defined by tc-mips.c: .alias,
	48	.extern, .galive, .gjaldef, .gjrlive, .livereg, .noalias, .option,
	49	.rdata, .sdata, .set.
	50
	51	The following pseudo-ops from the Kane and Heinrich MIPS book are
	52	not MIPS CPU specific, but are also not ECOFF specific. I have
	53	only listed the ones which are not already in read.c. It's not
	54	completely clear where these should be defined, but tc-mips.c is
	55	probably the most reasonable place: .asciiz, .asm0, .endr, .err,
	56	.half, .lab, .repeat, .struct, .weakext. */
	57
	58	const pseudo_typeS obj_pseudo_table[] =
	59	{
	60	/* COFF style debugging information. .ln is not used; .loc is used
	61	instead. */
	62	{ "def", ecoff_directive_def, 0 },
	63	{ "dim", ecoff_directive_dim, 0 },
	64	{ "endef", ecoff_directive_endef, 0 },
	65	{ "file", ecoff_directive_file, 0 },
	66	{ "scl", ecoff_directive_scl, 0 },
	67	{ "size", ecoff_directive_size, 0 },
	68	{ "esize", ecoff_directive_size, 0 },
	69	{ "tag", ecoff_directive_tag, 0 },
	70	{ "type", ecoff_directive_type, 0 },
	71	{ "etype", ecoff_directive_type, 0 },
	72	{ "val", ecoff_directive_val, 0 },
	73
	74	/* ECOFF specific debugging information. */
	75	{ "begin", ecoff_directive_begin, 0 },
	76	{ "bend", ecoff_directive_bend, 0 },
	77	{ "end", ecoff_directive_end, 0 },
	78	{ "ent", ecoff_directive_ent, 0 },
	79	{ "fmask", ecoff_directive_fmask, 0 },
	80	{ "frame", ecoff_directive_frame, 0 },
	81	{ "loc", ecoff_directive_loc, 0 },
	82	{ "mask", ecoff_directive_mask, 0 },
	83
	84	/* Other ECOFF directives. */
	85	{ "extern", ecoff_directive_extern, 0 },
	86
	87	#ifndef TC_MIPS
bf514e21	88	/* For TC_MIPS, tc-mips.c adds this. */
252b5132 RH	89	{ "weakext", ecoff_directive_weakext, 0 },
	90	#endif
	91
	92	/* These are used on Irix. I don't know how to implement them. */
	93	{ "bgnb", s_ignore, 0 },
	94	{ "endb", s_ignore, 0 },
	95	{ "verstamp", s_ignore, 0 },
	96
	97	/* Sentinel. */
3438adb3	98	{ NULL, s_ignore, 0 }
252b5132 RH	99	};
252b5132 RH	100
a161fe53	101	/* Set section VMAs and GP values before reloc processing. */
252b5132 RH	102
252b5132 RH	103	void
a161fe53	104	ecoff_frob_file_before_fix ()
252b5132	105	{
252b5132	106	bfd_vma addr;
7c6beb69	107	asection **sec;
252b5132 RH	108
	109	/* Set the section VMA values. We force the .sdata and .sbss
	110	sections to the end to ensure that their VMA addresses are close
	111	together so that the GP register can address both of them. We
	112	put the .bss section after the .sbss section.
	113
	114	Also, for the Alpha, we must sort the sections, to make sure they
	115	appear in the output file in the correct order. (Actually, maybe
	116	this is a job for BFD. But the VMAs computed would be out of
	117	whack if we computed them given our initial, random ordering.
	118	It's possible that that wouldn't break things; I could do some
	119	experimenting sometime and find out.
	120
	121	This output ordering of sections is magic, on the Alpha, at
	122	least. The .lita section must come before .lit8 and .lit4,
	123	otherwise the OSF/1 linker may silently trash the .lit{4,8}
	124	section contents. Also, .text must preceed .rdata. These differ
	125	from the order described in some parts of the DEC OSF/1 Assembly
	126	Language Programmer's Guide, but that order doesn't seem to work
	127	with their linker.
	128
	129	I don't know if section ordering on the MIPS is important. */
	130
	131	static const char *const names[] = {
	132	/* text segment */
	133	".text", ".rdata", ".init", ".fini",
	134	/* data segment */
	135	".data", ".lita", ".lit8", ".lit4", ".sdata", ".got",
	136	/* bss segment */
	137	".sbss", ".bss",
	138	};
3438adb3	139	#define n_names ((int) (sizeof (names) / sizeof (names[0])))
252b5132	140
7c6beb69 AM	141	/* Sections that match names, order to be straightened out later. */
	142	asection *secs[n_names];
	143	int i;
	144
252b5132	145	addr = 0;
7c6beb69 AM	146	for (i = 0; i < n_names; i++)
	147	secs[i] = 0;
	148
	149	for (sec = &stdoutput->sections; sec != (asection ) NULL; )
	150	{
	151	for (i = 0; i < n_names; i++)
	152	if (!strcmp ((*sec)->name, names[i]))
252b5132	153	{
7c6beb69 AM	154	secs[i] = *sec;
	155	bfd_section_list_remove (stdoutput, sec);
	156	break;
252b5132	157	}
7c6beb69	158	if (i == n_names)
252b5132	159	{
7c6beb69 AM	160	bfd_set_section_vma (stdoutput, *sec, addr);
	161	addr += bfd_section_size (stdoutput, *sec);
	162	sec = &(*sec)->next;
252b5132	163	}
7c6beb69 AM	164	}
	165	for (i = 0; i < n_names; i++)
	166	if (secs[i])
	167	{
	168	bfd_set_section_vma (stdoutput, secs[i], addr);
	169	addr += bfd_section_size (stdoutput, secs[i]);
	170	}
	171	for (i = n_names - 1; i >= 0; i--)
	172	if (secs[i])
	173	bfd_section_list_insert (stdoutput, &stdoutput->sections, secs[i]);
252b5132	174
a161fe53 AM	175	/* Fill in the register masks. */
	176	{
	177	unsigned long gprmask = 0;
	178	unsigned long fprmask = 0;
	179	unsigned long *cprmask = NULL;
	180
	181	#ifdef TC_MIPS
	182	/* Fill in the MIPS register masks. It's probably not worth
	183	setting up a generic interface for this. */
	184	gprmask = mips_gprmask;
	185	cprmask = mips_cprmask;
	186	#endif
	187
	188	#ifdef TC_ALPHA
	189	alpha_frob_ecoff_data ();
	190
	191	if (! bfd_ecoff_set_gp_value (stdoutput, alpha_gp_value))
	192	as_fatal (_("Can't set GP value"));
	193
	194	gprmask = alpha_gprmask;
	195	fprmask = alpha_fprmask;
	196	#endif
	197
	198	if (! bfd_ecoff_set_regmasks (stdoutput, gprmask, fprmask, cprmask))
	199	as_fatal (_("Can't set register masks"));
	200	}
	201	}
	202
	203	/* Swap out the symbols and debugging information for BFD. */
	204
	205	void
	206	ecoff_frob_file ()
	207	{
	208	const struct ecoff_debug_swap * const debug_swap
	209	= &ecoff_backend (stdoutput)->debug_swap;
17fc154e	210	bfd_vma addr ATTRIBUTE_UNUSED;
a161fe53 AM	211	HDRR *hdr;
	212	char *buf;
	213	char *set;
	214
252b5132 RH	215	/* Build the ECOFF debugging information. */
	216	assert (ecoff_data (stdoutput) != 0);
	217	hdr = &ecoff_data (stdoutput)->debug_info.symbolic_header;
	218	ecoff_build_debug (hdr, &buf, debug_swap);
	219
	220	/* Finish up the ecoff_tdata structure. */
	221	set = buf;
	222	#define SET(ptr, count, type, size) \
	223	if (hdr->count == 0) \
	224	ecoff_data (stdoutput)->debug_info.ptr = (type) NULL; \
	225	else \
	226	{ \
	227	ecoff_data (stdoutput)->debug_info.ptr = (type) set; \
	228	set += hdr->count * size; \
	229	}
	230
	231	SET (line, cbLine, unsigned char *, sizeof (unsigned char));
	232	SET (external_dnr, idnMax, PTR, debug_swap->external_dnr_size);
	233	SET (external_pdr, ipdMax, PTR, debug_swap->external_pdr_size);
	234	SET (external_sym, isymMax, PTR, debug_swap->external_sym_size);
	235	SET (external_opt, ioptMax, PTR, debug_swap->external_opt_size);
	236	SET (external_aux, iauxMax, union aux_ext *, sizeof (union aux_ext));
	237	SET (ss, issMax, char *, sizeof (char));
	238	SET (ssext, issExtMax, char *, sizeof (char));
	239	SET (external_rfd, crfd, PTR, debug_swap->external_rfd_size);
	240	SET (external_fdr, ifdMax, PTR, debug_swap->external_fdr_size);
	241	SET (external_ext, iextMax, PTR, debug_swap->external_ext_size);
252b5132	242	#undef SET
252b5132 RH	243	}
	244
	245	/* This is called by the ECOFF code to set the external information
	246	for a symbol. We just pass it on to BFD, which expects the swapped
	247	information to be stored in the native field of the symbol. */
	248
	249	void
	250	obj_ecoff_set_ext (sym, ext)
	251	symbolS *sym;
	252	EXTR *ext;
	253	{
	254	const struct ecoff_debug_swap * const debug_swap
	255	= &ecoff_backend (stdoutput)->debug_swap;
	256	ecoff_symbol_type *esym;
	257
fed9b18a ILT	258	know (bfd_asymbol_flavour (symbol_get_bfdsym (sym))
	259	== bfd_target_ecoff_flavour);
	260	esym = ecoffsymbol (symbol_get_bfdsym (sym));
b34976b6	261	esym->local = FALSE;
252b5132 RH	262	esym->native = xmalloc (debug_swap->external_ext_size);
	263	(*debug_swap->swap_ext_out) (stdoutput, ext, esym->native);
	264	}
	265
	266	static int
	267	ecoff_sec_sym_ok_for_reloc (sec)
3438adb3	268	asection *sec ATTRIBUTE_UNUSED;
252b5132 RH	269	{
	270	return 1;
	271	}
	272
	273	static void
	274	obj_ecoff_frob_symbol (sym, puntp)
	275	symbolS *sym;
3438adb3	276	int *puntp ATTRIBUTE_UNUSED;
252b5132 RH	277	{
	278	ecoff_frob_symbol (sym);
	279	}
	280
	281	static void
	282	ecoff_pop_insert ()
	283	{
	284	pop_insert (obj_pseudo_table);
	285	}
	286
5110c57e HPN	287	static int
	288	ecoff_separate_stab_sections ()
	289	{
	290	return 0;
	291	}
	292
252b5132 RH	293	const struct format_ops ecoff_format_ops =
	294	{
	295	bfd_target_ecoff_flavour,
4c63da97	296	0, /* dfl_leading_underscore */
5110c57e HPN	297
	298	/* FIXME: A comment why emit_section_symbols is different here (1) from
	299	the single-format definition (0) would be in order. */
4c63da97	300	1, /* emit_section_symbols */
5110c57e HPN	301	0, /* begin */
5110c57e HPN	302	ecoff_new_file,
252b5132 RH	303	obj_ecoff_frob_symbol,
252b5132 RH	304	ecoff_frob_file,
339681c0	305	0, /* frob_file_before_adjust */
a161fe53	306	ecoff_frob_file_before_fix,
4c63da97 AM	307	0, /* frob_file_after_relocs */
	308	0, /* s_get_size */
	309	0, /* s_set_size */
	310	0, /* s_get_align */
	311	0, /* s_set_align */
	312	0, /* s_get_other */
5110c57e	313	0, /* s_set_other */
4c63da97	314	0, /* s_get_desc */
5110c57e HPN	315	0, /* s_set_desc */
	316	0, /* s_get_type */
	317	0, /* s_set_type */
4c63da97	318	0, /* copy_symbol_attributes */
252b5132 RH	319	ecoff_generate_asm_lineno,
252b5132 RH	320	ecoff_stab,
5110c57e HPN	321	ecoff_separate_stab_sections,
5110c57e HPN	322	0, /* init_stab_section */
252b5132 RH	323	ecoff_sec_sym_ok_for_reloc,
	324	ecoff_pop_insert,
	325	ecoff_set_ext,
	326	ecoff_read_begin_hook,
5110c57e	327	ecoff_symbol_new_hook
252b5132	328	};