/* coff object file format
- Copyright (C) 1989, 90, 91, 92, 93, 94, 95, 96, 97, 98, 1999
+ Copyright 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
+ 1999, 2000, 2001, 2002, 2003, 2004, 2005
Free Software Foundation, Inc.
This file is part of GAS.
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. */
+ Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
+ 02110-1301, USA. */
#define OBJ_HEADER "obj-coff.h"
#include "obstack.h"
#include "subsegs.h"
+#ifdef TE_PE
+#include "coff/pe.h"
+#endif
+
+#define streq(a,b) (strcmp ((a), (b)) == 0)
+#define strneq(a,b,n) (strncmp ((a), (b), (n)) == 0)
+
/* I think this is probably always correct. */
#ifndef KEEP_RELOC_INFO
#define KEEP_RELOC_INFO
#endif
-static void obj_coff_bss PARAMS ((int));
-const char *s_get_name PARAMS ((symbolS * s));
-static void obj_coff_ln PARAMS ((int));
-static void obj_coff_def PARAMS ((int));
-static void obj_coff_endef PARAMS ((int));
-static void obj_coff_dim PARAMS ((int));
-static void obj_coff_line PARAMS ((int));
-static void obj_coff_size PARAMS ((int));
-static void obj_coff_scl PARAMS ((int));
-static void obj_coff_tag PARAMS ((int));
-static void obj_coff_val PARAMS ((int));
-static void obj_coff_type PARAMS ((int));
-static void obj_coff_ident PARAMS ((int));
-#ifdef BFD_ASSEMBLER
-static void obj_coff_loc PARAMS((int));
+/* The BFD_ASSEMBLER version of obj_coff_section will use this macro to set
+ a new section's attributes when a directive has no valid flags or the
+ "w" flag is used. This default should be appropriate for most. */
+#ifndef TC_COFF_SECTION_DEFAULT_ATTRIBUTES
+#define TC_COFF_SECTION_DEFAULT_ATTRIBUTES (SEC_LOAD | SEC_DATA)
#endif
/* This is used to hold the symbol built by a sequence of pseudo-ops
from .def and .endef. */
static symbolS *def_symbol_in_progress;
-\f
-/* stack stuff */
+#ifdef TE_PE
+/* PE weak alternate symbols begin with this string. */
+static const char weak_altprefix[] = ".weak.";
+#endif /* TE_PE */
+
typedef struct
{
unsigned long chunk_size;
}
stack;
+\f
+/* Stack stuff. */
+
static stack *
-stack_init (chunk_size, element_size)
- unsigned long chunk_size;
- unsigned long element_size;
+stack_init (unsigned long chunk_size,
+ unsigned long element_size)
{
stack *st;
- st = (stack *) malloc (sizeof (stack));
+ st = malloc (sizeof (* st));
if (!st)
- return 0;
+ return NULL;
st->data = malloc (chunk_size);
if (!st->data)
{
free (st);
- return 0;
+ return NULL;
}
st->pointer = 0;
st->size = chunk_size;
return st;
}
-#if 0
-/* Not currently used. */
-static void
-stack_delete (st)
- stack *st;
-{
- free (st->data);
- free (st);
-}
-#endif
-
static char *
-stack_push (st, element)
- stack *st;
- char *element;
+stack_push (stack *st, char *element)
{
if (st->pointer + st->element_size >= st->size)
{
st->size += st->chunk_size;
- if ((st->data = xrealloc (st->data, st->size)) == (char *) 0)
- return (char *) 0;
+ if ((st->data = xrealloc (st->data, st->size)) == NULL)
+ return NULL;
}
memcpy (st->data + st->pointer, element, st->element_size);
st->pointer += st->element_size;
}
static char *
-stack_pop (st)
- stack *st;
+stack_pop (stack *st)
{
if (st->pointer < st->element_size)
{
st->pointer = 0;
- return (char *) 0;
+ return NULL;
}
st->pointer -= st->element_size;
return st->data + st->pointer;
}
\f
-/*
- * Maintain a list of the tagnames of the structres.
- */
+/* Maintain a list of the tagnames of the structures. */
static struct hash_control *tag_hash;
static void
-tag_init ()
+tag_init (void)
{
tag_hash = hash_new ();
}
static void
-tag_insert (name, symbolP)
- const char *name;
- symbolS *symbolP;
+tag_insert (const char *name, symbolS *symbolP)
{
const char *error_string;
if ((error_string = hash_jam (tag_hash, name, (char *) symbolP)))
- {
- as_fatal (_("Inserting \"%s\" into structure table failed: %s"),
- name, error_string);
- }
+ as_fatal (_("Inserting \"%s\" into structure table failed: %s"),
+ name, error_string);
}
static symbolS *
-tag_find (name)
- char *name;
+tag_find (char *name)
{
-#ifdef STRIP_UNDERSCORE
- if (*name == '_')
- name++;
-#endif /* STRIP_UNDERSCORE */
return (symbolS *) hash_find (tag_hash, name);
}
static symbolS *
-tag_find_or_make (name)
- char *name;
+tag_find_or_make (char *name)
{
symbolS *symbolP;
#ifdef BFD_ASSEMBLER
symbol_table_insert (symbolP);
#endif
- } /* not found */
+ }
return symbolP;
}
compatibility with earlier versions of gas. */
static void
-obj_coff_bss (ignore)
- int ignore ATTRIBUTE_UNUSED;
+obj_coff_bss (int ignore ATTRIBUTE_UNUSED)
{
if (*input_line_pointer == '\n')
subseg_new (".bss", get_absolute_expression ());
s_lcomm (0);
}
-/* Handle .weak. This is a GNU extension. */
-
-static void
-obj_coff_weak (ignore)
- int ignore ATTRIBUTE_UNUSED;
-{
- char *name;
- int c;
- symbolS *symbolP;
-
- do
- {
- name = input_line_pointer;
- c = get_symbol_end ();
- symbolP = symbol_find_or_make (name);
- *input_line_pointer = c;
- SKIP_WHITESPACE ();
-
-#ifdef BFD_ASSEMLER
- S_SET_WEAK (symbolP);
-#endif
-
-#ifdef TE_PE
- S_SET_STORAGE_CLASS (symbolP, C_NT_WEAK);
-#else
- S_SET_STORAGE_CLASS (symbolP, C_WEAKEXT);
-#endif
-
- if (c == ',')
- {
- input_line_pointer++;
- SKIP_WHITESPACE ();
- if (*input_line_pointer == '\n')
- c = '\n';
- }
- }
- while (c == ',');
-
- demand_empty_rest_of_line ();
-}
-
#ifdef BFD_ASSEMBLER
-static void SA_SET_SYM_TAGNDX PARAMS ((symbolS *, symbolS *));
-
#define GET_FILENAME_STRING(X) \
-((char*)(&((X)->sy_symbol.ost_auxent->x_file.x_n.x_offset))[1])
+ ((char *) (&((X)->sy_symbol.ost_auxent->x_file.x_n.x_offset))[1])
/* @@ Ick. */
static segT
-fetch_coff_debug_section ()
+fetch_coff_debug_section (void)
{
static segT debug_section;
+
if (!debug_section)
{
- CONST asymbol *s;
- s = bfd_make_debug_symbol (stdoutput, (char *) 0, 0);
+ const asymbol *s;
+
+ s = bfd_make_debug_symbol (stdoutput, NULL, 0);
assert (s != 0);
debug_section = s->section;
}
}
void
-SA_SET_SYM_ENDNDX (sym, val)
- symbolS *sym;
- symbolS *val;
+SA_SET_SYM_ENDNDX (symbolS *sym, symbolS *val)
{
combined_entry_type *entry, *p;
}
static void
-SA_SET_SYM_TAGNDX (sym, val)
- symbolS *sym;
- symbolS *val;
+SA_SET_SYM_TAGNDX (symbolS *sym, symbolS *val)
{
combined_entry_type *entry, *p;
}
static int
-S_GET_DATA_TYPE (sym)
- symbolS *sym;
+S_GET_DATA_TYPE (symbolS *sym)
{
return coffsymbol (symbol_get_bfdsym (sym))->native->u.syment.n_type;
}
int
-S_SET_DATA_TYPE (sym, val)
- symbolS *sym;
- int val;
+S_SET_DATA_TYPE (symbolS *sym, int val)
{
coffsymbol (symbol_get_bfdsym (sym))->native->u.syment.n_type = val;
return val;
}
int
-S_GET_STORAGE_CLASS (sym)
- symbolS *sym;
+S_GET_STORAGE_CLASS (symbolS *sym)
{
return coffsymbol (symbol_get_bfdsym (sym))->native->u.syment.n_sclass;
}
int
-S_SET_STORAGE_CLASS (sym, val)
- symbolS *sym;
- int val;
+S_SET_STORAGE_CLASS (symbolS *sym, int val)
{
coffsymbol (symbol_get_bfdsym (sym))->native->u.syment.n_sclass = val;
return val;
}
-/* Merge a debug symbol containing debug information into a normal symbol. */
+/* Merge a debug symbol containing debug information into a normal symbol. */
-void
-c_symbol_merge (debug, normal)
- symbolS *debug;
- symbolS *normal;
+static void
+c_symbol_merge (symbolS *debug, symbolS *normal)
{
S_SET_DATA_TYPE (normal, S_GET_DATA_TYPE (debug));
S_SET_STORAGE_CLASS (normal, S_GET_STORAGE_CLASS (debug));
if (S_GET_NUMBER_AUXILIARY (debug) > S_GET_NUMBER_AUXILIARY (normal))
- {
- /* take the most we have */
- S_SET_NUMBER_AUXILIARY (normal, S_GET_NUMBER_AUXILIARY (debug));
- }
+ /* Take the most we have. */
+ S_SET_NUMBER_AUXILIARY (normal, S_GET_NUMBER_AUXILIARY (debug));
if (S_GET_NUMBER_AUXILIARY (debug) > 0)
- {
- /* Move all the auxiliary information. */
- memcpy (SYM_AUXINFO (normal), SYM_AUXINFO (debug),
- (S_GET_NUMBER_AUXILIARY (debug)
- * sizeof (*SYM_AUXINFO (debug))));
- }
+ /* Move all the auxiliary information. */
+ memcpy (SYM_AUXINFO (normal), SYM_AUXINFO (debug),
+ (S_GET_NUMBER_AUXILIARY (debug)
+ * sizeof (*SYM_AUXINFO (debug))));
- /* Move the debug flags. */
+ /* Move the debug flags. */
SF_SET_DEBUG_FIELD (normal, SF_GET_DEBUG_FIELD (debug));
}
void
-c_dot_file_symbol (filename)
- char *filename;
+c_dot_file_symbol (const char *filename, int appfile ATTRIBUTE_UNUSED)
{
symbolS *symbolP;
#ifndef NO_LISTING
{
extern int listing;
+
if (listing)
- {
- listing_source_file (filename);
- }
+ listing_source_file (filename);
}
#endif
- /* Make sure that the symbol is first on the symbol chain */
+ /* Make sure that the symbol is first on the symbol chain. */
if (symbol_rootP != symbolP)
{
symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
symbol_insert (symbolP, symbol_rootP, &symbol_rootP, &symbol_lastP);
- } /* if not first on the list */
+ }
}
-/* Line number handling */
+/* Line number handling. */
-struct line_no {
+struct line_no
+{
struct line_no *next;
fragS *frag;
alent l;
\f
void
-coff_obj_symbol_new_hook (symbolP)
- symbolS *symbolP;
+coff_obj_symbol_new_hook (symbolS *symbolP)
{
long sz = (OBJ_COFF_MAX_AUXENTRIES + 1) * sizeof (combined_entry_type);
- char * s = (char *) xmalloc (sz);
-
+ char * s = xmalloc (sz);
+
memset (s, 0, sz);
coffsymbol (symbol_get_bfdsym (symbolP))->native = (combined_entry_type *) s;
if (S_IS_STRING (symbolP))
SF_SET_STRING (symbolP);
-
+
if (S_IS_LOCAL (symbolP))
SF_SET_LOCAL (symbolP);
}
\f
-/*
- * Handle .ln directives.
- */
+/* Handle .ln directives. */
static symbolS *current_lineno_sym;
static struct line_no *line_nos;
-/* @@ Blindly assume all .ln directives will be in the .text section... */
+/* FIXME: Blindly assume all .ln directives will be in the .text section. */
int coff_n_line_nos;
static void
-add_lineno (frag, offset, num)
- fragS *frag;
- int offset;
- int num;
+add_lineno (fragS * frag, addressT offset, int num)
{
- struct line_no *new_line =
- (struct line_no *) xmalloc (sizeof (struct line_no));
+ struct line_no * new_line = xmalloc (sizeof (* new_line));
+
if (!current_lineno_sym)
- {
- abort ();
- }
- if (num <= 0)
+ abort ();
+
+#ifndef OBJ_XCOFF
+ /* The native aix assembler accepts negative line number. */
+
+ if (num <= 0)
{
/* Zero is used as an end marker in the file. */
- as_bad (_("Line numbers must be positive integers\n"));
- return;
+ as_warn (_("Line numbers must be positive integers\n"));
+ num = 1;
}
+#endif /* OBJ_XCOFF */
new_line->next = line_nos;
new_line->frag = frag;
new_line->l.line_number = num;
}
void
-coff_add_linesym (sym)
- symbolS *sym;
+coff_add_linesym (symbolS *sym)
{
if (line_nos)
{
}
static void
-obj_coff_ln (appline)
- int appline;
+obj_coff_ln (int appline)
{
int l;
}
l = get_absolute_expression ();
- if (!appline)
- {
- add_lineno (frag_now, frag_now_fix (), l);
- }
- if (appline)
+ /* If there is no lineno symbol, treat a .ln
+ directive as if it were a .appline directive. */
+ if (appline || current_lineno_sym == NULL)
new_logical_line ((char *) NULL, l - 1);
+ else
+ add_lineno (frag_now, frag_now_fix (), l);
#ifndef NO_LISTING
{
compatibility. */
static void
-obj_coff_loc (ignore)
- int ignore ATTRIBUTE_UNUSED;
+obj_coff_loc (int ignore ATTRIBUTE_UNUSED)
{
int lineno;
if (listing)
{
- lineno += coff_line_base - 1;
+ lineno += coff_line_base - 1;
listing_source_line (lineno);
}
}
/* Handle the .ident pseudo-op. */
static void
-obj_coff_ident (ignore)
- int ignore ATTRIBUTE_UNUSED;
+obj_coff_ident (int ignore ATTRIBUTE_UNUSED)
{
segT current_seg = now_seg;
subsegT current_subseg = now_subseg;
subseg_set (current_seg, current_subseg);
}
-/*
- * def()
- *
- * Handle .def directives.
- *
- * One might ask : why can't we symbol_new if the symbol does not
- * already exist and fill it with debug information. Because of
- * the C_EFCN special symbol. It would clobber the value of the
- * function symbol before we have a chance to notice that it is
- * a C_EFCN. And a second reason is that the code is more clear this
- * way. (at least I think it is :-).
- *
- */
+/* Handle .def directives.
+
+ One might ask : why can't we symbol_new if the symbol does not
+ already exist and fill it with debug information. Because of
+ the C_EFCN special symbol. It would clobber the value of the
+ function symbol before we have a chance to notice that it is
+ a C_EFCN. And a second reason is that the code is more clear this
+ way. (at least I think it is :-). */
#define SKIP_SEMI_COLON() while (*input_line_pointer++ != ';')
#define SKIP_WHITESPACES() while (*input_line_pointer == ' ' || \
- *input_line_pointer == '\t') \
- input_line_pointer++;
+ *input_line_pointer == '\t') \
+ input_line_pointer++;
static void
-obj_coff_def (what)
- int what ATTRIBUTE_UNUSED;
+obj_coff_def (int what ATTRIBUTE_UNUSED)
{
- char name_end; /* Char after the end of name */
- char *symbol_name; /* Name of the debug symbol */
- char *symbol_name_copy; /* Temporary copy of the name */
+ char name_end; /* Char after the end of name. */
+ char *symbol_name; /* Name of the debug symbol. */
+ char *symbol_name_copy; /* Temporary copy of the name. */
unsigned int symbol_name_length;
if (def_symbol_in_progress != NULL)
as_warn (_(".def pseudo-op used inside of .def/.endef: ignored."));
demand_empty_rest_of_line ();
return;
- } /* if not inside .def/.endef */
+ }
SKIP_WHITESPACES ();
symbol_name = input_line_pointer;
-#ifdef STRIP_UNDERSCORE
- if (symbol_name[0] == '_' && symbol_name[1] != 0)
- symbol_name++;
-#endif /* STRIP_UNDERSCORE */
-
name_end = get_symbol_end ();
symbol_name_length = strlen (symbol_name);
symbol_name_copy = xmalloc (symbol_name_length + 1);
symbol_name_copy = tc_canonicalize_symbol_name (symbol_name_copy);
#endif
- /* Initialize the new symbol */
+ /* Initialize the new symbol. */
def_symbol_in_progress = symbol_make (symbol_name_copy);
symbol_set_frag (def_symbol_in_progress, &zero_address_frag);
S_SET_VALUE (def_symbol_in_progress, 0);
unsigned int dim_index;
static void
-obj_coff_endef (ignore)
- int ignore ATTRIBUTE_UNUSED;
+obj_coff_endef (int ignore ATTRIBUTE_UNUSED)
{
- symbolS *symbolP;
+ symbolS *symbolP = NULL;
- /* DIM BUG FIX sac@cygnus.com */
dim_index = 0;
if (def_symbol_in_progress == NULL)
{
as_warn (_(".endef pseudo-op used outside of .def/.endef: ignored."));
demand_empty_rest_of_line ();
return;
- } /* if not inside .def/.endef */
+ }
- /* Set the section number according to storage class. */
+ /* Set the section number according to storage class. */
switch (S_GET_STORAGE_CLASS (def_symbol_in_progress))
{
case C_STRTAG:
case C_ENTAG:
case C_UNTAG:
SF_SET_TAG (def_symbol_in_progress);
- /* intentional fallthrough */
+ /* Fall through. */
case C_FILE:
case C_TPDEF:
SF_SET_DEBUG (def_symbol_in_progress);
break;
case C_EFCN:
- SF_SET_LOCAL (def_symbol_in_progress); /* Do not emit this symbol. */
- /* intentional fallthrough */
+ SF_SET_LOCAL (def_symbol_in_progress); /* Do not emit this symbol. */
+ /* Fall through. */
case C_BLOCK:
- SF_SET_PROCESS (def_symbol_in_progress); /* Will need processing before writing */
- /* intentional fallthrough */
+ SF_SET_PROCESS (def_symbol_in_progress); /* Will need processing before writing. */
+ /* Fall through. */
case C_FCN:
{
- CONST char *name;
+ const char *name;
+
S_SET_SEGMENT (def_symbol_in_progress, text_section);
name = S_GET_NAME (def_symbol_in_progress);
if (name[0] == '.' && name[2] == 'f' && name[3] == '\0')
- {
+ {
switch (name[1])
{
- case 'b':
+ case 'b':
/* .bf */
if (! in_function ())
as_warn (_("`%s' symbol without preceding function"), name);
clear_function ();
break;
#ifdef TE_PE
- case 'e':
+ case 'e':
/* .ef */
/* The MS compilers output the actual endline, not the
function-relative one... we want to match without
changing the assembler input. */
- SA_SET_SYM_LNNO (def_symbol_in_progress,
+ SA_SET_SYM_LNNO (def_symbol_in_progress,
(SA_GET_SYM_LNNO (def_symbol_in_progress)
+ coff_line_base));
break;
case C_ARG:
case C_REGPARM:
case C_FIELD:
+
+ /* According to the COFF documentation:
+
+ http://osr5doc.sco.com:1996/topics/COFF_SectNumFld.html
+
+ A special section number (-2) marks symbolic debugging symbols,
+ including structure/union/enumeration tag names, typedefs, and
+ the name of the file. A section number of -1 indicates that the
+ symbol has a value but is not relocatable. Examples of
+ absolute-valued symbols include automatic and register variables,
+ function arguments, and .eos symbols.
+
+ But from Ian Lance Taylor:
+
+ http://sources.redhat.com/ml/binutils/2000-08/msg00202.html
+
+ the actual tools all marked them as section -1. So the GNU COFF
+ assembler follows historical COFF assemblers.
+
+ However, it causes problems for djgpp
+
+ http://sources.redhat.com/ml/binutils/2000-08/msg00210.html
+
+ By defining STRICTCOFF, a COFF port can make the assembler to
+ follow the documented behavior. */
+#ifdef STRICTCOFF
+ case C_MOS:
+ case C_MOE:
+ case C_MOU:
+ case C_EOS:
+#endif
SF_SET_DEBUG (def_symbol_in_progress);
S_SET_SEGMENT (def_symbol_in_progress, absolute_section);
break;
+#ifndef STRICTCOFF
case C_MOS:
case C_MOE:
case C_MOU:
case C_EOS:
S_SET_SEGMENT (def_symbol_in_progress, absolute_section);
break;
+#endif
case C_EXT:
case C_WEAKEXT:
#endif
case C_STAT:
case C_LABEL:
- /* Valid but set somewhere else (s_comm, s_lcomm, colon) */
+ /* Valid but set somewhere else (s_comm, s_lcomm, colon). */
break;
default:
as_warn (_("unexpected storage class %d"),
S_GET_STORAGE_CLASS (def_symbol_in_progress));
break;
- } /* switch on storage class */
+ }
/* Now that we have built a debug symbol, try to find if we should
merge with an existing symbol or not. If a symbol is C_EFCN or
lineno entry MUST point to the definition function or else it
will point off into space when obj_crawl_symbol_chain() merges
the debug symbol into the real symbol. Therefor, let's presume
- the debug symbol is a real function reference. */
+ the debug symbol is a real function reference. */
/* FIXME-SOON If for some reason the definition label/symbol is
never seen, this will probably leave an undefined symbol at link
- time. */
+ time. */
if (S_GET_STORAGE_CLASS (def_symbol_in_progress) == C_EFCN
|| S_GET_STORAGE_CLASS (def_symbol_in_progress) == C_LABEL
- || (!strcmp (bfd_get_section_name (stdoutput,
- S_GET_SEGMENT (def_symbol_in_progress)),
- "*DEBUG*")
+ || (streq (bfd_get_section_name (stdoutput,
+ S_GET_SEGMENT (def_symbol_in_progress)),
+ "*DEBUG*")
&& !SF_GET_TAG (def_symbol_in_progress))
|| S_GET_SEGMENT (def_symbol_in_progress) == absolute_section
|| ! symbol_constant_p (def_symbol_in_progress)
- || (symbolP = symbol_find_base (S_GET_NAME (def_symbol_in_progress),
- DO_NOT_STRIP)) == NULL
+ || (symbolP = symbol_find (S_GET_NAME (def_symbol_in_progress))) == NULL
|| SF_GET_TAG (def_symbol_in_progress) != SF_GET_TAG (symbolP))
{
/* If it already is at the end of the symbol list, do nothing */
if (def_symbol_in_progress != symbol_lastP)
- {
+ {
symbol_remove (def_symbol_in_progress, &symbol_rootP, &symbol_lastP);
symbol_append (def_symbol_in_progress, symbol_lastP, &symbol_rootP,
&symbol_lastP);
- }
+ }
}
else
{
into the old one. This is not mandatory. The linker can
handle duplicate symbols correctly. But I guess that it save
a *lot* of space if the assembly file defines a lot of
- symbols. [loic] */
+ symbols. [loic] */
/* The debug entry (def_symbol_in_progress) is merged into the
- previous definition. */
+ previous definition. */
c_symbol_merge (def_symbol_in_progress, symbolP);
symbol_remove (def_symbol_in_progress, &symbol_rootP, &symbol_lastP);
{
/* For functions, and tags, and static symbols, the symbol
*must* be where the debug symbol appears. Move the
- existing symbol to the current place. */
- /* If it already is at the end of the symbol list, do nothing */
+ existing symbol to the current place. */
+ /* If it already is at the end of the symbol list, do nothing. */
if (def_symbol_in_progress != symbol_lastP)
{
symbol_remove (def_symbol_in_progress, &symbol_rootP, &symbol_lastP);
{
symbolS *oldtag;
- oldtag = symbol_find_base (S_GET_NAME (def_symbol_in_progress),
- DO_NOT_STRIP);
+ oldtag = symbol_find (S_GET_NAME (def_symbol_in_progress));
if (oldtag == NULL || ! SF_GET_TAG (oldtag))
tag_insert (S_GET_NAME (def_symbol_in_progress),
def_symbol_in_progress);
SF_SET_PROCESS (def_symbol_in_progress);
if (symbolP == NULL)
- {
- /* That is, if this is the first time we've seen the
- function... */
- symbol_table_insert (def_symbol_in_progress);
- } /* definition follows debug */
- } /* Create the line number entry pointing to the function being defined */
+ /* That is, if this is the first time we've seen the
+ function. */
+ symbol_table_insert (def_symbol_in_progress);
+
+ }
def_symbol_in_progress = NULL;
demand_empty_rest_of_line ();
}
static void
-obj_coff_dim (ignore)
- int ignore ATTRIBUTE_UNUSED;
+obj_coff_dim (int ignore ATTRIBUTE_UNUSED)
{
int dim_index;
as_warn (_(".dim pseudo-op used outside of .def/.endef: ignored."));
demand_empty_rest_of_line ();
return;
- } /* if not inside .def/.endef */
+ }
S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
default:
as_warn (_("badly formed .dim directive ignored"));
- /* intentional fallthrough */
+ /* Fall through. */
case '\n':
case ';':
dim_index = DIMNUM;
}
static void
-obj_coff_line (ignore)
- int ignore ATTRIBUTE_UNUSED;
+obj_coff_line (int ignore ATTRIBUTE_UNUSED)
{
int this_base;
}
this_base = get_absolute_expression ();
- if (!strcmp (".bf", S_GET_NAME (def_symbol_in_progress)))
+ if (streq (".bf", S_GET_NAME (def_symbol_in_progress)))
coff_line_base = this_base;
S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
demand_empty_rest_of_line ();
#ifndef NO_LISTING
- if (strcmp (".bf", S_GET_NAME (def_symbol_in_progress)) == 0)
+ if (streq (".bf", S_GET_NAME (def_symbol_in_progress)))
{
extern int listing;
}
static void
-obj_coff_size (ignore)
- int ignore ATTRIBUTE_UNUSED;
+obj_coff_size (int ignore ATTRIBUTE_UNUSED)
{
if (def_symbol_in_progress == NULL)
{
as_warn (_(".size pseudo-op used outside of .def/.endef ignored."));
demand_empty_rest_of_line ();
return;
- } /* if not inside .def/.endef */
+ }
S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
SA_SET_SYM_SIZE (def_symbol_in_progress, get_absolute_expression ());
}
static void
-obj_coff_scl (ignore)
- int ignore ATTRIBUTE_UNUSED;
+obj_coff_scl (int ignore ATTRIBUTE_UNUSED)
{
if (def_symbol_in_progress == NULL)
{
as_warn (_(".scl pseudo-op used outside of .def/.endef ignored."));
demand_empty_rest_of_line ();
return;
- } /* if not inside .def/.endef */
+ }
S_SET_STORAGE_CLASS (def_symbol_in_progress, get_absolute_expression ());
demand_empty_rest_of_line ();
}
static void
-obj_coff_tag (ignore)
- int ignore ATTRIBUTE_UNUSED;
+obj_coff_tag (int ignore ATTRIBUTE_UNUSED)
{
char *symbol_name;
char name_end;
#endif
/* Assume that the symbol referred to by .tag is always defined.
- This was a bad assumption. I've added find_or_make. xoxorich. */
+ This was a bad assumption. I've added find_or_make. xoxorich. */
SA_SET_SYM_TAGNDX (def_symbol_in_progress,
tag_find_or_make (symbol_name));
if (SA_GET_SYM_TAGNDX (def_symbol_in_progress) == 0L)
- {
- as_warn (_("tag not found for .tag %s"), symbol_name);
- } /* not defined */
+ as_warn (_("tag not found for .tag %s"), symbol_name);
SF_SET_TAGGED (def_symbol_in_progress);
*input_line_pointer = name_end;
}
static void
-obj_coff_type (ignore)
- int ignore ATTRIBUTE_UNUSED;
+obj_coff_type (int ignore ATTRIBUTE_UNUSED)
{
if (def_symbol_in_progress == NULL)
{
as_warn (_(".type pseudo-op used outside of .def/.endef ignored."));
demand_empty_rest_of_line ();
return;
- } /* if not inside .def/.endef */
+ }
S_SET_DATA_TYPE (def_symbol_in_progress, get_absolute_expression ());
if (ISFCN (S_GET_DATA_TYPE (def_symbol_in_progress)) &&
S_GET_STORAGE_CLASS (def_symbol_in_progress) != C_TPDEF)
- {
- SF_SET_FUNCTION (def_symbol_in_progress);
- } /* is a function */
+ SF_SET_FUNCTION (def_symbol_in_progress);
demand_empty_rest_of_line ();
}
static void
-obj_coff_val (ignore)
- int ignore ATTRIBUTE_UNUSED;
+obj_coff_val (int ignore ATTRIBUTE_UNUSED)
{
if (def_symbol_in_progress == NULL)
{
as_warn (_(".val pseudo-op used outside of .def/.endef ignored."));
demand_empty_rest_of_line ();
return;
- } /* if not inside .def/.endef */
+ }
if (is_name_beginner (*input_line_pointer))
{
#ifdef tc_canonicalize_symbol_name
symbol_name = tc_canonicalize_symbol_name (symbol_name);
#endif
- if (!strcmp (symbol_name, "."))
+ if (streq (symbol_name, "."))
{
+ /* If the .val is != from the .def (e.g. statics). */
symbol_set_frag (def_symbol_in_progress, frag_now);
S_SET_VALUE (def_symbol_in_progress, (valueT) frag_now_fix ());
- /* If the .val is != from the .def (e.g. statics) */
}
- else if (strcmp (S_GET_NAME (def_symbol_in_progress), symbol_name))
+ else if (! streq (S_GET_NAME (def_symbol_in_progress), symbol_name))
{
expressionS exp;
just below. */
}
/* Otherwise, it is the name of a non debug symbol and its value
- will be calculated later. */
+ will be calculated later. */
*input_line_pointer = name_end;
}
else
{
S_SET_VALUE (def_symbol_in_progress, get_absolute_expression ());
- } /* if symbol based */
+ }
+
+ demand_empty_rest_of_line ();
+}
+
+#ifdef TE_PE
+
+/* Return nonzero if name begins with weak alternate symbol prefix. */
+
+static int
+weak_is_altname (const char * name)
+{
+ return strneq (name, weak_altprefix, sizeof (weak_altprefix) - 1);
+}
+
+/* Return the name of the alternate symbol
+ name corresponding to a weak symbol's name. */
+
+static const char *
+weak_name2altname (const char * name)
+{
+ char *alt_name;
+
+ alt_name = xmalloc (sizeof (weak_altprefix) + strlen (name));
+ strcpy (alt_name, weak_altprefix);
+ return strcat (alt_name, name);
+}
+
+/* Return the name of the weak symbol corresponding to an
+ alterate symbol. */
+
+static const char *
+weak_altname2name (const char * name)
+{
+ char * weak_name;
+ char * dot;
+
+ assert (weak_is_altname (name));
+
+ weak_name = xstrdup (name + 6);
+ if ((dot = strchr (weak_name, '.')))
+ *dot = 0;
+ return weak_name;
+}
+
+/* Make a weak symbol name unique by
+ appending the name of an external symbol. */
+
+static const char *
+weak_uniquify (const char * name)
+{
+ char *ret;
+ const char * unique = "";
+
+#ifdef USE_UNIQUE
+ if (an_external_name != NULL)
+ unique = an_external_name;
+#endif
+ assert (weak_is_altname (name));
+
+ if (strchr (name + sizeof (weak_altprefix), '.'))
+ return name;
+
+ ret = xmalloc (strlen (name) + strlen (unique) + 2);
+ strcpy (ret, name);
+ strcat (ret, ".");
+ strcat (ret, unique);
+ return ret;
+}
+
+#endif /* TE_PE */
+
+/* Handle .weak. This is a GNU extension in formats other than PE. */
+
+static void
+obj_coff_weak (int ignore ATTRIBUTE_UNUSED)
+{
+ char *name;
+ int c;
+ symbolS *symbolP;
+#ifdef TE_PE
+ symbolS *alternateP;
+#endif
+
+ do
+ {
+ name = input_line_pointer;
+ c = get_symbol_end ();
+ if (*name == 0)
+ {
+ as_warn (_("badly formed .weak directive ignored"));
+ ignore_rest_of_line ();
+ return;
+ }
+ c = 0;
+ symbolP = symbol_find_or_make (name);
+ *input_line_pointer = c;
+ SKIP_WHITESPACE ();
+
+#if defined BFD_ASSEMBLER || defined S_SET_WEAK
+ S_SET_WEAK (symbolP);
+#endif
+
+#ifdef TE_PE
+ /* See _Microsoft Portable Executable and Common Object
+ File Format Specification_, section 5.5.3.
+ Create a symbol representing the alternate value.
+ coff_frob_symbol will set the value of this symbol from
+ the value of the weak symbol itself. */
+ S_SET_STORAGE_CLASS (symbolP, C_NT_WEAK);
+ S_SET_NUMBER_AUXILIARY (symbolP, 1);
+ SA_SET_SYM_FSIZE (symbolP, IMAGE_WEAK_EXTERN_SEARCH_LIBRARY);
+
+ alternateP = symbol_find_or_make (weak_name2altname (name));
+ S_SET_EXTERNAL (alternateP);
+ S_SET_STORAGE_CLASS (alternateP, C_NT_WEAK);
+
+ SA_SET_SYM_TAGNDX (symbolP, alternateP);
+#endif
+
+ if (c == ',')
+ {
+ input_line_pointer++;
+ SKIP_WHITESPACE ();
+ if (*input_line_pointer == '\n')
+ c = '\n';
+ }
+
+ }
+ while (c == ',');
demand_empty_rest_of_line ();
}
void
-coff_obj_read_begin_hook ()
+coff_obj_read_begin_hook (void)
{
- /* These had better be the same. Usually 18 bytes. */
+ /* These had better be the same. Usually 18 bytes. */
#ifndef BFD_HEADERS
know (sizeof (SYMENT) == sizeof (AUXENT));
know (SYMESZ == AUXESZ);
tag_init ();
}
-
symbolS *coff_last_function;
+#ifndef OBJ_XCOFF
static symbolS *coff_last_bf;
+#endif
void
-coff_frob_symbol (symp, punt)
- symbolS *symp;
- int *punt;
+coff_frob_symbol (symbolS *symp, int *punt)
{
static symbolS *last_tagP;
static stack *block_stack;
}
if (current_lineno_sym)
- coff_add_linesym ((symbolS *) 0);
+ coff_add_linesym (NULL);
if (!block_stack)
block_stack = stack_init (512, sizeof (symbolS*));
- if (S_IS_WEAK (symp))
- {
#ifdef TE_PE
- S_SET_STORAGE_CLASS (symp, C_NT_WEAK);
-#else
- S_SET_STORAGE_CLASS (symp, C_WEAKEXT);
-#endif
+ if (S_GET_STORAGE_CLASS (symp) == C_NT_WEAK
+ && ! S_IS_WEAK (symp)
+ && weak_is_altname (S_GET_NAME (symp)))
+ {
+ /* This is a weak alternate symbol. All processing of
+ PECOFFweak symbols is done here, through the alternate. */
+ symbolS *weakp = symbol_find (weak_altname2name (S_GET_NAME (symp)));
+
+ assert (weakp);
+ assert (S_GET_NUMBER_AUXILIARY (weakp) == 1);
+
+ if (symbol_equated_p (weakp))
+ {
+ /* The weak symbol has an alternate specified; symp is unneeded. */
+ S_SET_STORAGE_CLASS (weakp, C_NT_WEAK);
+ SA_SET_SYM_TAGNDX (weakp,
+ symbol_get_value_expression (weakp)->X_add_symbol);
+
+ S_CLEAR_EXTERNAL (symp);
+ *punt = 1;
+ return;
+ }
+ else
+ {
+ /* The weak symbol has been assigned an alternate value.
+ Copy this value to symp, and set symp as weakp's alternate. */
+ if (S_GET_STORAGE_CLASS (weakp) != C_NT_WEAK)
+ {
+ S_SET_STORAGE_CLASS (symp, S_GET_STORAGE_CLASS (weakp));
+ S_SET_STORAGE_CLASS (weakp, C_NT_WEAK);
+ }
+
+ if (S_IS_DEFINED (weakp))
+ {
+ /* This is a defined weak symbol. Copy value information
+ from the weak symbol itself to the alternate symbol. */
+ symbol_set_value_expression (symp,
+ symbol_get_value_expression (weakp));
+ symbol_set_frag (symp, symbol_get_frag (weakp));
+ S_SET_SEGMENT (symp, S_GET_SEGMENT (weakp));
+ }
+ else
+ {
+ /* This is an undefined weak symbol.
+ Define the alternate symbol to zero. */
+ S_SET_VALUE (symp, 0);
+ S_SET_SEGMENT (symp, absolute_section);
+ }
+
+ S_SET_NAME (symp, weak_uniquify (S_GET_NAME (symp)));
+ S_SET_STORAGE_CLASS (symp, C_EXT);
+
+ S_SET_VALUE (weakp, 0);
+ S_SET_SEGMENT (weakp, undefined_section);
+ }
}
+#else /* TE_PE */
+ if (S_IS_WEAK (symp))
+ S_SET_STORAGE_CLASS (symp, C_WEAKEXT);
+#endif /* TE_PE */
if (!S_IS_DEFINED (symp)
&& !S_IS_WEAK (symp)
if (!SF_GET_DEBUG (symp))
{
- symbolS *real;
+ symbolS * real;
+
if (!SF_GET_LOCAL (symp)
&& !SF_GET_STATICS (symp)
- && (real = symbol_find_base (S_GET_NAME (symp), DO_NOT_STRIP))
+ && S_GET_STORAGE_CLASS (symp) != C_LABEL
+ && symbol_constant_p (symp)
+ && (real = symbol_find (S_GET_NAME (symp)))
+ && S_GET_STORAGE_CLASS (real) == C_NULL
&& real != symp)
{
c_symbol_merge (symp, real);
*punt = 1;
+ return;
}
+
if (!S_IS_DEFINED (symp) && !SF_GET_LOCAL (symp))
{
assert (S_GET_VALUE (symp) == 0);
else
S_SET_STORAGE_CLASS (symp, C_STAT);
}
+
if (SF_GET_PROCESS (symp))
{
if (S_GET_STORAGE_CLASS (symp) == C_BLOCK)
{
- if (!strcmp (S_GET_NAME (symp), ".bb"))
+ if (streq (S_GET_NAME (symp), ".bb"))
stack_push (block_stack, (char *) &symp);
else
{
symbolS *begin;
+
begin = *(symbolS **) stack_pop (block_stack);
if (begin == 0)
as_warn (_("mismatched .eb"));
next_set_end = begin;
}
}
+
if (coff_last_function == 0 && SF_GET_FUNCTION (symp))
{
union internal_auxent *auxp;
+
coff_last_function = symp;
if (S_GET_NUMBER_AUXILIARY (symp) < 1)
S_SET_NUMBER_AUXILIARY (symp, 1);
memset (auxp->x_sym.x_fcnary.x_ary.x_dimen, 0,
sizeof (auxp->x_sym.x_fcnary.x_ary.x_dimen));
}
+
if (S_GET_STORAGE_CLASS (symp) == C_EFCN)
{
if (coff_last_function == 0)
- as_fatal (_("C_EFCN symbol out of scope"));
+ as_fatal (_("C_EFCN symbol for %s out of scope"),
+ S_GET_NAME (symp));
SA_SET_SYM_FSIZE (coff_last_function,
(long) (S_GET_VALUE (symp)
- S_GET_VALUE (coff_last_function)));
coff_last_function = 0;
}
}
+
if (S_IS_EXTERNAL (symp))
S_SET_STORAGE_CLASS (symp, C_EXT);
else if (SF_GET_LOCAL (symp))
if (SF_GET_FUNCTION (symp))
symbol_get_bfdsym (symp)->flags |= BSF_FUNCTION;
-
- /* more ... */
}
/* Double check weak symbols. */
order to call SA_SET_SYM_ENDNDX correctly. */
if (! symbol_used_in_reloc_p (symp)
&& ((symbol_get_bfdsym (symp)->flags & BSF_SECTION_SYM) != 0
- || (! S_IS_EXTERNAL (symp)
+ || (! (S_IS_EXTERNAL (symp) || S_IS_WEAK (symp))
&& ! symbol_get_tc (symp)->output
&& S_GET_STORAGE_CLASS (symp) != C_FILE)))
*punt = 1;
set_end = next_set_end;
}
+#ifndef OBJ_XCOFF
if (! *punt
&& S_GET_STORAGE_CLASS (symp) == C_FCN
- && strcmp (S_GET_NAME (symp), ".bf") == 0)
+ && streq (S_GET_NAME (symp), ".bf"))
{
if (coff_last_bf != NULL)
SA_SET_SYM_ENDNDX (coff_last_bf, symp);
coff_last_bf = symp;
}
-
+#endif
if (coffsymbol (symbol_get_bfdsym (symp))->lineno)
{
int i;
/* We need i entries for line numbers, plus 1 for the first
entry which BFD will override, plus 1 for the last zero
entry (a marker for BFD). */
- l = (alent *) xmalloc ((i + 2) * sizeof (alent));
+ l = xmalloc ((i + 2) * sizeof (* l));
coffsymbol (symbol_get_bfdsym (symp))->lineno = l;
l[i + 1].line_number = 0;
l[i + 1].u.sym = NULL;
for (; i > 0; i--)
{
if (lptr->frag)
- lptr->l.u.offset += lptr->frag->fr_address;
+ lptr->l.u.offset += lptr->frag->fr_address / OCTETS_PER_BYTE;
l[i] = lptr->l;
lptr = lptr->next;
}
}
void
-coff_adjust_section_syms (abfd, sec, x)
- bfd *abfd ATTRIBUTE_UNUSED;
- asection *sec;
- PTR x ATTRIBUTE_UNUSED;
+coff_adjust_section_syms (bfd *abfd ATTRIBUTE_UNUSED,
+ asection *sec,
+ void * x ATTRIBUTE_UNUSED)
{
symbolS *secsym;
segment_info_type *seginfo = seg_info (sec);
if (seginfo == NULL)
return;
- if (!strcmp (sec->name, ".text"))
+ if (streq (sec->name, ".text"))
nlnno = coff_n_line_nos;
else
nlnno = 0;
fixp = fixp->fx_next;
}
}
- if (bfd_get_section_size_before_reloc (sec) == 0
+ if (bfd_get_section_size (sec) == 0
&& nrelocs == 0
&& nlnno == 0
&& sec != text_section
&& sec != data_section
&& sec != bss_section)
return;
+
secsym = section_symbol (sec);
/* This is an estimate; we'll plug in the real value using
SET_SECTION_RELOCS later */
}
void
-coff_frob_file_after_relocs ()
+coff_frob_file_after_relocs (void)
{
- bfd_map_over_sections (stdoutput, coff_adjust_section_syms, (char*) 0);
+ bfd_map_over_sections (stdoutput, coff_adjust_section_syms, NULL);
}
-/*
- * implement the .section pseudo op:
- * .section name {, "flags"}
- * ^ ^
- * | +--- optional flags: 'b' for bss
- * | 'i' for info
- * +-- section name 'l' for lib
- * 'n' for noload
- * 'o' for over
- * 'w' for data
- * 'd' (apparently m88k for data)
- * 'x' for text
- * 'r' for read-only data
- * 's' for shared data (PE)
- * But if the argument is not a quoted string, treat it as a
- * subsegment number.
- */
+/* Implement the .section pseudo op:
+ .section name {, "flags"}
+ ^ ^
+ | +--- optional flags: 'b' for bss
+ | 'i' for info
+ +-- section name 'l' for lib
+ 'n' for noload
+ 'o' for over
+ 'w' for data
+ 'd' (apparently m88k for data)
+ 'x' for text
+ 'r' for read-only data
+ 's' for shared data (PE)
+ But if the argument is not a quoted string, treat it as a
+ subsegment number.
+
+ Note the 'a' flag is silently ignored. This allows the same
+ .section directive to be parsed in both ELF and COFF formats. */
void
-obj_coff_section (ignore)
- int ignore ATTRIBUTE_UNUSED;
+obj_coff_section (int ignore ATTRIBUTE_UNUSED)
{
- /* Strip out the section name */
+ /* Strip out the section name. */
char *section_name;
char c;
char *name;
unsigned int exp;
- flagword flags;
+ flagword flags, oldflags;
asection *sec;
if (flag_mri)
SKIP_WHITESPACE ();
exp = 0;
- flags = SEC_LOAD;
+ flags = SEC_NO_FLAGS;
if (*input_line_pointer == ',')
{
switch (*input_line_pointer)
{
case 'b': flags |= SEC_ALLOC; flags &=~ SEC_LOAD; break;
- case 'n': flags &=~ SEC_LOAD; break;
- case 'd': flags |= SEC_DATA | SEC_LOAD; /* fall through */
+ case 'n': flags &=~ SEC_LOAD; flags |= SEC_NEVER_LOAD; break;
+
+ case 's': flags |= SEC_COFF_SHARED; /* Fall through. */
+ case 'd': flags |= SEC_DATA | SEC_LOAD; /* Fall through. */
case 'w': flags &=~ SEC_READONLY; break;
+
+ case 'a': break; /* For compatibility with ELF. */
case 'x': flags |= SEC_CODE | SEC_LOAD; break;
- case 'r': flags |= SEC_READONLY; break;
- case 's': flags |= SEC_SHARED; break;
+ case 'r': flags |= SEC_DATA | SEC_LOAD | SEC_READONLY; break;
case 'i': /* STYP_INFO */
case 'l': /* STYP_LIB */
break;
default:
- as_warn(_("unknown section attribute '%c'"),
- *input_line_pointer);
+ as_warn (_("unknown section attribute '%c'"),
+ *input_line_pointer);
break;
}
++input_line_pointer;
sec = subseg_new (name, (subsegT) exp);
- if (flags != SEC_NO_FLAGS)
+ oldflags = bfd_get_section_flags (stdoutput, sec);
+ if (oldflags == SEC_NO_FLAGS)
{
- flagword oldflags;
+ /* Set section flags for a new section just created by subseg_new.
+ Provide a default if no flags were parsed. */
+ if (flags == SEC_NO_FLAGS)
+ flags = TC_COFF_SECTION_DEFAULT_ATTRIBUTES;
- oldflags = bfd_get_section_flags (stdoutput, sec);
- oldflags &= SEC_LINK_ONCE | SEC_LINK_DUPLICATES;
- flags |= oldflags;
+#ifdef COFF_LONG_SECTION_NAMES
+ /* Add SEC_LINK_ONCE and SEC_LINK_DUPLICATES_DISCARD to .gnu.linkonce
+ sections so adjust_reloc_syms in write.c will correctly handle
+ relocs which refer to non-local symbols in these sections. */
+ if (strneq (name, ".gnu.linkonce", sizeof (".gnu.linkonce") - 1))
+ flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
+#endif
if (! bfd_set_section_flags (stdoutput, sec, flags))
as_warn (_("error setting flags for \"%s\": %s"),
bfd_section_name (stdoutput, sec),
bfd_errmsg (bfd_get_error ()));
}
+ else if (flags != SEC_NO_FLAGS)
+ {
+ /* This section's attributes have already been set. Warn if the
+ attributes don't match. */
+ flagword matchflags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE
+ | SEC_DATA | SEC_COFF_SHARED | SEC_NEVER_LOAD);
+ if ((flags ^ oldflags) & matchflags)
+ as_warn (_("Ignoring changed section attributes for %s"), name);
+ }
demand_empty_rest_of_line ();
}
void
-coff_adjust_symtab ()
+coff_adjust_symtab (void)
{
if (symbol_rootP == NULL
|| S_GET_STORAGE_CLASS (symbol_rootP) != C_FILE)
- c_dot_file_symbol ("fake");
+ c_dot_file_symbol ("fake", 0);
}
void
-coff_frob_section (sec)
- segT sec;
+coff_frob_section (segT sec)
{
segT strsec;
char *p;
fragS *fragp;
bfd_vma size, n_entries, mask;
+ bfd_vma align_power = (bfd_vma)sec->alignment_power + OCTETS_PER_BYTE_POWER;
/* The COFF back end in BFD requires that all section sizes be
- rounded up to multiples of the corresponding section alignments.
- Seems kinda silly to me, but that's the way it is. */
- size = bfd_get_section_size_before_reloc (sec);
- mask = ((bfd_vma) 1 << (bfd_vma) sec->alignment_power) - 1;
+ rounded up to multiples of the corresponding section alignments,
+ supposedly because standard COFF has no other way of encoding alignment
+ for sections. If your COFF flavor has a different way of encoding
+ section alignment, then skip this step, as TICOFF does. */
+ size = bfd_get_section_size (sec);
+ mask = ((bfd_vma) 1 << align_power) - 1;
+#if !defined(TICOFF)
if (size & mask)
{
- size = (size + mask) & ~mask;
- bfd_set_section_size (stdoutput, sec, size);
+ bfd_vma new_size;
+ fragS *last;
+
+ new_size = (size + mask) & ~mask;
+ bfd_set_section_size (stdoutput, sec, new_size);
+
+ /* If the size had to be rounded up, add some padding in
+ the last non-empty frag. */
+ fragp = seg_info (sec)->frchainP->frch_root;
+ last = seg_info (sec)->frchainP->frch_last;
+ while (fragp->fr_next != last)
+ fragp = fragp->fr_next;
+ last->fr_address = size;
+ fragp->fr_offset += new_size - size;
}
+#endif
/* If the section size is non-zero, the section symbol needs an aux
entry associated with it, indicating the size. We don't know
all the values yet; coff_frob_symbol will fill them in later. */
+#ifndef TICOFF
if (size != 0
|| sec == text_section
|| sec == data_section
|| sec == bss_section)
+#endif
{
symbolS *secsym = section_symbol (sec);
SA_SET_SCN_SCNLEN (secsym, size);
}
- /* @@ these should be in a "stabs.h" file, or maybe as.h */
+ /* FIXME: These should be in a "stabs.h" file, or maybe as.h. */
#ifndef STAB_SECTION_NAME
#define STAB_SECTION_NAME ".stab"
#endif
#ifndef STAB_STRING_SECTION_NAME
#define STAB_STRING_SECTION_NAME ".stabstr"
#endif
- if (strcmp (STAB_STRING_SECTION_NAME, sec->name))
+ if (! streq (STAB_STRING_SECTION_NAME, sec->name))
return;
strsec = sec;
sec = subseg_get (STAB_SECTION_NAME, 0);
/* size is already rounded up, since other section will be listed first */
- size = bfd_get_section_size_before_reloc (strsec);
+ size = bfd_get_section_size (strsec);
- n_entries = bfd_get_section_size_before_reloc (sec) / 12 - 1;
+ n_entries = bfd_get_section_size (sec) / 12 - 1;
/* Find first non-empty frag. It should be large enough. */
fragp = seg_info (sec)->frchainP->frch_root;
}
void
-obj_coff_init_stab_section (seg)
- segT seg;
+obj_coff_init_stab_section (segT seg)
{
char *file;
char *p;
char *stabstr_name;
unsigned int stroff;
- /* Make space for this first symbol. */
+ /* Make space for this first symbol. */
p = frag_more (12);
- /* Zero it out. */
+ /* Zero it out. */
memset (p, 0, 12);
as_where (&file, (unsigned int *) NULL);
- stabstr_name = (char *) alloca (strlen (seg->name) + 4);
+ stabstr_name = xmalloc (strlen (seg->name) + 4);
strcpy (stabstr_name, seg->name);
strcat (stabstr_name, "str");
stroff = get_stab_string_offset (file, stabstr_name);
}
#ifdef DEBUG
-/* for debugging */
const char *
-s_get_name (s)
- symbolS *s;
+s_get_name (symbolS *s)
{
return ((s == NULL) ? "(NULL)" : S_GET_NAME (s));
}
void
-symbol_dump ()
+symbol_dump (void)
{
symbolS *symbolP;
for (symbolP = symbol_rootP; symbolP; symbolP = symbol_next (symbolP))
- {
- printf(_("0x%lx: \"%s\" type = %ld, class = %d, segment = %d\n"),
- (unsigned long) symbolP,
- S_GET_NAME(symbolP),
- (long) S_GET_DATA_TYPE(symbolP),
- S_GET_STORAGE_CLASS(symbolP),
- (int) S_GET_SEGMENT(symbolP));
- }
+ printf (_("0x%lx: \"%s\" type = %ld, class = %d, segment = %d\n"),
+ (unsigned long) symbolP,
+ S_GET_NAME (symbolP),
+ (long) S_GET_DATA_TYPE (symbolP),
+ S_GET_STORAGE_CLASS (symbolP),
+ (int) S_GET_SEGMENT (symbolP));
}
#endif /* DEBUG */
#else /* not BFD_ASSEMBLER */
#include "frags.h"
-/* This is needed because we include internal bfd things. */
+/* This is needed because we include internal bfd things. */
#include <time.h>
#include "libbfd.h"
#include "libcoff.h"
-#ifdef TE_PE
-#include "coff/pe.h"
-#endif
-
/* The NOP_OPCODE is for the alignment fill value. Fill with nop so
that we can stick sections together without causing trouble. */
#ifndef NOP_OPCODE
int function_lineoff = -1; /* Offset in line#s where the last function
started (the odd entry for line #0) */
-/* structure used to keep the filenames which
+/* Structure used to keep the filenames which
are too long around so that we can stick them
- into the string table */
-struct filename_list
+ into the string table. */
+struct filename_list
{
- char *filename;
+ const char *filename;
struct filename_list *next;
};
/* Add 4 to the real value to get the index and compensate the
negatives. This vector is used by S_GET_SEGMENT to turn a coff
- section number into a segment number
-*/
-static symbolS *previous_file_symbol;
-void c_symbol_merge ();
-static int line_base;
+ section number into a segment number. */
-symbolS *c_section_symbol ();
bfd *abfd;
+static symbolS *previous_file_symbol;
+static int line_base;
-static void fixup_segment PARAMS ((segment_info_type *segP,
- segT this_segment_type));
-
-
-static void fixup_mdeps PARAMS ((fragS *,
- object_headers *,
- segT));
-
+/* When not using BFD_ASSEMBLER, we permit up to 40 sections.
-static void fill_section PARAMS ((bfd * abfd,
- object_headers *,
- unsigned long *));
-
-
-static int c_line_new PARAMS ((symbolS * symbol, long paddr,
- int line_number,
- fragS * frag));
-
-
-static void w_symbols PARAMS ((bfd * abfd, char *where,
- symbolS * symbol_rootP));
-
-static void adjust_stab_section PARAMS ((bfd *abfd, segT seg));
-
-static void obj_coff_lcomm PARAMS ((int));
-static void obj_coff_text PARAMS ((int));
-static void obj_coff_data PARAMS ((int));
-void obj_coff_section PARAMS ((int));
-
-/* When not using BFD_ASSEMBLER, we permit up to 40 sections.
-
- This array maps a COFF section number into a gas section number.
- Because COFF uses negative section numbers, you must add 4 to the
- COFF section number when indexing into this array; this is done via
- the SEG_INFO_FROM_SECTION_NUMBER macro. This must correspond to
- seg_N_TYPE. */
+ This array maps a COFF section number into a gas section number.
+ Because COFF uses negative section numbers, you must add 4 to the
+ COFF section number when indexing into this array; this is done via
+ the SEG_INFO_FROM_SECTION_NUMBER macro. This must correspond to
+ seg_N_TYPE. */
static const segT seg_info_off_by_4[] =
{
#define SEG_INFO_FROM_SECTION_NUMBER(x) (seg_info_off_by_4[(x)+4])
static relax_addressT
-relax_align (address, alignment)
- relax_addressT address;
- long alignment;
+relax_align (relax_addressT address, long alignment)
{
relax_addressT mask;
relax_addressT new_address;
mask = ~((~0) << alignment);
new_address = (address + mask) & (~mask);
- return (new_address - address);
-}
+ return new_address - address;
+}
segT
-s_get_segment (x)
- symbolS * x;
+s_get_segment (symbolS * x)
{
return SEG_INFO_FROM_SECTION_NUMBER (x->sy_symbol.ost_entry.n_scnum);
}
-/* calculate the size of the frag chain and fill in the section header
- to contain all of it, also fill in the addr of the sections */
+/* Calculate the size of the frag chain and fill in the section header
+ to contain all of it, also fill in the addr of the sections. */
+
static unsigned int
-size_section (abfd, idx)
- bfd *abfd ATTRIBUTE_UNUSED;
- unsigned int idx;
+size_section (bfd *abfd ATTRIBUTE_UNUSED, unsigned int idx)
{
-
unsigned int size = 0;
fragS *frag = segment_info[idx].frchainP->frch_root;
+
while (frag)
{
size = frag->fr_address;
break;
#endif
case rs_space:
- assert (frag->fr_symbol == 0);
case rs_fill:
case rs_org:
size += frag->fr_fix;
break;
case rs_align:
case rs_align_code:
+ case rs_align_test:
{
addressT off;
return size;
}
-
static unsigned int
-count_entries_in_chain (idx)
- unsigned int idx;
+count_entries_in_chain (unsigned int idx)
{
unsigned int nrelocs;
fixS *fixup_ptr;
- /* Count the relocations */
+ /* Count the relocations. */
fixup_ptr = segment_info[idx].fix_root;
nrelocs = 0;
while (fixup_ptr != (fixS *) NULL)
{
if (fixup_ptr->fx_done == 0 && TC_COUNT_RELOC (fixup_ptr))
{
-#ifdef TC_A29K
+#if defined(TC_A29K) || defined(TC_OR32)
if (fixup_ptr->fx_r_type == RELOC_CONSTH)
nrelocs += 2;
else
#ifdef TE_AUX
-static int compare_external_relocs PARAMS ((const PTR, const PTR));
+/* AUX's ld expects relocations to be sorted. */
-/* AUX's ld expects relocations to be sorted */
static int
-compare_external_relocs (x, y)
- const PTR x;
- const PTR y;
+compare_external_relocs (const void * x, const void * y)
{
struct external_reloc *a = (struct external_reloc *) x;
struct external_reloc *b = (struct external_reloc *) y;
bfd_vma aadr = bfd_getb32 (a->r_vaddr);
bfd_vma badr = bfd_getb32 (b->r_vaddr);
+
return (aadr < badr ? -1 : badr < aadr ? 1 : 0);
}
#endif
-/* output all the relocations for a section */
-void
-do_relocs_for (abfd, h, file_cursor)
- bfd * abfd;
- object_headers * h;
- unsigned long *file_cursor;
+/* Output all the relocations for a section. */
+
+static void
+do_relocs_for (bfd * abfd, object_headers * h, unsigned long *file_cursor)
{
unsigned int nrelocs;
unsigned int idx;
unsigned int external_reloc_size;
unsigned int base = segment_info[idx].scnhdr.s_paddr;
fixS *fix_ptr = segment_info[idx].fix_root;
+
nrelocs = count_entries_in_chain (idx);
if (nrelocs)
avoids a SCO bug, where free(malloc(0)) tends to crash. */
{
external_reloc_size = nrelocs * RELSZ;
- external_reloc_vec =
- (struct external_reloc *) malloc (external_reloc_size);
+ external_reloc_vec = malloc (external_reloc_size);
ext_ptr = external_reloc_vec;
{
struct internal_reloc intr;
- /* Only output some of the relocations */
+ /* Only output some of the relocations. */
if (fix_ptr->fx_done == 0 && TC_COUNT_RELOC (fix_ptr))
{
#ifdef TC_RELOC_MANGLE
TC_RELOC_MANGLE (&segment_info[idx], fix_ptr, &intr,
base);
-
#else
symbolS *dot;
symbolS *symbol_ptr = fix_ptr->fx_addsy;
/* Turn the segment of the symbol into an offset. */
if (symbol_ptr)
{
- resolve_symbol_value (symbol_ptr, 1);
+ resolve_symbol_value (symbol_ptr);
if (! symbol_ptr->sy_resolved)
{
char *file;
as_bad (_("bad relocation: symbol `%s' not in symbol table"),
S_GET_NAME (symbol_ptr));
}
+
dot = segment_info[S_GET_SEGMENT (symbol_ptr)].dot;
if (dot)
- {
- intr.r_symndx = dot->sy_number;
- }
+ intr.r_symndx = dot->sy_number;
else
- {
- intr.r_symndx = symbol_ptr->sy_number;
- }
-
+ intr.r_symndx = symbol_ptr->sy_number;
}
else
- {
- intr.r_symndx = -1;
- }
+ intr.r_symndx = -1;
#endif
-
(void) bfd_coff_swap_reloc_out (abfd, &intr, ext_ptr);
ext_ptr++;
-
#if defined(TC_A29K)
-
/* The 29k has a special kludge for the high 16 bit
- reloc. Two relocations are emited, R_IHIHALF,
+ reloc. Two relocations are emitted, R_IHIHALF,
and R_IHCONST. The second one doesn't contain a
symbol, but uses the value for offset. */
-
if (intr.r_type == R_IHIHALF)
{
- /* now emit the second bit */
+ /* Now emit the second bit. */
intr.r_type = R_IHCONST;
intr.r_symndx = fix_ptr->fx_addnumber;
(void) bfd_coff_swap_reloc_out (abfd, &intr, ext_ptr);
ext_ptr++;
}
+#endif
+#if defined(TC_OR32)
+ /* The or32 has a special kludge for the high 16 bit
+ reloc. Two relocations are emitted, R_IHIHALF,
+ and R_IHCONST. The second one doesn't contain a
+ symbol, but uses the value for offset. */
+ if (intr.r_type == R_IHIHALF)
+ {
+ /* Now emit the second bit. */
+ intr.r_type = R_IHCONST;
+ intr.r_symndx = fix_ptr->fx_addnumber;
+ (void) bfd_coff_swap_reloc_out (abfd, & intr, ext_ptr);
+ ext_ptr ++;
+ }
#endif
}
fix_ptr = fix_ptr->fx_next;
}
-
#ifdef TE_AUX
- /* Sort the reloc table */
- qsort ((PTR) external_reloc_vec, nrelocs,
+ /* Sort the reloc table. */
+ qsort ((void *) external_reloc_vec, nrelocs,
sizeof (struct external_reloc), compare_external_relocs);
#endif
-
- /* Write out the reloc table */
- bfd_write ((PTR) external_reloc_vec, 1, external_reloc_size,
- abfd);
+ /* Write out the reloc table. */
+ bfd_bwrite ((void *) external_reloc_vec,
+ (bfd_size_type) external_reloc_size, abfd);
free (external_reloc_vec);
/* Fill in section header info. */
}
else
{
- /* No relocs */
+ /* No relocs. */
segment_info[idx].scnhdr.s_relptr = 0;
}
}
}
- /* Set relocation_size field in file headers */
+
+ /* Set relocation_size field in file headers. */
H_SET_RELOCATION_SIZE (h, *file_cursor - reloc_start, 0);
}
+/* Run through a frag chain and write out the data to go with it, fill
+ in the scnhdrs with the info on the file positions. */
-/* run through a frag chain and write out the data to go with it, fill
- in the scnhdrs with the info on the file postions
-*/
static void
-fill_section (abfd, h, file_cursor)
- bfd * abfd;
- object_headers *h ATTRIBUTE_UNUSED;
- unsigned long *file_cursor;
+fill_section (bfd * abfd,
+ object_headers *h ATTRIBUTE_UNUSED,
+ unsigned long *file_cursor)
{
-
unsigned int i;
unsigned int paddr = 0;
if (s->s_name[0])
{
fragS *frag = segment_info[i].frchainP->frch_root;
- char *buffer;
+ char *buffer = NULL;
if (s->s_size == 0)
s->s_scnptr = 0;
}
know (s->s_paddr == paddr);
- if (strcmp (s->s_name, ".text") == 0)
+ if (streq (s->s_name, ".text"))
s->s_flags |= STYP_TEXT;
- else if (strcmp (s->s_name, ".data") == 0)
+ else if (streq (s->s_name, ".data"))
s->s_flags |= STYP_DATA;
- else if (strcmp (s->s_name, ".bss") == 0)
+ else if (streq (s->s_name, ".bss"))
{
s->s_scnptr = 0;
s->s_flags |= STYP_BSS;
COFF_NOLOAD_PROBLEM, and have only one test here. */
#ifndef TC_I386
#ifndef TC_A29K
+#ifndef TC_OR32
#ifndef COFF_NOLOAD_PROBLEM
/* Apparently the SVR3 linker (and exec syscall) and UDI
mondfe progrem are confused by noload sections. */
s->s_flags |= STYP_NOLOAD;
#endif
#endif
+#endif
#endif
}
- else if (strcmp (s->s_name, ".lit") == 0)
+ else if (streq (s->s_name, ".lit"))
s->s_flags = STYP_LIT | STYP_TEXT;
- else if (strcmp (s->s_name, ".init") == 0)
+ else if (streq (s->s_name, ".init"))
s->s_flags |= STYP_TEXT;
- else if (strcmp (s->s_name, ".fini") == 0)
+ else if (streq (s->s_name, ".fini"))
s->s_flags |= STYP_TEXT;
- else if (strncmp (s->s_name, ".comment", 8) == 0)
+ else if (strneq (s->s_name, ".comment", 8))
s->s_flags |= STYP_INFO;
while (frag)
{
unsigned int fill_size;
+
switch (frag->fr_type)
{
case rs_machine_dependent:
break;
case rs_space:
- assert (frag->fr_symbol == 0);
case rs_fill:
case rs_align:
case rs_align_code:
+ case rs_align_test:
case rs_org:
if (frag->fr_fix)
{
{
unsigned int count;
unsigned int off = frag->fr_fix;
+
for (count = frag->fr_offset; count; count--)
{
if (fill_size + frag->fr_address + off <= s->s_size)
{
if (s->s_scnptr != 0)
{
- bfd_write (buffer, s->s_size, 1, abfd);
+ bfd_bwrite (buffer, s->s_size, abfd);
*file_cursor += s->s_size;
}
free (buffer);
}
}
-/* Coff file generation & utilities */
+/* Coff file generation & utilities. */
static void
-coff_header_append (abfd, h)
- bfd * abfd;
- object_headers * h;
+coff_header_append (bfd * abfd, object_headers * h)
{
unsigned int i;
char buffer[1000];
H_SET_ENTRY_POINT (h, 0);
H_SET_TEXT_START (h, segment_info[SEG_E0].frchainP->frch_root->fr_address);
H_SET_DATA_START (h, segment_info[SEG_E1].frchainP->frch_root->fr_address);
- H_SET_SIZEOF_OPTIONAL_HEADER (h, bfd_coff_swap_aouthdr_out(abfd, &h->aouthdr,
- buffero));
+ H_SET_SIZEOF_OPTIONAL_HEADER (h, bfd_coff_swap_aouthdr_out (abfd, &h->aouthdr,
+ buffero));
#else /* defined (OBJ_COFF_OMIT_OPTIONAL_HEADER) */
H_SET_SIZEOF_OPTIONAL_HEADER (h, 0);
#endif /* defined (OBJ_COFF_OMIT_OPTIONAL_HEADER) */
i = bfd_coff_swap_filehdr_out (abfd, &h->filehdr, buffer);
- bfd_write (buffer, i, 1, abfd);
- bfd_write (buffero, H_GET_SIZEOF_OPTIONAL_HEADER (h), 1, abfd);
+ bfd_bwrite (buffer, (bfd_size_type) i, abfd);
+ bfd_bwrite (buffero, (bfd_size_type) H_GET_SIZEOF_OPTIONAL_HEADER (h), abfd);
for (i = SEG_E0; i < SEG_LAST; i++)
{
string_size += strlen (segment_info[i].name) + 1;
}
#endif
-
size = bfd_coff_swap_scnhdr_out (abfd,
&(segment_info[i].scnhdr),
buffer);
if (size == 0)
as_bad (_("bfd_coff_swap_scnhdr_out failed"));
- bfd_write (buffer, size, 1, abfd);
+ bfd_bwrite (buffer, (bfd_size_type) size, abfd);
}
}
}
-
-char *
-symbol_to_chars (abfd, where, symbolP)
- bfd * abfd;
- char *where;
- symbolS * symbolP;
+static char *
+symbol_to_chars (bfd * abfd, char * where, symbolS * symbolP)
{
unsigned int numaux = symbolP->sy_symbol.ost_entry.n_numaux;
unsigned int i;
valueT val;
- /* Turn any symbols with register attributes into abs symbols */
+ /* Turn any symbols with register attributes into abs symbols. */
if (S_GET_SEGMENT (symbolP) == reg_section)
- {
- S_SET_SEGMENT (symbolP, absolute_section);
- }
- /* At the same time, relocate all symbols to their output value */
+ S_SET_SEGMENT (symbolP, absolute_section);
+ /* At the same time, relocate all symbols to their output value. */
#ifndef TE_PE
val = (segment_info[S_GET_SEGMENT (symbolP)].scnhdr.s_paddr
+ S_GET_VALUE (symbolP));
S_GET_STORAGE_CLASS (symbolP),
i, numaux, where);
}
- return where;
+ return where;
}
void
-coff_obj_symbol_new_hook (symbolP)
- symbolS *symbolP;
+coff_obj_symbol_new_hook (symbolS *symbolP)
{
- char underscore = 0; /* Symbol has leading _ */
+ char underscore = 0; /* Symbol has leading _ */
- /* Effective symbol */
- /* Store the pointer in the offset. */
+ /* Effective symbol. */
+ /* Store the pointer in the offset. */
S_SET_ZEROES (symbolP, 0L);
S_SET_DATA_TYPE (symbolP, T_NULL);
S_SET_STORAGE_CLASS (symbolP, 0);
S_SET_NUMBER_AUXILIARY (symbolP, 0);
- /* Additional information */
+ /* Additional information. */
symbolP->sy_symbol.ost_flags = 0;
- /* Auxiliary entries */
+ /* Auxiliary entries. */
memset ((char *) &symbolP->sy_symbol.ost_auxent[0], 0, AUXESZ);
if (S_IS_STRING (symbolP))
SF_SET_LOCAL (symbolP);
}
-/*
- * Handle .ln directives.
- */
+static int
+c_line_new (symbolS * symbol, long paddr, int line_number, fragS * frag)
+{
+ struct lineno_list *new_line = xmalloc (sizeof (* new_line));
+
+ segment_info_type *s = segment_info + now_seg;
+ new_line->line.l_lnno = line_number;
+
+ if (line_number == 0)
+ {
+ last_line_symbol = symbol;
+ new_line->line.l_addr.l_symndx = (long) symbol;
+ }
+ else
+ {
+ new_line->line.l_addr.l_paddr = paddr;
+ }
+
+ new_line->frag = (char *) frag;
+ new_line->next = NULL;
+
+ if (s->lineno_list_head == NULL)
+ s->lineno_list_head = new_line;
+ else
+ s->lineno_list_tail->next = new_line;
+
+ s->lineno_list_tail = new_line;
+ return LINESZ * s->scnhdr.s_nlnno++;
+}
+
+/* Handle .ln directives. */
static void
-obj_coff_ln (appline)
- int appline;
+obj_coff_ln (int appline)
{
int l;
if (! appline && def_symbol_in_progress != NULL)
{
+ /* Wrong context. */
as_warn (_(".ln pseudo-op inside .def/.endef: ignored."));
demand_empty_rest_of_line ();
return;
- } /* wrong context */
+ }
l = get_absolute_expression ();
c_line_new (0, frag_now_fix (), l, frag_now);
l += line_base - 1;
listing_source_line ((unsigned int) l);
}
-
}
#endif
demand_empty_rest_of_line ();
}
-/*
- * def()
- *
- * Handle .def directives.
- *
- * One might ask : why can't we symbol_new if the symbol does not
- * already exist and fill it with debug information. Because of
- * the C_EFCN special symbol. It would clobber the value of the
- * function symbol before we have a chance to notice that it is
- * a C_EFCN. And a second reason is that the code is more clear this
- * way. (at least I think it is :-).
- *
- */
+/* Handle .def directives.
+
+ One might ask : why can't we symbol_new if the symbol does not
+ already exist and fill it with debug information. Because of
+ the C_EFCN special symbol. It would clobber the value of the
+ function symbol before we have a chance to notice that it is
+ a C_EFCN. And a second reason is that the code is more clear this
+ way. (at least I think it is :-). */
#define SKIP_SEMI_COLON() while (*input_line_pointer++ != ';')
#define SKIP_WHITESPACES() while (*input_line_pointer == ' ' || \
- *input_line_pointer == '\t') \
- input_line_pointer++;
+ *input_line_pointer == '\t') \
+ input_line_pointer++;
static void
-obj_coff_def (what)
- int what ATTRIBUTE_UNUSED;
+obj_coff_def (int what ATTRIBUTE_UNUSED)
{
- char name_end; /* Char after the end of name */
- char *symbol_name; /* Name of the debug symbol */
- char *symbol_name_copy; /* Temporary copy of the name */
+ char name_end; /* Char after the end of name. */
+ char *symbol_name; /* Name of the debug symbol. */
+ char *symbol_name_copy; /* Temporary copy of the name. */
unsigned int symbol_name_length;
if (def_symbol_in_progress != NULL)
as_warn (_(".def pseudo-op used inside of .def/.endef: ignored."));
demand_empty_rest_of_line ();
return;
- } /* if not inside .def/.endef */
+ }
SKIP_WHITESPACES ();
- def_symbol_in_progress = (symbolS *) obstack_alloc (¬es, sizeof (*def_symbol_in_progress));
+ def_symbol_in_progress = obstack_alloc (¬es, sizeof (*def_symbol_in_progress));
memset (def_symbol_in_progress, 0, sizeof (*def_symbol_in_progress));
symbol_name = input_line_pointer;
symbol_name_copy = tc_canonicalize_symbol_name (symbol_name_copy);
#endif
- /* Initialize the new symbol */
-#ifdef STRIP_UNDERSCORE
- S_SET_NAME (def_symbol_in_progress, (*symbol_name_copy == '_'
- ? symbol_name_copy + 1
- : symbol_name_copy));
-#else /* STRIP_UNDERSCORE */
+ /* Initialize the new symbol. */
S_SET_NAME (def_symbol_in_progress, symbol_name_copy);
-#endif /* STRIP_UNDERSCORE */
/* free(symbol_name_copy); */
def_symbol_in_progress->sy_name_offset = (unsigned long) ~0;
def_symbol_in_progress->sy_number = ~0;
demand_empty_rest_of_line ();
}
-unsigned int dim_index;
+static void
+c_symbol_merge (symbolS *debug, symbolS *normal)
+{
+ S_SET_DATA_TYPE (normal, S_GET_DATA_TYPE (debug));
+ S_SET_STORAGE_CLASS (normal, S_GET_STORAGE_CLASS (debug));
+
+ if (S_GET_NUMBER_AUXILIARY (debug) > S_GET_NUMBER_AUXILIARY (normal))
+ S_SET_NUMBER_AUXILIARY (normal, S_GET_NUMBER_AUXILIARY (debug));
+
+ if (S_GET_NUMBER_AUXILIARY (debug) > 0)
+ memcpy ((char *) &normal->sy_symbol.ost_auxent[0],
+ (char *) &debug->sy_symbol.ost_auxent[0],
+ (unsigned int) (S_GET_NUMBER_AUXILIARY (debug) * AUXESZ));
+
+ /* Move the debug flags. */
+ SF_SET_DEBUG_FIELD (normal, SF_GET_DEBUG_FIELD (debug));
+}
+static unsigned int dim_index;
static void
-obj_coff_endef (ignore)
- int ignore ATTRIBUTE_UNUSED;
+obj_coff_endef (int ignore ATTRIBUTE_UNUSED)
{
symbolS *symbolP = 0;
- /* DIM BUG FIX sac@cygnus.com */
+
dim_index = 0;
if (def_symbol_in_progress == NULL)
{
as_warn (_(".endef pseudo-op used outside of .def/.endef: ignored."));
demand_empty_rest_of_line ();
return;
- } /* if not inside .def/.endef */
+ }
- /* Set the section number according to storage class. */
+ /* Set the section number according to storage class. */
switch (S_GET_STORAGE_CLASS (def_symbol_in_progress))
{
case C_STRTAG:
case C_ENTAG:
case C_UNTAG:
SF_SET_TAG (def_symbol_in_progress);
- /* intentional fallthrough */
+ /* Fall through. */
+
case C_FILE:
case C_TPDEF:
SF_SET_DEBUG (def_symbol_in_progress);
break;
case C_EFCN:
- SF_SET_LOCAL (def_symbol_in_progress); /* Do not emit this symbol. */
- /* intentional fallthrough */
+ /* Do not emit this symbol. */
+ SF_SET_LOCAL (def_symbol_in_progress);
+ /* Fall through. */
+
case C_BLOCK:
- SF_SET_PROCESS (def_symbol_in_progress); /* Will need processing before writing */
- /* intentional fallthrough */
+ /* Will need processing before writing. */
+ SF_SET_PROCESS (def_symbol_in_progress);
+ /* Fall through. */
+
case C_FCN:
S_SET_SEGMENT (def_symbol_in_progress, SEG_E0);
- if (strcmp (S_GET_NAME (def_symbol_in_progress), ".bf") == 0)
- { /* .bf */
+ if (streq (S_GET_NAME (def_symbol_in_progress), ".bf"))
+ {
if (function_lineoff < 0)
- {
- fprintf (stderr, _("`.bf' symbol without preceding function\n"));
- } /* missing function symbol */
+ fprintf (stderr, _("`.bf' symbol without preceding function\n"));
+
SA_GET_SYM_LNNOPTR (last_line_symbol) = function_lineoff;
SF_SET_PROCESS (last_line_symbol);
SF_SET_PROCESS (def_symbol_in_progress);
function_lineoff = -1;
}
- /* Value is always set to . */
+
+ /* Value is always set to . */
def_symbol_in_progress->sy_frag = frag_now;
S_SET_VALUE (def_symbol_in_progress, (valueT) frag_now_fix ());
break;
#endif
case C_STAT:
case C_LABEL:
- /* Valid but set somewhere else (s_comm, s_lcomm, colon) */
+ /* Valid but set somewhere else (s_comm, s_lcomm, colon). */
break;
case C_USTATIC:
case C_ULABEL:
as_warn (_("unexpected storage class %d"), S_GET_STORAGE_CLASS (def_symbol_in_progress));
break;
- } /* switch on storage class */
+ }
/* Now that we have built a debug symbol, try to find if we should
merge with an existing symbol or not. If a symbol is C_EFCN or
lineno entry MUST point to the definition function or else it
will point off into space when crawl_symbols() merges the debug
symbol into the real symbol. Therefor, let's presume the debug
- symbol is a real function reference. */
+ symbol is a real function reference. */
/* FIXME-SOON If for some reason the definition label/symbol is
never seen, this will probably leave an undefined symbol at link
- time. */
+ time. */
if (S_GET_STORAGE_CLASS (def_symbol_in_progress) == C_EFCN
|| S_GET_STORAGE_CLASS (def_symbol_in_progress) == C_LABEL
&& !SF_GET_TAG (def_symbol_in_progress))
|| S_GET_SEGMENT (def_symbol_in_progress) == absolute_section
|| def_symbol_in_progress->sy_value.X_op != O_constant
- || (symbolP = symbol_find_base (S_GET_NAME (def_symbol_in_progress), DO_NOT_STRIP)) == NULL
+ || (symbolP = symbol_find (S_GET_NAME (def_symbol_in_progress))) == NULL
|| (SF_GET_TAG (def_symbol_in_progress) != SF_GET_TAG (symbolP)))
{
symbol_append (def_symbol_in_progress, symbol_lastP, &symbol_rootP,
previous definition. */
c_symbol_merge (def_symbol_in_progress, symbolP);
- /* FIXME-SOON Should *def_symbol_in_progress be free'd? xoxorich. */
+ /* FIXME-SOON Should *def_symbol_in_progress be free'd? xoxorich. */
def_symbol_in_progress = symbolP;
if (SF_GET_FUNCTION (def_symbol_in_progress)
{
/* For functions, and tags, and static symbols, the symbol
*must* be where the debug symbol appears. Move the
- existing symbol to the current place. */
- /* If it already is at the end of the symbol list, do nothing */
+ existing symbol to the current place. */
+ /* If it already is at the end of the symbol list, do nothing. */
if (def_symbol_in_progress != symbol_lastP)
{
symbol_remove (def_symbol_in_progress, &symbol_rootP,
&symbol_lastP);
symbol_append (def_symbol_in_progress, symbol_lastP,
&symbol_rootP, &symbol_lastP);
- } /* if not already in place */
- } /* if function */
- } /* normal or mergable */
+ }
+ }
+ }
if (SF_GET_TAG (def_symbol_in_progress))
{
symbolS *oldtag;
- oldtag = symbol_find_base (S_GET_NAME (def_symbol_in_progress),
- DO_NOT_STRIP);
+ oldtag = symbol_find (S_GET_NAME (def_symbol_in_progress));
if (oldtag == NULL || ! SF_GET_TAG (oldtag))
tag_insert (S_GET_NAME (def_symbol_in_progress),
def_symbol_in_progress);
SF_SET_PROCESS (def_symbol_in_progress);
if (symbolP == NULL)
- {
- /* That is, if this is the first time we've seen the
- function... */
- symbol_table_insert (def_symbol_in_progress);
- } /* definition follows debug */
- } /* Create the line number entry pointing to the function being defined */
+ /* That is, if this is the first time we've seen the function. */
+ symbol_table_insert (def_symbol_in_progress);
+ }
def_symbol_in_progress = NULL;
demand_empty_rest_of_line ();
}
static void
-obj_coff_dim (ignore)
- int ignore ATTRIBUTE_UNUSED;
+obj_coff_dim (int ignore ATTRIBUTE_UNUSED)
{
int dim_index;
as_warn (_(".dim pseudo-op used outside of .def/.endef: ignored."));
demand_empty_rest_of_line ();
return;
- } /* if not inside .def/.endef */
+ }
S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
default:
as_warn (_("badly formed .dim directive ignored"));
- /* intentional fallthrough */
+ /* Fall through. */
+
case '\n':
case ';':
dim_index = DIMNUM;
}
static void
-obj_coff_line (ignore)
- int ignore ATTRIBUTE_UNUSED;
+obj_coff_line (int ignore ATTRIBUTE_UNUSED)
{
int this_base;
const char *name;
/* Only .bf symbols indicate the use of a new base line number; the
line numbers associated with .ef, .bb, .eb are relative to the
start of the containing function. */
- if (!strcmp (".bf", name))
+ if (streq (".bf", name))
{
-#if 0 /* XXX Can we ever have line numbers going backwards? */
- if (this_base > line_base)
-#endif
- {
- line_base = this_base;
- }
+ line_base = this_base;
#ifndef NO_LISTING
{
extern int listing;
if (listing)
- {
- listing_source_line ((unsigned int) line_base);
- }
+ listing_source_line ((unsigned int) line_base);
}
#endif
}
}
static void
-obj_coff_size (ignore)
- int ignore ATTRIBUTE_UNUSED;
+obj_coff_size (int ignore ATTRIBUTE_UNUSED)
{
if (def_symbol_in_progress == NULL)
{
as_warn (_(".size pseudo-op used outside of .def/.endef ignored."));
demand_empty_rest_of_line ();
return;
- } /* if not inside .def/.endef */
+ }
S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
SA_SET_SYM_SIZE (def_symbol_in_progress, get_absolute_expression ());
}
static void
-obj_coff_scl (ignore)
- int ignore ATTRIBUTE_UNUSED;
+obj_coff_scl (int ignore ATTRIBUTE_UNUSED)
{
if (def_symbol_in_progress == NULL)
{
as_warn (_(".scl pseudo-op used outside of .def/.endef ignored."));
demand_empty_rest_of_line ();
return;
- } /* if not inside .def/.endef */
+ }
S_SET_STORAGE_CLASS (def_symbol_in_progress, get_absolute_expression ());
demand_empty_rest_of_line ();
}
static void
-obj_coff_tag (ignore)
- int ignore ATTRIBUTE_UNUSED;
+obj_coff_tag (int ignore ATTRIBUTE_UNUSED)
{
char *symbol_name;
char name_end;
#endif
/* Assume that the symbol referred to by .tag is always defined.
- This was a bad assumption. I've added find_or_make. xoxorich. */
+ This was a bad assumption. I've added find_or_make. xoxorich. */
SA_SET_SYM_TAGNDX (def_symbol_in_progress,
(long) tag_find_or_make (symbol_name));
if (SA_GET_SYM_TAGNDX (def_symbol_in_progress) == 0L)
- {
- as_warn (_("tag not found for .tag %s"), symbol_name);
- } /* not defined */
+ as_warn (_("tag not found for .tag %s"), symbol_name);
SF_SET_TAGGED (def_symbol_in_progress);
*input_line_pointer = name_end;
}
static void
-obj_coff_type (ignore)
- int ignore ATTRIBUTE_UNUSED;
+obj_coff_type (int ignore ATTRIBUTE_UNUSED)
{
if (def_symbol_in_progress == NULL)
{
as_warn (_(".type pseudo-op used outside of .def/.endef ignored."));
demand_empty_rest_of_line ();
return;
- } /* if not inside .def/.endef */
+ }
S_SET_DATA_TYPE (def_symbol_in_progress, get_absolute_expression ());
if (ISFCN (S_GET_DATA_TYPE (def_symbol_in_progress)) &&
S_GET_STORAGE_CLASS (def_symbol_in_progress) != C_TPDEF)
- {
- SF_SET_FUNCTION (def_symbol_in_progress);
- } /* is a function */
+ SF_SET_FUNCTION (def_symbol_in_progress);
demand_empty_rest_of_line ();
}
static void
-obj_coff_val (ignore)
- int ignore ATTRIBUTE_UNUSED;
+obj_coff_val (int ignore ATTRIBUTE_UNUSED)
{
if (def_symbol_in_progress == NULL)
{
as_warn (_(".val pseudo-op used outside of .def/.endef ignored."));
demand_empty_rest_of_line ();
return;
- } /* if not inside .def/.endef */
+ }
if (is_name_beginner (*input_line_pointer))
{
symbol_name = tc_canonicalize_symbol_name (symbol_name);
#endif
- if (!strcmp (symbol_name, "."))
+ if (streq (symbol_name, "."))
{
def_symbol_in_progress->sy_frag = frag_now;
S_SET_VALUE (def_symbol_in_progress, (valueT) frag_now_fix ());
- /* If the .val is != from the .def (e.g. statics) */
+ /* If the .val is != from the .def (e.g. statics). */
}
- else if (strcmp (S_GET_NAME (def_symbol_in_progress), symbol_name))
+ else if (! streq (S_GET_NAME (def_symbol_in_progress), symbol_name))
{
def_symbol_in_progress->sy_value.X_op = O_symbol;
def_symbol_in_progress->sy_value.X_add_symbol =
just below. */
}
/* Otherwise, it is the name of a non debug symbol and
- its value will be calculated later. */
+ its value will be calculated later. */
*input_line_pointer = name_end;
/* FIXME: this is to avoid an error message in the
{
S_SET_VALUE (def_symbol_in_progress,
(valueT) get_absolute_expression ());
- } /* if symbol based */
+ }
demand_empty_rest_of_line ();
}
read.c, which then calls this object file format specific routine. */
void
-obj_coff_pe_handle_link_once (type)
- enum linkonce_type type;
+obj_coff_pe_handle_link_once (enum linkonce_type type)
{
seg_info (now_seg)->scnhdr.s_flags |= IMAGE_SCN_LNK_COMDAT;
#endif /* TE_PE */
void
-coff_obj_read_begin_hook ()
+coff_obj_read_begin_hook (void)
{
- /* These had better be the same. Usually 18 bytes. */
+ /* These had better be the same. Usually 18 bytes. */
#ifndef BFD_HEADERS
know (sizeof (SYMENT) == sizeof (AUXENT));
know (SYMESZ == AUXESZ);
}
/* This function runs through the symbol table and puts all the
- externals onto another chain */
+ externals onto another chain. */
/* The chain of globals. */
symbolS *symbol_globalP;
symbolS *symbol_global_lastP;
-/* The chain of externals */
+/* The chain of externals. */
symbolS *symbol_externP;
symbolS *symbol_extern_lastP;
symbolS *last_tagP;
static unsigned int
-yank_symbols ()
+yank_symbols (void)
{
symbolS *symbolP;
unsigned int symbol_number = 0;
unsigned int last_file_symno = 0;
-
struct filename_list *filename_list_scan = filename_list_head;
for (symbolP = symbol_rootP;
if (!SF_GET_DEBUG (symbolP))
{
- /* Debug symbols do not need all this rubbish */
+ /* Debug symbols do not need all this rubbish. */
symbolS *real_symbolP;
- /* L* and C_EFCN symbols never merge. */
+ /* L* and C_EFCN symbols never merge. */
if (!SF_GET_LOCAL (symbolP)
&& !SF_GET_STATICS (symbolP)
&& S_GET_STORAGE_CLASS (symbolP) != C_LABEL
&& symbolP->sy_value.X_op == O_constant
- && (real_symbolP = symbol_find_base (S_GET_NAME (symbolP), DO_NOT_STRIP))
+ && (real_symbolP = symbol_find (S_GET_NAME (symbolP)))
&& real_symbolP != symbolP)
{
/* FIXME-SOON: where do dups come from?
- Maybe tag references before definitions? xoxorich. */
+ Maybe tag references before definitions? xoxorich. */
/* Move the debug data from the debug symbol to the
- real symbol. Do NOT do the oposite (i.e. move from
+ real symbol. Do NOT do the opposite (i.e. move from
real symbol to debug symbol and remove real symbol from the
list.) Because some pointers refer to the real symbol
- whereas no pointers refer to the debug symbol. */
+ whereas no pointers refer to the debug symbol. */
c_symbol_merge (symbolP, real_symbolP);
- /* Replace the current symbol by the real one */
+ /* Replace the current symbol by the real one. */
/* The symbols will never be the last or the first
because : 1st symbol is .file and 3 last symbols are
- .text, .data, .bss */
+ .text, .data, .bss. */
symbol_remove (real_symbolP, &symbol_rootP, &symbol_lastP);
symbol_insert (real_symbolP, symbolP, &symbol_rootP, &symbol_lastP);
symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
symbolP = real_symbolP;
- } /* if not local but dup'd */
+ }
if (flag_readonly_data_in_text && (S_GET_SEGMENT (symbolP) == SEG_E1))
- {
- S_SET_SEGMENT (symbolP, SEG_E0);
- } /* push data into text */
+ S_SET_SEGMENT (symbolP, SEG_E0);
- resolve_symbol_value (symbolP, 1);
+ resolve_symbol_value (symbolP);
if (S_GET_STORAGE_CLASS (symbolP) == C_NULL)
{
if (!S_IS_DEFINED (symbolP) && !SF_GET_LOCAL (symbolP))
- {
- S_SET_EXTERNAL (symbolP);
- }
+ S_SET_EXTERNAL (symbolP);
+
else if (S_GET_SEGMENT (symbolP) == SEG_E0)
- {
- S_SET_STORAGE_CLASS (symbolP, C_LABEL);
- }
+ S_SET_STORAGE_CLASS (symbolP, C_LABEL);
+
else
- {
- S_SET_STORAGE_CLASS (symbolP, C_STAT);
- }
+ S_SET_STORAGE_CLASS (symbolP, C_STAT);
}
- /* Mainly to speed up if not -g */
+ /* Mainly to speed up if not -g. */
if (SF_GET_PROCESS (symbolP))
{
- /* Handle the nested blocks auxiliary info. */
+ /* Handle the nested blocks auxiliary info. */
if (S_GET_STORAGE_CLASS (symbolP) == C_BLOCK)
{
- if (!strcmp (S_GET_NAME (symbolP), ".bb"))
+ if (streq (S_GET_NAME (symbolP), ".bb"))
stack_push (block_stack, (char *) &symbolP);
else
- { /* .eb */
- register symbolS *begin_symbolP;
+ {
+ /* .eb */
+ symbolS *begin_symbolP;
+
begin_symbolP = *(symbolS **) stack_pop (block_stack);
- if (begin_symbolP == (symbolS *) 0)
+ if (begin_symbolP == NULL)
as_warn (_("mismatched .eb"));
else
SA_SET_SYM_ENDNDX (begin_symbolP, symbol_number + 2);
}
}
+
/* If we are able to identify the type of a function, and we
are out of a function (last_functionP == 0) then, the
function symbol will be associated with an auxiliary
- entry. */
- if (last_functionP == (symbolS *) 0 &&
- SF_GET_FUNCTION (symbolP))
+ entry. */
+ if (last_functionP == NULL && SF_GET_FUNCTION (symbolP))
{
last_functionP = symbolP;
if (S_GET_NUMBER_AUXILIARY (symbolP) < 1)
- {
- S_SET_NUMBER_AUXILIARY (symbolP, 1);
- } /* make it at least 1 */
-
- /* Clobber possible stale .dim information. */
-#if 0
- /* Iffed out by steve - this fries the lnnoptr info too */
- bzero (symbolP->sy_symbol.ost_auxent[0].x_sym.x_fcnary.x_ary.x_dimen,
- sizeof (symbolP->sy_symbol.ost_auxent[0].x_sym.x_fcnary.x_ary.x_dimen));
-#endif
+ S_SET_NUMBER_AUXILIARY (symbolP, 1);
}
+
if (S_GET_STORAGE_CLASS (symbolP) == C_FCN)
{
- if (strcmp (S_GET_NAME (symbolP), ".bf") == 0)
+ if (streq (S_GET_NAME (symbolP), ".bf"))
{
if (last_bfP != NULL)
SA_SET_SYM_ENDNDX (last_bfP, symbol_number);
{
/* I don't even know if this is needed for sdb. But
the standard assembler generates it, so... */
- if (last_functionP == (symbolS *) 0)
+ if (last_functionP == NULL)
as_fatal (_("C_EFCN symbol out of scope"));
SA_SET_SYM_FSIZE (last_functionP,
(long) (S_GET_VALUE (symbolP) -
S_GET_VALUE (last_functionP)));
SA_SET_SYM_ENDNDX (last_functionP, symbol_number);
- last_functionP = (symbolS *) 0;
+ last_functionP = NULL;
}
}
}
else if (SF_GET_TAG (symbolP))
- {
- /* First descriptor of a structure must point to
- the first slot after the structure description. */
- last_tagP = symbolP;
+ /* First descriptor of a structure must point to
+ the first slot after the structure description. */
+ last_tagP = symbolP;
- }
else if (S_GET_STORAGE_CLASS (symbolP) == C_EOS)
- {
- /* +2 take in account the current symbol */
- SA_SET_SYM_ENDNDX (last_tagP, symbol_number + 2);
- }
+ /* +2 take in account the current symbol. */
+ SA_SET_SYM_ENDNDX (last_tagP, symbol_number + 2);
+
else if (S_GET_STORAGE_CLASS (symbolP) == C_FILE)
{
/* If the filename was too long to fit in the
- auxent, put it in the string table */
+ auxent, put it in the string table. */
if (SA_GET_FILE_FNAME_ZEROS (symbolP) == 0
&& SA_GET_FILE_FNAME_OFFSET (symbolP) != 0)
{
{
S_SET_VALUE (symbolP, last_file_symno);
last_file_symno = symbol_number;
- } /* no one points at the first .file symbol */
- } /* if debug or tag or eos or file */
+ }
+ }
#ifdef tc_frob_coff_symbol
tc_frob_coff_symbol (symbolP);
[21] foo external
[22] .be
ld will move the symbol 21 to the end of the list but
- endndx will still be 22 instead of 21. */
-
+ endndx will still be 22 instead of 21. */
if (SF_GET_LOCAL (symbolP))
- {
- /* remove C_EFCN and LOCAL (L...) symbols */
- /* next pointer remains valid */
- symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
+ /* Remove C_EFCN and LOCAL (L...) symbols. */
+ /* Next pointer remains valid. */
+ symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
- }
else if (symbolP->sy_value.X_op == O_symbol
&& (! S_IS_DEFINED (symbolP) || S_IS_COMMON (symbolP)))
- {
- /* Skip symbols which were equated to undefined or common
- symbols. */
- symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
- }
+ /* Skip symbols which were equated to undefined or common
+ symbols. */
+ symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
+
else if (!S_IS_DEFINED (symbolP)
&& !S_IS_DEBUG (symbolP)
&& !SF_GET_STATICS (symbolP)
#endif
|| S_GET_STORAGE_CLASS (symbolP) == C_WEAKEXT))
{
- /* if external, Remove from the list */
+ /* If external, Remove from the list. */
symbolS *hold = symbol_previous (symbolP);
symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
/* The O'Reilly COFF book says that defined global symbols
come at the end of the symbol table, just before
undefined global symbols. */
-
symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
symbol_clear_list_pointers (symbolP);
symbol_append (symbolP, symbol_global_lastP, &symbol_globalP,
string_byte_count += strlen (S_GET_NAME (symbolP)) + 1;
}
else
- {
- symbolP->sy_name_offset = 0;
- } /* fix "long" names */
+ symbolP->sy_name_offset = 0;
symbolP->sy_number = symbol_number;
symbol_number += 1 + S_GET_NUMBER_AUXILIARY (symbolP);
- } /* if local symbol */
- } /* traverse the symbol list */
- return symbol_number;
+ }
+ }
+ return symbol_number;
}
-
static unsigned int
-glue_symbols (head, tail)
- symbolS **head;
- symbolS **tail;
+glue_symbols (symbolS **head, symbolS **tail)
{
unsigned int symbol_number = 0;
{
symbolS *tmp = *head;
- /* append */
+ /* Append. */
symbol_remove (tmp, head, tail);
symbol_append (tmp, symbol_lastP, &symbol_rootP, &symbol_lastP);
- /* and process */
+ /* Process. */
if (SF_GET_STRING (tmp))
{
tmp->sy_name_offset = string_byte_count;
string_byte_count += strlen (S_GET_NAME (tmp)) + 1;
}
else
- {
- tmp->sy_name_offset = 0;
- } /* fix "long" names */
+ /* Fix "long" names. */
+ tmp->sy_name_offset = 0;
tmp->sy_number = symbol_number;
symbol_number += 1 + S_GET_NUMBER_AUXILIARY (tmp);
- } /* append the entire extern chain */
+ }
return symbol_number;
}
static unsigned int
-tie_tags ()
+tie_tags (void)
{
unsigned int symbol_number = 0;
symbolS *symbolP;
return symbol_number;
}
+
+/* Build a 'section static' symbol. */
+
+static symbolS *
+c_section_symbol (char *name, int idx)
+{
+ symbolS *symbolP;
+
+ symbolP = symbol_find (name);
+ if (symbolP == NULL)
+ symbolP = symbol_new (name, idx, 0, &zero_address_frag);
+ else
+ {
+ /* Mmmm. I just love violating interfaces. Makes me feel...dirty. */
+ S_SET_SEGMENT (symbolP, idx);
+ symbolP->sy_frag = &zero_address_frag;
+ }
+
+ S_SET_STORAGE_CLASS (symbolP, C_STAT);
+ S_SET_NUMBER_AUXILIARY (symbolP, 1);
+
+ SF_SET_STATICS (symbolP);
+
+#ifdef TE_DELTA
+ /* manfred@s-direktnet.de: section symbols *must* have the LOCAL bit cleared,
+ which is set by the new definition of LOCAL_LABEL in tc-m68k.h. */
+ SF_CLEAR_LOCAL (symbolP);
+#endif
+#ifdef TE_PE
+ /* If the .linkonce pseudo-op was used for this section, we must
+ store the information in the auxiliary entry for the section
+ symbol. */
+ if (segment_info[idx].linkonce != LINKONCE_UNSET)
+ {
+ int type;
+
+ switch (segment_info[idx].linkonce)
+ {
+ default:
+ abort ();
+ case LINKONCE_DISCARD:
+ type = IMAGE_COMDAT_SELECT_ANY;
+ break;
+ case LINKONCE_ONE_ONLY:
+ type = IMAGE_COMDAT_SELECT_NODUPLICATES;
+ break;
+ case LINKONCE_SAME_SIZE:
+ type = IMAGE_COMDAT_SELECT_SAME_SIZE;
+ break;
+ case LINKONCE_SAME_CONTENTS:
+ type = IMAGE_COMDAT_SELECT_EXACT_MATCH;
+ break;
+ }
+
+ SYM_AUXENT (symbolP)->x_scn.x_comdat = type;
+ }
+#endif /* TE_PE */
+
+ return symbolP;
+}
+
static void
-crawl_symbols (h, abfd)
- object_headers *h;
- bfd *abfd ATTRIBUTE_UNUSED;
+crawl_symbols (object_headers *h, bfd *abfd ATTRIBUTE_UNUSED)
{
unsigned int i;
- /* Initialize the stack used to keep track of the matching .bb .be */
-
+ /* Initialize the stack used to keep track of the matching .bb .be. */
block_stack = stack_init (512, sizeof (symbolS *));
/* The symbol list should be ordered according to the following sequence
- * order :
- * . .file symbol
- * . debug entries for functions
- * . fake symbols for the sections, including .text .data and .bss
- * . defined symbols
- * . undefined symbols
- * But this is not mandatory. The only important point is to put the
- * undefined symbols at the end of the list.
- */
-
- /* Is there a .file symbol ? If not insert one at the beginning. */
+ order :
+ . .file symbol
+ . debug entries for functions
+ . fake symbols for the sections, including .text .data and .bss
+ . defined symbols
+ . undefined symbols
+ But this is not mandatory. The only important point is to put the
+ undefined symbols at the end of the list. */
+
+ /* Is there a .file symbol ? If not insert one at the beginning. */
if (symbol_rootP == NULL
|| S_GET_STORAGE_CLASS (symbol_rootP) != C_FILE)
- {
- c_dot_file_symbol ("fake");
- }
-
- /*
- * Build up static symbols for the sections, they are filled in later
- */
-
+ c_dot_file_symbol ("fake", 0);
+ /* Build up static symbols for the sections, they are filled in later. */
for (i = SEG_E0; i < SEG_LAST; i++)
if (segment_info[i].scnhdr.s_name[0])
- segment_info[i].dot = c_section_symbol (segment_info[i].name,
+ segment_info[i].dot = c_section_symbol ((char *) segment_info[i].name,
i - SEG_E0 + 1);
- /* Take all the externals out and put them into another chain */
+ /* Take all the externals out and put them into another chain. */
H_SET_SYMBOL_TABLE_SIZE (h, yank_symbols ());
- /* Take the externals and glue them onto the end.*/
+ /* Take the externals and glue them onto the end. */
H_SET_SYMBOL_TABLE_SIZE (h,
(H_GET_SYMBOL_COUNT (h)
+ glue_symbols (&symbol_globalP,
know (symbol_extern_lastP == NULL);
}
-/*
- * Find strings by crawling along symbol table chain.
- */
+/* Find strings by crawling along symbol table chain. */
-void
-w_strings (where)
- char *where;
+static void
+w_strings (char *where)
{
symbolS *symbolP;
struct filename_list *filename_list_scan = filename_list_head;
- /* Gotta do md_ byte-ordering stuff for string_byte_count first - KWK */
+ /* Gotta do md_ byte-ordering stuff for string_byte_count first - KWK. */
md_number_to_chars (where, (valueT) string_byte_count, 4);
where += 4;
}
static void
-do_linenos_for (abfd, h, file_cursor)
- bfd * abfd;
- object_headers * h;
- unsigned long *file_cursor;
+do_linenos_for (bfd * abfd,
+ object_headers * h,
+ unsigned long *file_cursor)
{
unsigned int idx;
unsigned long start = *file_cursor;
{
segment_info_type *s = segment_info + idx;
-
if (s->scnhdr.s_nlnno != 0)
{
struct lineno_list *line_ptr;
-
- struct external_lineno *buffer =
- (struct external_lineno *) xmalloc (s->scnhdr.s_nlnno * LINESZ);
-
+ struct external_lineno *buffer = xmalloc (s->scnhdr.s_nlnno * LINESZ);
struct external_lineno *dst = buffer;
/* Run through the table we've built and turn it into its external
- form, take this chance to remove duplicates */
+ form, take this chance to remove duplicates. */
for (line_ptr = s->lineno_list_head;
line_ptr != (struct lineno_list *) NULL;
line_ptr = line_ptr->next)
{
-
if (line_ptr->line.l_lnno == 0)
{
- /* Turn a pointer to a symbol into the symbols' index */
- line_ptr->line.l_addr.l_symndx =
- ((symbolS *) line_ptr->line.l_addr.l_symndx)->sy_number;
+ /* Turn a pointer to a symbol into the symbols' index,
+ provided that it has been initialised. */
+ if (line_ptr->line.l_addr.l_symndx)
+ line_ptr->line.l_addr.l_symndx =
+ ((symbolS *) line_ptr->line.l_addr.l_symndx)->sy_number;
}
else
- {
- line_ptr->line.l_addr.l_paddr += ((struct frag *) (line_ptr->frag))->fr_address;
- }
-
+ line_ptr->line.l_addr.l_paddr += ((struct frag *) (line_ptr->frag))->fr_address;
(void) bfd_coff_swap_lineno_out (abfd, &(line_ptr->line), dst);
dst++;
-
}
s->scnhdr.s_lnnoptr = *file_cursor;
- bfd_write (buffer, 1, s->scnhdr.s_nlnno * LINESZ, abfd);
+ bfd_bwrite (buffer, (bfd_size_type) s->scnhdr.s_nlnno * LINESZ, abfd);
free (buffer);
*file_cursor += s->scnhdr.s_nlnno * LINESZ;
}
}
+
H_SET_LINENO_SIZE (h, *file_cursor - start);
}
-
/* Now we run through the list of frag chains in a segment and
make all the subsegment frags appear at the end of the
- list, as if the seg 0 was extra long */
+ list, as if the seg 0 was extra long. */
static void
-remove_subsegs ()
+remove_subsegs (void)
{
unsigned int i;
unsigned long machine;
int coff_flags;
-extern void
-write_object_file ()
-{
- int i;
- const char *name;
- struct frchain *frchain_ptr;
-
- object_headers headers;
- unsigned long file_cursor;
- bfd *abfd;
- unsigned int addr;
- abfd = bfd_openw (out_file_name, TARGET_FORMAT);
-
-
- if (abfd == 0)
- {
- as_perror (_("FATAL: Can't create %s"), out_file_name);
- exit (EXIT_FAILURE);
- }
- bfd_set_format (abfd, bfd_object);
- bfd_set_arch_mach (abfd, BFD_ARCH, machine);
-
- string_byte_count = 4;
-
- for (frchain_ptr = frchain_root;
- frchain_ptr != (struct frchain *) NULL;
- frchain_ptr = frchain_ptr->frch_next)
- {
- /* Run through all the sub-segments and align them up. Also
- close any open frags. We tack a .fill onto the end of the
- frag chain so that any .align's size can be worked by looking
- at the next frag. */
-
- subseg_set (frchain_ptr->frch_seg, frchain_ptr->frch_subseg);
#ifndef SUB_SEGMENT_ALIGN
-#define SUB_SEGMENT_ALIGN(SEG) 1
-#endif
-#ifdef md_do_align
- md_do_align (SUB_SEGMENT_ALIGN (now_seg), (char *) NULL, 0, 0,
- alignment_done);
+#ifdef HANDLE_ALIGN
+/* The last subsegment gets an alignment corresponding to the alignment
+ of the section. This allows proper nop-filling at the end of
+ code-bearing sections. */
+#define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) \
+ (!(FRCHAIN)->frch_next || (FRCHAIN)->frch_next->frch_seg != (SEG) \
+ ? get_recorded_alignment (SEG) : 0)
+#else
+#define SUB_SEGMENT_ALIGN(SEG, FRCHAIN) 1
#endif
- frag_align (SUB_SEGMENT_ALIGN (now_seg),
- subseg_text_p (now_seg) ? NOP_OPCODE : 0,
- 0);
-#ifdef md_do_align
- alignment_done:
#endif
- frag_wane (frag_now);
- frag_now->fr_fix = 0;
- know (frag_now->fr_next == NULL);
- }
-
-
- remove_subsegs ();
+static void
+w_symbols (bfd * abfd, char *where, symbolS * symbol_rootP)
+{
+ symbolS *symbolP;
+ unsigned int i;
- for (i = SEG_E0; i < SEG_UNKNOWN; i++)
+ /* First fill in those values we have only just worked out. */
+ for (i = SEG_E0; i < SEG_LAST; i++)
{
- relax_segment (segment_info[i].frchainP->frch_root, i);
+ symbolP = segment_info[i].dot;
+ if (symbolP)
+ {
+ SA_SET_SCN_SCNLEN (symbolP, segment_info[i].scnhdr.s_size);
+ SA_SET_SCN_NRELOC (symbolP, segment_info[i].scnhdr.s_nreloc);
+ SA_SET_SCN_NLINNO (symbolP, segment_info[i].scnhdr.s_nlnno);
+ }
}
- H_SET_NUMBER_OF_SECTIONS (&headers, 0);
-
- /* Find out how big the sections are, and set the addresses. */
- addr = 0;
- for (i = SEG_E0; i < SEG_UNKNOWN; i++)
+ /* Emit all symbols left in the symbol chain. */
+ for (symbolP = symbol_rootP; symbolP; symbolP = symbol_next (symbolP))
{
- long size;
-
- segment_info[i].scnhdr.s_paddr = addr;
- segment_info[i].scnhdr.s_vaddr = addr;
+ /* 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;
- if (segment_info[i].scnhdr.s_name[0])
- {
- H_SET_NUMBER_OF_SECTIONS (&headers,
- H_GET_NUMBER_OF_SECTIONS (&headers) + 1);
+ /* We can't fix the lnnoptr field in yank_symbols with the other
+ adjustments, because we have to wait until we know where they
+ go in the file. */
+ if (SF_GET_ADJ_LNNOPTR (symbolP))
+ SA_GET_SYM_LNNOPTR (symbolP) +=
+ segment_info[S_GET_SEGMENT (symbolP)].scnhdr.s_lnnoptr;
-#ifdef COFF_LONG_SECTION_NAMES
- /* Support long section names as found in PE. This code
- must coordinate with that in coff_header_append and
- w_strings. */
- {
- unsigned int len;
+ tc_coff_symbol_emit_hook (symbolP);
- len = strlen (segment_info[i].name);
- if (len > SCNNMLEN)
- string_byte_count += len + 1;
- }
-#endif /* COFF_LONG_SECTION_NAMES */
+ temp = S_GET_NAME (symbolP);
+ if (SF_GET_STRING (symbolP))
+ {
+ S_SET_OFFSET (symbolP, symbolP->sy_name_offset);
+ S_SET_ZEROES (symbolP, 0);
}
+ else
+ {
+ memset (symbolP->sy_symbol.ost_entry.n_name, 0, SYMNMLEN);
+ strncpy (symbolP->sy_symbol.ost_entry.n_name, temp, SYMNMLEN);
+ }
+ where = symbol_to_chars (abfd, where, symbolP);
+ S_SET_NAME (symbolP, temp);
+ }
+}
- size = size_section (abfd, (unsigned int) i);
- addr += size;
+static void
+fixup_mdeps (fragS *frags,
+ object_headers *h ATTRIBUTE_UNUSED,
+ segT this_segment)
+{
+ subseg_change (this_segment, 0);
- /* I think the section alignment is only used on the i960; the
- i960 needs it, and it should do no harm on other targets. */
-#ifdef ALIGNMENT_IN_S_FLAGS
- segment_info[i].scnhdr.s_flags |= (section_alignment[i] & 0xF) << 8;
-#else
- segment_info[i].scnhdr.s_align = 1 << section_alignment[i];
+ while (frags)
+ {
+ switch (frags->fr_type)
+ {
+ case rs_align:
+ case rs_align_code:
+ case rs_align_test:
+ case rs_org:
+#ifdef HANDLE_ALIGN
+ HANDLE_ALIGN (frags);
#endif
-
- if (i == SEG_E0)
- H_SET_TEXT_SIZE (&headers, size);
- else if (i == SEG_E1)
- H_SET_DATA_SIZE (&headers, size);
- else if (i == SEG_E2)
- H_SET_BSS_SIZE (&headers, size);
+ frags->fr_type = rs_fill;
+ frags->fr_offset =
+ ((frags->fr_next->fr_address - frags->fr_address - frags->fr_fix)
+ / frags->fr_var);
+ break;
+ case rs_machine_dependent:
+ md_convert_frag (h, this_segment, frags);
+ frag_wane (frags);
+ break;
+ default:
+ ;
+ }
+ frags = frags->fr_next;
}
+}
- /* Turn the gas native symbol table shape into a coff symbol table */
- crawl_symbols (&headers, abfd);
-
- if (string_byte_count == 4)
- string_byte_count = 0;
-
- H_SET_STRING_SIZE (&headers, string_byte_count);
-
-#ifdef tc_frob_file
- tc_frob_file ();
+#ifndef TC_FORCE_RELOCATION
+#define TC_FORCE_RELOCATION(fix) 0
#endif
- for (i = SEG_E0; i < SEG_UNKNOWN; i++)
- {
- fixup_mdeps (segment_info[i].frchainP->frch_root, &headers, i);
- fixup_segment (&segment_info[i], i);
- }
+static void
+fixup_segment (segment_info_type * segP, segT this_segment_type)
+{
+ fixS * fixP;
+ symbolS *add_symbolP;
+ symbolS *sub_symbolP;
+ long add_number;
+ int size;
+ char *place;
+ long where;
+ char pcrel;
+ fragS *fragP;
+ segT add_symbol_segment = absolute_section;
- /* Look for ".stab" segments and fill in their initial symbols
- correctly. */
- for (i = SEG_E0; i < SEG_UNKNOWN; i++)
+ for (fixP = segP->fix_root; fixP; fixP = fixP->fx_next)
{
- name = segment_info[i].name;
-
- if (name != NULL
- && strncmp (".stab", name, 5) == 0
- && strncmp (".stabstr", name, 8) != 0)
- adjust_stab_section (abfd, i);
- }
-
- file_cursor = H_GET_TEXT_FILE_OFFSET (&headers);
+ fragP = fixP->fx_frag;
+ know (fragP);
+ where = fixP->fx_where;
+ place = fragP->fr_literal + where;
+ size = fixP->fx_size;
+ add_symbolP = fixP->fx_addsy;
+ sub_symbolP = fixP->fx_subsy;
+ add_number = fixP->fx_offset;
+ pcrel = fixP->fx_pcrel;
- bfd_seek (abfd, (file_ptr) file_cursor, 0);
+ /* We want function-relative stabs to work on systems which
+ may use a relaxing linker; thus we must handle the sym1-sym2
+ fixups function-relative stabs generates.
- /* Plant the data */
+ Of course, if you actually enable relaxing in the linker, the
+ line and block scoping information is going to be incorrect
+ in some cases. The only way to really fix this is to support
+ a reloc involving the difference of two symbols. */
+ if (linkrelax
+ && (!sub_symbolP || pcrel))
+ continue;
- fill_section (abfd, &headers, &file_cursor);
+#ifdef TC_I960
+ if (fixP->fx_tcbit && SF_GET_CALLNAME (add_symbolP))
+ {
+ /* Relocation should be done via the associated 'bal' entry
+ point symbol. */
+ if (!SF_GET_BALNAME (tc_get_bal_of_call (add_symbolP)))
+ {
+ as_bad_where (fixP->fx_file, fixP->fx_line,
+ _("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);
+ }
+#endif
- do_relocs_for (abfd, &headers, &file_cursor);
+ /* Make sure the symbols have been resolved; this may not have
+ happened if these are expression symbols. */
+ if (add_symbolP != NULL && ! add_symbolP->sy_resolved)
+ resolve_symbol_value (add_symbolP);
- do_linenos_for (abfd, &headers, &file_cursor);
+ if (add_symbolP != NULL)
+ {
+ /* If this fixup is against a symbol which has been equated
+ to another symbol, convert it to the other symbol. */
+ if (add_symbolP->sy_value.X_op == O_symbol
+ && (! S_IS_DEFINED (add_symbolP)
+ || S_IS_COMMON (add_symbolP)))
+ {
+ while (add_symbolP->sy_value.X_op == O_symbol
+ && (! S_IS_DEFINED (add_symbolP)
+ || S_IS_COMMON (add_symbolP)))
+ {
+ symbolS *n;
- H_SET_FILE_MAGIC_NUMBER (&headers, COFF_MAGIC);
-#ifndef OBJ_COFF_OMIT_TIMESTAMP
- H_SET_TIME_STAMP (&headers, (long)time((time_t *)0));
-#else
- H_SET_TIME_STAMP (&headers, 0);
-#endif
-#ifdef TC_COFF_SET_MACHINE
- TC_COFF_SET_MACHINE (&headers);
-#endif
+ /* We must avoid looping, as that can occur with a
+ badly written program. */
+ n = add_symbolP->sy_value.X_add_symbol;
+ if (n == add_symbolP)
+ break;
+ add_number += add_symbolP->sy_value.X_add_number;
+ add_symbolP = n;
+ }
+ fixP->fx_addsy = add_symbolP;
+ fixP->fx_offset = add_number;
+ }
+ }
-#ifndef COFF_FLAGS
-#define COFF_FLAGS 0
-#endif
+ if (sub_symbolP != NULL && ! sub_symbolP->sy_resolved)
+ resolve_symbol_value (sub_symbolP);
-#ifdef KEEP_RELOC_INFO
- H_SET_FLAGS (&headers, ((H_GET_LINENO_SIZE(&headers) ? 0 : F_LNNO) |
- COFF_FLAGS | coff_flags));
-#else
- H_SET_FLAGS (&headers, ((H_GET_LINENO_SIZE(&headers) ? 0 : F_LNNO) |
- (H_GET_RELOCATION_SIZE(&headers) ? 0 : F_RELFLG) |
- COFF_FLAGS | coff_flags));
-#endif
+ if (add_symbolP != NULL
+ && add_symbolP->sy_mri_common)
+ {
+ add_number += S_GET_VALUE (add_symbolP);
+ fixP->fx_offset = add_number;
+ add_symbolP = fixP->fx_addsy = add_symbolP->sy_value.X_add_symbol;
+ }
- {
- unsigned int symtable_size = H_GET_SYMBOL_TABLE_SIZE (&headers);
- char *buffer1 = xmalloc (symtable_size + string_byte_count + 1);
+ if (add_symbolP)
+ add_symbol_segment = S_GET_SEGMENT (add_symbolP);
- H_SET_SYMBOL_TABLE_POINTER (&headers, bfd_tell (abfd));
- w_symbols (abfd, buffer1, symbol_rootP);
- if (string_byte_count > 0)
- w_strings (buffer1 + symtable_size);
- bfd_write (buffer1, 1, symtable_size + string_byte_count, abfd);
- free (buffer1);
- }
+ if (sub_symbolP)
+ {
+ if (add_symbolP == NULL || add_symbol_segment == absolute_section)
+ {
+ if (add_symbolP != NULL)
+ {
+ add_number += S_GET_VALUE (add_symbolP);
+ add_symbolP = NULL;
+ fixP->fx_addsy = NULL;
+ }
- coff_header_append (abfd, &headers);
-#if 0
- /* Recent changes to write need this, but where it should
- go is up to Ken.. */
- if (bfd_close_all_done (abfd) == false)
- as_fatal (_("Can't close %s: %s"), out_file_name,
- bfd_errmsg (bfd_get_error ()));
-#else
- {
- extern bfd *stdoutput;
- stdoutput = abfd;
- }
+ /* It's just -sym. */
+ if (S_GET_SEGMENT (sub_symbolP) == absolute_section)
+ {
+ add_number -= S_GET_VALUE (sub_symbolP);
+ fixP->fx_subsy = 0;
+ fixP->fx_done = 1;
+ }
+ else
+ {
+#ifndef TC_M68K
+ as_bad_where (fixP->fx_file, fixP->fx_line,
+ _("Negative of non-absolute symbol %s"),
+ S_GET_NAME (sub_symbolP));
#endif
+ add_number -= S_GET_VALUE (sub_symbolP);
+ } /* not absolute */
-}
-
-/* Add a new segment. This is called from subseg_new via the
- obj_new_segment macro. */
+ /* 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
+ && SEG_NORMAL (add_symbol_segment))
+ {
+ /* 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_tcbit)
+ as_bad_where (fixP->fx_file, fixP->fx_line,
+ _("callj to difference of 2 symbols"));
+#endif /* TC_I960 */
+ add_number += S_GET_VALUE (add_symbolP) -
+ S_GET_VALUE (sub_symbolP);
+ add_symbolP = NULL;
-segT
-obj_coff_add_segment (name)
- const char *name;
-{
- unsigned int i;
+ if (!TC_FORCE_RELOCATION (fixP))
+ {
+ fixP->fx_addsy = NULL;
+ fixP->fx_subsy = NULL;
+ fixP->fx_done = 1;
+#ifdef TC_M68K /* FIXME: Is this right? */
+ pcrel = 0;
+ fixP->fx_pcrel = 0;
+#endif
+ }
+ }
+ else
+ {
+ /* Different segments in subtraction. */
+ know (!(S_IS_EXTERNAL (sub_symbolP) && (S_GET_SEGMENT (sub_symbolP) == absolute_section)));
-#ifndef COFF_LONG_SECTION_NAMES
- char buf[SCNNMLEN + 1];
+ if ((S_GET_SEGMENT (sub_symbolP) == absolute_section))
+ add_number -= S_GET_VALUE (sub_symbolP);
- strncpy (buf, name, SCNNMLEN);
- buf[SCNNMLEN] = '\0';
- name = buf;
+#ifdef DIFF_EXPR_OK
+ else if (S_GET_SEGMENT (sub_symbolP) == this_segment_type)
+ {
+ /* Make it pc-relative. */
+ add_number += (md_pcrel_from (fixP)
+ - S_GET_VALUE (sub_symbolP));
+ pcrel = 1;
+ fixP->fx_pcrel = 1;
+ sub_symbolP = 0;
+ fixP->fx_subsy = 0;
+ }
#endif
+ else
+ {
+ as_bad_where (fixP->fx_file, fixP->fx_line,
+ _("Can't emit reloc {- %s-seg symbol \"%s\"} @ file address %ld."),
+ segment_name (S_GET_SEGMENT (sub_symbolP)),
+ S_GET_NAME (sub_symbolP),
+ (long) (fragP->fr_address + where));
+ }
+ }
+ }
- for (i = SEG_E0; i < SEG_LAST && segment_info[i].scnhdr.s_name[0]; i++)
- if (strcmp (name, segment_info[i].name) == 0)
- return (segT) i;
-
- if (i == SEG_LAST)
- {
- as_bad (_("Too many new sections; can't add \"%s\""), name);
- return now_seg;
- }
+ 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
- /* Add a new section. */
- strncpy (segment_info[i].scnhdr.s_name, name,
- sizeof (segment_info[i].scnhdr.s_name));
- segment_info[i].scnhdr.s_flags = STYP_REG;
- segment_info[i].name = xstrdup (name);
+ add_number += S_GET_VALUE (add_symbolP);
+ add_number -= md_pcrel_from (fixP);
- return (segT) i;
-}
+ /* We used to do
+ add_number -= segP->scnhdr.s_vaddr;
+ if defined (TC_I386) || defined (TE_LYNX). I now
+ think that was an error propagated from the case when
+ we are going to emit the relocation. If we are not
+ going to emit the relocation, then we just want to
+ set add_number to the difference between the symbols.
+ This is a case that would only arise when there is a
+ PC relative reference from a section other than .text
+ to a symbol defined in the same section, and the
+ reference is not relaxed. Since jump instructions on
+ the i386 are relaxed, this could only arise with a
+ call instruction. */
-/*
- * implement the .section pseudo op:
- * .section name {, "flags"}
- * ^ ^
- * | +--- optional flags: 'b' for bss
- * | 'i' for info
- * +-- section name 'l' for lib
- * 'n' for noload
- * 'o' for over
- * 'w' for data
- * 'd' (apparently m88k for data)
- * 'x' for text
- * 'r' for read-only data
- * But if the argument is not a quoted string, treat it as a
- * subsegment number.
- */
+ /* Lie. Don't want further pcrel processing. */
+ pcrel = 0;
+ if (!TC_FORCE_RELOCATION (fixP))
+ {
+ fixP->fx_addsy = NULL;
+ fixP->fx_done = 1;
+ }
+ }
+ else
+ {
+ switch (add_symbol_segment)
+ {
+ case absolute_section:
+#ifdef TC_I960
+ /* See comment about reloc_callj() above. */
+ reloc_callj (fixP);
+#endif /* TC_I960 */
+ add_number += S_GET_VALUE (add_symbolP);
+ add_symbolP = NULL;
-void
-obj_coff_section (ignore)
- int ignore ATTRIBUTE_UNUSED;
-{
- /* Strip out the section name */
- char *section_name, *name;
- char c;
- unsigned int exp;
- long flags;
+ if (!TC_FORCE_RELOCATION (fixP))
+ {
+ fixP->fx_addsy = NULL;
+ fixP->fx_done = 1;
+ }
+ break;
+ default:
- if (flag_mri)
- {
- char type;
+#if defined(TC_A29K) || (defined(TE_PE) && defined(TC_I386)) || defined(TC_M88K) || defined(TC_OR32)
+ /* This really should be handled in the linker, but
+ backward compatibility forbids. */
+ add_number += S_GET_VALUE (add_symbolP);
+#else
+ add_number += S_GET_VALUE (add_symbolP) +
+ segment_info[S_GET_SEGMENT (add_symbolP)].scnhdr.s_paddr;
+#endif
+ break;
- s_mri_sect (&type);
- flags = 0;
- if (type == 'C')
- flags = STYP_TEXT;
- else if (type == 'D')
- flags = STYP_DATA;
- segment_info[now_seg].scnhdr.s_flags |= flags;
+ 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_where (fixP->fx_file, fixP->fx_line,
+ _("can't use COBR format with external label"));
+ fixP->fx_addsy = NULL;
+ fixP->fx_done = 1;
+ continue;
+ }
+#endif /* TC_I960 */
+#if ((defined (TC_I386) || defined (TE_LYNX) || defined (TE_AUX)) && !defined(TE_PE)) || defined (COFF_COMMON_ADDEND)
+ /* 386 COFF uses a peculiar format in which the
+ value of a common symbol is stored in the .text
+ segment (I've checked this on SVR3.2 and SCO
+ 3.2.2) Ian Taylor <ian@cygnus.com>. */
+ /* This is also true for 68k COFF on sysv machines
+ (Checked on Motorola sysv68 R3V6 and R3V7.1, and also on
+ UNIX System V/M68000, Release 1.0 from ATT/Bell Labs)
+ Philippe De Muyter <phdm@info.ucl.ac.be>. */
+ if (S_IS_COMMON (add_symbolP))
+ add_number += S_GET_VALUE (add_symbolP);
+#endif
+ break;
- return;
- }
+ }
+ }
+ }
- section_name = input_line_pointer;
- c = get_symbol_end ();
+ if (pcrel)
+ {
+#if !defined(TC_M88K) && !(defined(TE_PE) && defined(TC_I386)) && !defined(TC_A29K) && !defined(TC_OR32)
+ /* This adjustment is not correct on the m88k, for which the
+ linker does all the computation. */
+ add_number -= md_pcrel_from (fixP);
+#endif
+ if (add_symbolP == 0)
+ fixP->fx_addsy = &abs_symbol;
+#if defined (TC_I386) || defined (TE_LYNX) || defined (TC_I960) || defined (TC_M68K)
+ /* On the 386 we must adjust by the segment vaddr as well.
+ Ian Taylor.
- name = xmalloc (input_line_pointer - section_name + 1);
- strcpy (name, section_name);
+ I changed the i960 to work this way as well. This is
+ compatible with the current GNU linker behaviour. I do
+ not know what other i960 COFF assemblers do. This is not
+ a common case: normally, only assembler code will contain
+ a PC relative reloc, and only branches which do not
+ originate in the .text section will have a non-zero
+ address.
- *input_line_pointer = c;
+ I changed the m68k to work this way as well. This will
+ break existing PC relative relocs from sections which do
+ not start at address 0, but it will make ld -r work.
+ Ian Taylor, 4 Oct 96. */
- exp = 0;
- flags = 0;
+ add_number -= segP->scnhdr.s_vaddr;
+#endif
+ }
- SKIP_WHITESPACE ();
- if (*input_line_pointer == ',')
- {
- ++input_line_pointer;
- SKIP_WHITESPACE ();
+ md_apply_fix (fixP, (valueT *) & add_number, this_segment_type);
- if (*input_line_pointer != '"')
- exp = get_absolute_expression ();
- else
+ if (!fixP->fx_bit_fixP && ! fixP->fx_no_overflow)
{
- ++input_line_pointer;
- while (*input_line_pointer != '"'
- && ! is_end_of_line[(unsigned char) *input_line_pointer])
+#ifndef TC_M88K
+ /* The m88k uses the offset field of the reloc to get around
+ this problem. */
+ if ((size == 1
+ && ((add_number & ~0xFF)
+ || (fixP->fx_signed && (add_number & 0x80)))
+ && ((add_number & ~0xFF) != (-1 & ~0xFF)
+ || (add_number & 0x80) == 0))
+ || (size == 2
+ && ((add_number & ~0xFFFF)
+ || (fixP->fx_signed && (add_number & 0x8000)))
+ && ((add_number & ~0xFFFF) != (-1 & ~0xFFFF)
+ || (add_number & 0x8000) == 0)))
{
- switch (*input_line_pointer)
- {
- case 'b': flags |= STYP_BSS; break;
- case 'i': flags |= STYP_INFO; break;
- case 'l': flags |= STYP_LIB; break;
- case 'n': flags |= STYP_NOLOAD; break;
- case 'o': flags |= STYP_OVER; break;
- case 'd':
- case 'w': flags |= STYP_DATA; break;
- case 'x': flags |= STYP_TEXT; break;
- case 'r': flags |= STYP_LIT; break;
- default:
- as_warn(_("unknown section attribute '%c'"),
- *input_line_pointer);
- break;
- }
- ++input_line_pointer;
+ as_bad_where (fixP->fx_file, fixP->fx_line,
+ _("Value of %ld too large for field of %d bytes at 0x%lx"),
+ (long) add_number, size,
+ (unsigned long) (fragP->fr_address + where));
}
- if (*input_line_pointer == '"')
- ++input_line_pointer;
+#endif
+#ifdef WARN_SIGNED_OVERFLOW_WORD
+ /* Warn if a .word value is too large when treated as a
+ signed number. We already know it is not too negative.
+ This is to catch over-large switches generated by gcc on
+ the 68k. */
+ if (!flag_signed_overflow_ok
+ && size == 2
+ && add_number > 0x7fff)
+ as_bad_where (fixP->fx_file, fixP->fx_line,
+ _("Signed .word overflow; switch may be too large; %ld at 0x%lx"),
+ (long) add_number,
+ (unsigned long) (fragP->fr_address + where));
+#endif
}
}
-
- subseg_new (name, (subsegT) exp);
-
- segment_info[now_seg].scnhdr.s_flags |= flags;
-
- demand_empty_rest_of_line ();
-}
-
-
-static void
-obj_coff_text (ignore)
- int ignore ATTRIBUTE_UNUSED;
-{
- subseg_new (".text", get_absolute_expression ());
}
+/* Fill in the counts in the first entry in a .stab section. */
static void
-obj_coff_data (ignore)
- int ignore ATTRIBUTE_UNUSED;
-{
- if (flag_readonly_data_in_text)
- subseg_new (".text", get_absolute_expression () + 1000);
- else
- subseg_new (".data", get_absolute_expression ());
-}
-
-static void
-obj_coff_ident (ignore)
- int ignore ATTRIBUTE_UNUSED;
+adjust_stab_section (bfd *abfd, segT seg)
{
- segT current_seg = now_seg; /* save current seg */
- subsegT current_subseg = now_subseg;
- subseg_new (".comment", 0); /* .comment seg */
- stringer (1); /* read string */
- subseg_set (current_seg, current_subseg); /* restore current seg */
-}
-
-void
-c_symbol_merge (debug, normal)
- symbolS *debug;
- symbolS *normal;
-{
- S_SET_DATA_TYPE (normal, S_GET_DATA_TYPE (debug));
- S_SET_STORAGE_CLASS (normal, S_GET_STORAGE_CLASS (debug));
-
- if (S_GET_NUMBER_AUXILIARY (debug) > S_GET_NUMBER_AUXILIARY (normal))
- {
- S_SET_NUMBER_AUXILIARY (normal, S_GET_NUMBER_AUXILIARY (debug));
- } /* take the most we have */
-
- if (S_GET_NUMBER_AUXILIARY (debug) > 0)
- {
- memcpy ((char *) &normal->sy_symbol.ost_auxent[0],
- (char *) &debug->sy_symbol.ost_auxent[0],
- (unsigned int) (S_GET_NUMBER_AUXILIARY (debug) * AUXESZ));
- } /* Move all the auxiliary information */
-
- /* Move the debug flags. */
- SF_SET_DEBUG_FIELD (normal, SF_GET_DEBUG_FIELD (debug));
-} /* c_symbol_merge() */
+ segT stabstrseg = SEG_UNKNOWN;
+ const char *secname, *name2;
+ char *name;
+ char *p = NULL;
+ int i, strsz = 0, nsyms;
+ fragS *frag = segment_info[seg].frchainP->frch_root;
-static int
-c_line_new (symbol, paddr, line_number, frag)
- symbolS * symbol;
- long paddr;
- int line_number;
- fragS * frag;
-{
- struct lineno_list *new_line =
- (struct lineno_list *) xmalloc (sizeof (struct lineno_list));
+ /* Look for the associated string table section. */
- segment_info_type *s = segment_info + now_seg;
- new_line->line.l_lnno = line_number;
+ secname = segment_info[seg].name;
+ name = alloca (strlen (secname) + 4);
+ strcpy (name, secname);
+ strcat (name, "str");
- if (line_number == 0)
- {
- last_line_symbol = symbol;
- new_line->line.l_addr.l_symndx = (long) symbol;
- }
- else
+ for (i = SEG_E0; i < SEG_UNKNOWN; i++)
{
- new_line->line.l_addr.l_paddr = paddr;
+ name2 = segment_info[i].name;
+ if (name2 != NULL && strneq (name2, name, 8))
+ {
+ stabstrseg = i;
+ break;
+ }
}
- new_line->frag = (char *) frag;
- new_line->next = (struct lineno_list *) NULL;
+ /* If we found the section, get its size. */
+ if (stabstrseg != SEG_UNKNOWN)
+ strsz = size_section (abfd, stabstrseg);
+ nsyms = size_section (abfd, seg) / 12 - 1;
- if (s->lineno_list_head == (struct lineno_list *) NULL)
- {
- s->lineno_list_head = new_line;
- }
- else
- {
- s->lineno_list_tail->next = new_line;
- }
- s->lineno_list_tail = new_line;
- return LINESZ * s->scnhdr.s_nlnno++;
+ /* Look for the first frag of sufficient size for the initial stab
+ symbol, and collect a pointer to it. */
+ while (frag && frag->fr_fix < 12)
+ frag = frag->fr_next;
+ assert (frag != 0);
+ p = frag->fr_literal;
+ assert (p != 0);
+
+ /* Write in the number of stab symbols and the size of the string
+ table. */
+ bfd_h_put_16 (abfd, (bfd_vma) nsyms, (bfd_byte *) p + 6);
+ bfd_h_put_32 (abfd, (bfd_vma) strsz, (bfd_byte *) p + 8);
}
void
-c_dot_file_symbol (filename)
- char *filename;
+write_object_file (void)
{
- symbolS *symbolP;
-
- symbolP = symbol_new (".file",
- SEG_DEBUG,
- 0,
- &zero_address_frag);
-
- S_SET_STORAGE_CLASS (symbolP, C_FILE);
- S_SET_NUMBER_AUXILIARY (symbolP, 1);
-
- if (strlen (filename) > FILNMLEN)
- {
- /* Filename is too long to fit into an auxent,
- we stick it into the string table instead. We keep
- a linked list of the filenames we find so we can emit
- them later.*/
- struct filename_list *f = ((struct filename_list *)
- xmalloc (sizeof (struct filename_list)));
-
- f->filename = filename;
- f->next = 0;
-
- SA_SET_FILE_FNAME_ZEROS (symbolP, 0);
- SA_SET_FILE_FNAME_OFFSET (symbolP, 1);
-
- if (filename_list_tail)
- filename_list_tail->next = f;
- else
- filename_list_head = f;
- filename_list_tail = f;
- }
- else
- {
- SA_SET_FILE_FNAME (symbolP, filename);
- }
-#ifndef NO_LISTING
- {
- extern int listing;
- if (listing)
- {
- listing_source_file (filename);
- }
-
- }
-
-#endif
- SF_SET_DEBUG (symbolP);
- S_SET_VALUE (symbolP, (valueT) previous_file_symbol);
-
- previous_file_symbol = symbolP;
+ int i;
+ const char *name;
+ struct frchain *frchain_ptr;
+ object_headers headers;
+ unsigned long file_cursor;
+ bfd *abfd;
+ unsigned int addr;
+ abfd = bfd_openw (out_file_name, TARGET_FORMAT);
- /* Make sure that the symbol is first on the symbol chain */
- if (symbol_rootP != symbolP)
+ if (abfd == 0)
{
- symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
- symbol_insert (symbolP, symbol_rootP, &symbol_rootP, &symbol_lastP);
+ as_perror (_("FATAL: Can't create %s"), out_file_name);
+ exit (EXIT_FAILURE);
}
-} /* c_dot_file_symbol() */
-
-/*
- * Build a 'section static' symbol.
- */
+ bfd_set_format (abfd, bfd_object);
+ bfd_set_arch_mach (abfd, BFD_ARCH, machine);
-symbolS *
-c_section_symbol (name, idx)
- char *name;
- int idx;
-{
- symbolS *symbolP;
+ string_byte_count = 4;
- symbolP = symbol_find_base (name, DO_NOT_STRIP);
- if (symbolP == NULL)
- symbolP = symbol_new (name, idx, 0, &zero_address_frag);
- else
+ /* Run through all the sub-segments and align them up. Also
+ close any open frags. We tack a .fill onto the end of the
+ frag chain so that any .align's size can be worked by looking
+ at the next frag. */
+ for (frchain_ptr = frchain_root;
+ frchain_ptr != (struct frchain *) NULL;
+ frchain_ptr = frchain_ptr->frch_next)
{
- /* Mmmm. I just love violating interfaces. Makes me feel...dirty. */
- S_SET_SEGMENT (symbolP, idx);
- symbolP->sy_frag = &zero_address_frag;
- }
+ int alignment;
- S_SET_STORAGE_CLASS (symbolP, C_STAT);
- S_SET_NUMBER_AUXILIARY (symbolP, 1);
+ subseg_set (frchain_ptr->frch_seg, frchain_ptr->frch_subseg);
- SF_SET_STATICS (symbolP);
+ alignment = SUB_SEGMENT_ALIGN (now_seg, frchain_ptr);
-#ifdef TE_DELTA
- /* manfred@s-direktnet.de: section symbols *must* have the LOCAL bit cleared,
- which is set by the new definition of LOCAL_LABEL in tc-m68k.h. */
- SF_CLEAR_LOCAL (symbolP);
+#ifdef md_do_align
+ md_do_align (alignment, NULL, 0, 0, alignment_done);
#endif
-#ifdef TE_PE
- /* If the .linkonce pseudo-op was used for this section, we must
- store the information in the auxiliary entry for the section
- symbol. */
- if (segment_info[idx].linkonce != LINKONCE_UNSET)
- {
- int type;
+ if (subseg_text_p (now_seg))
+ frag_align_code (alignment, 0);
+ else
+ frag_align (alignment, 0, 0);
- switch (segment_info[idx].linkonce)
- {
- default:
- abort ();
- case LINKONCE_DISCARD:
- type = IMAGE_COMDAT_SELECT_ANY;
- break;
- case LINKONCE_ONE_ONLY:
- type = IMAGE_COMDAT_SELECT_NODUPLICATES;
- break;
- case LINKONCE_SAME_SIZE:
- type = IMAGE_COMDAT_SELECT_SAME_SIZE;
- break;
- case LINKONCE_SAME_CONTENTS:
- type = IMAGE_COMDAT_SELECT_EXACT_MATCH;
- break;
- }
+#ifdef md_do_align
+ alignment_done:
+#endif
- SYM_AUXENT (symbolP)->x_scn.x_comdat = type;
+ frag_wane (frag_now);
+ frag_now->fr_fix = 0;
+ know (frag_now->fr_next == NULL);
}
-#endif /* TE_PE */
- return symbolP;
-} /* c_section_symbol() */
+ remove_subsegs ();
-static void
-w_symbols (abfd, where, symbol_rootP)
- bfd * abfd;
- char *where;
- symbolS * symbol_rootP;
-{
- symbolS *symbolP;
- unsigned int i;
+ for (i = SEG_E0; i < SEG_UNKNOWN; i++)
+ relax_segment (segment_info[i].frchainP->frch_root, i);
- /* First fill in those values we have only just worked out */
- for (i = SEG_E0; i < SEG_LAST; i++)
- {
- symbolP = segment_info[i].dot;
- if (symbolP)
- {
- SA_SET_SCN_SCNLEN (symbolP, segment_info[i].scnhdr.s_size);
- SA_SET_SCN_NRELOC (symbolP, segment_info[i].scnhdr.s_nreloc);
- SA_SET_SCN_NLINNO (symbolP, segment_info[i].scnhdr.s_nlnno);
- }
- }
+ /* Relaxation has completed. Freeze all syms. */
+ finalize_syms = 1;
- /*
- * Emit all symbols left in the symbol chain.
- */
- for (symbolP = symbol_rootP; symbolP; symbolP = symbol_next (symbolP))
+ H_SET_NUMBER_OF_SECTIONS (&headers, 0);
+
+ /* Find out how big the sections are, and set the addresses. */
+ addr = 0;
+ for (i = SEG_E0; i < SEG_UNKNOWN; i++)
{
- /* Used to save the offset of the name. It is used to point
- to the string in memory but must be a file offset. */
- register char *temp;
+ long size;
- /* We can't fix the lnnoptr field in yank_symbols with the other
- adjustments, because we have to wait until we know where they
- go in the file. */
- if (SF_GET_ADJ_LNNOPTR (symbolP))
+ segment_info[i].scnhdr.s_paddr = addr;
+ segment_info[i].scnhdr.s_vaddr = addr;
+
+ if (segment_info[i].scnhdr.s_name[0])
{
- SA_GET_SYM_LNNOPTR (symbolP) +=
- segment_info[S_GET_SEGMENT (symbolP)].scnhdr.s_lnnoptr;
- }
+ H_SET_NUMBER_OF_SECTIONS (&headers,
+ H_GET_NUMBER_OF_SECTIONS (&headers) + 1);
- tc_coff_symbol_emit_hook (symbolP);
+#ifdef COFF_LONG_SECTION_NAMES
+ /* Support long section names as found in PE. This code
+ must coordinate with that in coff_header_append and
+ w_strings. */
+ {
+ unsigned int len;
- temp = S_GET_NAME (symbolP);
- if (SF_GET_STRING (symbolP))
- {
- S_SET_OFFSET (symbolP, symbolP->sy_name_offset);
- S_SET_ZEROES (symbolP, 0);
- }
- else
- {
- memset (symbolP->sy_symbol.ost_entry.n_name, 0, SYMNMLEN);
- strncpy (symbolP->sy_symbol.ost_entry.n_name, temp, SYMNMLEN);
+ len = strlen (segment_info[i].name);
+ if (len > SCNNMLEN)
+ string_byte_count += len + 1;
+ }
+#endif /* COFF_LONG_SECTION_NAMES */
}
- where = symbol_to_chars (abfd, where, symbolP);
- S_SET_NAME (symbolP, temp);
+
+ size = size_section (abfd, (unsigned int) i);
+ addr += size;
+
+ /* I think the section alignment is only used on the i960; the
+ i960 needs it, and it should do no harm on other targets. */
+#ifdef ALIGNMENT_IN_S_FLAGS
+ segment_info[i].scnhdr.s_flags |= (section_alignment[i] & 0xF) << 8;
+#else
+ segment_info[i].scnhdr.s_align = 1 << section_alignment[i];
+#endif
+
+ if (i == SEG_E0)
+ H_SET_TEXT_SIZE (&headers, size);
+ else if (i == SEG_E1)
+ H_SET_DATA_SIZE (&headers, size);
+ else if (i == SEG_E2)
+ H_SET_BSS_SIZE (&headers, size);
}
-} /* w_symbols() */
+ /* Turn the gas native symbol table shape into a coff symbol table. */
+ crawl_symbols (&headers, abfd);
-static void
-obj_coff_lcomm (ignore)
- int ignore ATTRIBUTE_UNUSED;
-{
- s_lcomm(0);
- return;
-#if 0
- char *name;
- char c;
- int temp;
- char *p;
+ if (string_byte_count == 4)
+ string_byte_count = 0;
- symbolS *symbolP;
+ H_SET_STRING_SIZE (&headers, string_byte_count);
- name = input_line_pointer;
+#ifdef tc_frob_file
+ tc_frob_file ();
+#endif
- c = get_symbol_end ();
- p = input_line_pointer;
- *p = c;
- SKIP_WHITESPACE ();
- if (*input_line_pointer != ',')
- {
- as_bad (_("Expected comma after name"));
- ignore_rest_of_line ();
- return;
- }
- if (*input_line_pointer == '\n')
+ for (i = SEG_E0; i < SEG_UNKNOWN; i++)
{
- as_bad (_("Missing size expression"));
- return;
+ fixup_mdeps (segment_info[i].frchainP->frch_root, &headers, i);
+ fixup_segment (&segment_info[i], i);
}
- input_line_pointer++;
- if ((temp = get_absolute_expression ()) < 0)
+
+ /* Look for ".stab" segments and fill in their initial symbols
+ correctly. */
+ for (i = SEG_E0; i < SEG_UNKNOWN; i++)
{
- as_warn (_("lcomm length (%d.) <0! Ignored."), temp);
- ignore_rest_of_line ();
- return;
+ name = segment_info[i].name;
+
+ if (name != NULL
+ && strneq (".stab", name, 5)
+ && ! strneq (".stabstr", name, 8))
+ adjust_stab_section (abfd, i);
}
- *p = 0;
- symbolP = symbol_find_or_make(name);
+ file_cursor = H_GET_TEXT_FILE_OFFSET (&headers);
- if (S_GET_SEGMENT(symbolP) == SEG_UNKNOWN &&
- S_GET_VALUE(symbolP) == 0)
- {
- if (! need_pass_2)
- {
- char *p;
- segT current_seg = now_seg; /* save current seg */
- subsegT current_subseg = now_subseg;
-
- subseg_set (SEG_E2, 1);
- symbolP->sy_frag = frag_now;
- p = frag_var(rs_org, 1, 1, (relax_substateT)0, symbolP,
- (offsetT) temp, (char *) 0);
- *p = 0;
- subseg_set (current_seg, current_subseg); /* restore current seg */
- S_SET_SEGMENT(symbolP, SEG_E2);
- S_SET_STORAGE_CLASS(symbolP, C_STAT);
- }
- }
- else
- as_bad(_("Symbol %s already defined"), name);
+ bfd_seek (abfd, (file_ptr) file_cursor, 0);
+
+ /* Plant the data. */
+ fill_section (abfd, &headers, &file_cursor);
+
+ do_relocs_for (abfd, &headers, &file_cursor);
+
+ do_linenos_for (abfd, &headers, &file_cursor);
+
+ H_SET_FILE_MAGIC_NUMBER (&headers, COFF_MAGIC);
+#ifndef OBJ_COFF_OMIT_TIMESTAMP
+ H_SET_TIME_STAMP (&headers, (long) time (NULL));
+#else
+ H_SET_TIME_STAMP (&headers, 0);
+#endif
+#ifdef TC_COFF_SET_MACHINE
+ TC_COFF_SET_MACHINE (&headers);
+#endif
- demand_empty_rest_of_line();
+#ifndef COFF_FLAGS
+#define COFF_FLAGS 0
#endif
-}
-static void
-fixup_mdeps (frags, h, this_segment)
- fragS * frags;
- object_headers * h;
- segT this_segment;
-{
- subseg_change (this_segment, 0);
- while (frags)
- {
- switch (frags->fr_type)
- {
- case rs_align:
- case rs_align_code:
- case rs_org:
-#ifdef HANDLE_ALIGN
- HANDLE_ALIGN (frags);
+#ifdef KEEP_RELOC_INFO
+ H_SET_FLAGS (&headers, ((H_GET_LINENO_SIZE (&headers) ? 0 : F_LNNO) |
+ COFF_FLAGS | coff_flags));
+#else
+ H_SET_FLAGS (&headers, ((H_GET_LINENO_SIZE (&headers) ? 0 : F_LNNO) |
+ (H_GET_RELOCATION_SIZE (&headers) ? 0 : F_RELFLG) |
+ COFF_FLAGS | coff_flags));
#endif
- frags->fr_type = rs_fill;
- frags->fr_offset =
- ((frags->fr_next->fr_address - frags->fr_address - frags->fr_fix)
- / frags->fr_var);
- break;
- case rs_machine_dependent:
- md_convert_frag (h, this_segment, frags);
- frag_wane (frags);
- break;
- default:
- ;
- }
- frags = frags->fr_next;
- }
+
+ {
+ unsigned int symtable_size = H_GET_SYMBOL_TABLE_SIZE (&headers);
+ char *buffer1 = xmalloc (symtable_size + string_byte_count + 1);
+
+ H_SET_SYMBOL_TABLE_POINTER (&headers, bfd_tell (abfd));
+ w_symbols (abfd, buffer1, symbol_rootP);
+ if (string_byte_count > 0)
+ w_strings (buffer1 + symtable_size);
+ bfd_bwrite (buffer1, (bfd_size_type) symtable_size + string_byte_count,
+ abfd);
+ free (buffer1);
+ }
+
+ coff_header_append (abfd, &headers);
+
+ {
+ extern bfd *stdoutput;
+ stdoutput = abfd;
+ }
}
-#if 1
+/* Add a new segment. This is called from subseg_new via the
+ obj_new_segment macro. */
+
+segT
+obj_coff_add_segment (const char *name)
+{
+ unsigned int i;
+
+#ifndef COFF_LONG_SECTION_NAMES
+ char buf[SCNNMLEN + 1];
-#ifndef TC_FORCE_RELOCATION
-#define TC_FORCE_RELOCATION(fix) 0
+ strncpy (buf, name, SCNNMLEN);
+ buf[SCNNMLEN] = '\0';
+ name = buf;
#endif
-static void
-fixup_segment (segP, this_segment_type)
- segment_info_type * segP;
- segT this_segment_type;
-{
- register fixS * fixP;
- register symbolS *add_symbolP;
- register symbolS *sub_symbolP;
- long add_number;
- register int size;
- register char *place;
- register long where;
- register char pcrel;
- register fragS *fragP;
- register segT add_symbol_segment = absolute_section;
+ for (i = SEG_E0; i < SEG_LAST && segment_info[i].scnhdr.s_name[0]; i++)
+ if (streq (name, segment_info[i].name))
+ return (segT) i;
- for (fixP = segP->fix_root; fixP; fixP = fixP->fx_next)
+ if (i == SEG_LAST)
{
- fragP = fixP->fx_frag;
- know (fragP);
- where = fixP->fx_where;
- place = fragP->fr_literal + where;
- size = fixP->fx_size;
- add_symbolP = fixP->fx_addsy;
- sub_symbolP = fixP->fx_subsy;
- add_number = fixP->fx_offset;
- pcrel = fixP->fx_pcrel;
-
- /* We want function-relative stabs to work on systems which
- may use a relaxing linker; thus we must handle the sym1-sym2
- fixups function-relative stabs generates.
+ as_bad (_("Too many new sections; can't add \"%s\""), name);
+ return now_seg;
+ }
- Of course, if you actually enable relaxing in the linker, the
- line and block scoping information is going to be incorrect
- in some cases. The only way to really fix this is to support
- a reloc involving the difference of two symbols. */
- if (linkrelax
- && (!sub_symbolP || pcrel))
- continue;
+ /* Add a new section. */
+ strncpy (segment_info[i].scnhdr.s_name, name,
+ sizeof (segment_info[i].scnhdr.s_name));
+ segment_info[i].scnhdr.s_flags = STYP_REG;
+ segment_info[i].name = xstrdup (name);
-#ifdef TC_I960
- if (fixP->fx_tcbit && SF_GET_CALLNAME (add_symbolP))
- {
- /* Relocation should be done via the associated 'bal' entry
- point symbol. */
+ return (segT) i;
+}
- if (!SF_GET_BALNAME (tc_get_bal_of_call (add_symbolP)))
- {
- as_bad_where (fixP->fx_file, fixP->fx_line,
- _("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);
- }
-#endif
+/* Implement the .section pseudo op:
+ .section name {, "flags"}
+ ^ ^
+ | +--- optional flags: 'b' for bss
+ | 'i' for info
+ +-- section name 'l' for lib
+ 'n' for noload
+ 'o' for over
+ 'w' for data
+ 'd' (apparently m88k for data)
+ 'x' for text
+ 'r' for read-only data
+ But if the argument is not a quoted string, treat it as a
+ subsegment number. */
- /* Make sure the symbols have been resolved; this may not have
- happened if these are expression symbols. */
- if (add_symbolP != NULL && ! add_symbolP->sy_resolved)
- resolve_symbol_value (add_symbolP, 1);
+void
+obj_coff_section (int ignore ATTRIBUTE_UNUSED)
+{
+ /* Strip out the section name. */
+ char *section_name, *name;
+ char c;
+ unsigned int exp;
+ long flags;
- if (add_symbolP != NULL)
- {
- /* If this fixup is against a symbol which has been equated
- to another symbol, convert it to the other symbol. */
- if (add_symbolP->sy_value.X_op == O_symbol
- && (! S_IS_DEFINED (add_symbolP)
- || S_IS_COMMON (add_symbolP)))
- {
- while (add_symbolP->sy_value.X_op == O_symbol
- && (! S_IS_DEFINED (add_symbolP)
- || S_IS_COMMON (add_symbolP)))
- {
- symbolS *n;
+ if (flag_mri)
+ {
+ char type;
- /* We must avoid looping, as that can occur with a
- badly written program. */
- n = add_symbolP->sy_value.X_add_symbol;
- if (n == add_symbolP)
- break;
- add_number += add_symbolP->sy_value.X_add_number;
- add_symbolP = n;
- }
- fixP->fx_addsy = add_symbolP;
- fixP->fx_offset = add_number;
- }
- }
+ s_mri_sect (&type);
+ flags = 0;
+ if (type == 'C')
+ flags = STYP_TEXT;
+ else if (type == 'D')
+ flags = STYP_DATA;
+ segment_info[now_seg].scnhdr.s_flags |= flags;
- if (sub_symbolP != NULL && ! sub_symbolP->sy_resolved)
- resolve_symbol_value (sub_symbolP, 1);
+ return;
+ }
- if (add_symbolP != NULL
- && add_symbolP->sy_mri_common)
- {
- know (add_symbolP->sy_value.X_op == O_symbol);
- add_number += S_GET_VALUE (add_symbolP);
- fixP->fx_offset = add_number;
- add_symbolP = fixP->fx_addsy = add_symbolP->sy_value.X_add_symbol;
- }
+ section_name = input_line_pointer;
+ c = get_symbol_end ();
- if (add_symbolP)
- {
- add_symbol_segment = S_GET_SEGMENT (add_symbolP);
- } /* if there is an addend */
+ name = xmalloc (input_line_pointer - section_name + 1);
+ strcpy (name, section_name);
- if (sub_symbolP)
- {
- if (add_symbolP == NULL || add_symbol_segment == absolute_section)
- {
- if (add_symbolP != NULL)
- {
- add_number += S_GET_VALUE (add_symbolP);
- add_symbolP = NULL;
- fixP->fx_addsy = NULL;
- }
+ *input_line_pointer = c;
- /* It's just -sym. */
- if (S_GET_SEGMENT (sub_symbolP) == absolute_section)
- {
- add_number -= S_GET_VALUE (sub_symbolP);
- fixP->fx_subsy = 0;
- fixP->fx_done = 1;
- }
- else
- {
-#ifndef TC_M68K
- as_bad_where (fixP->fx_file, fixP->fx_line,
- _("Negative of non-absolute symbol %s"),
- S_GET_NAME (sub_symbolP));
-#endif
- add_number -= S_GET_VALUE (sub_symbolP);
- } /* not absolute */
+ exp = 0;
+ flags = 0;
- /* 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
- && SEG_NORMAL (add_symbol_segment))
- {
- /* 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_tcbit)
- {
- as_bad_where (fixP->fx_file, fixP->fx_line,
- _("callj to difference of 2 symbols"));
- }
-#endif /* TC_I960 */
- add_number += S_GET_VALUE (add_symbolP) -
- S_GET_VALUE (sub_symbolP);
- add_symbolP = NULL;
+ SKIP_WHITESPACE ();
+ if (*input_line_pointer == ',')
+ {
+ ++input_line_pointer;
+ SKIP_WHITESPACE ();
- if (!TC_FORCE_RELOCATION (fixP))
- {
- fixP->fx_addsy = NULL;
- fixP->fx_subsy = NULL;
- fixP->fx_done = 1;
-#ifdef TC_M68K /* is this right? */
- pcrel = 0;
- fixP->fx_pcrel = 0;
-#endif
- }
- }
- else
+ if (*input_line_pointer != '"')
+ exp = get_absolute_expression ();
+ else
+ {
+ ++input_line_pointer;
+ while (*input_line_pointer != '"'
+ && ! is_end_of_line[(unsigned char) *input_line_pointer])
{
- /* Different segments in subtraction. */
- know (!(S_IS_EXTERNAL (sub_symbolP) && (S_GET_SEGMENT (sub_symbolP) == absolute_section)));
-
- if ((S_GET_SEGMENT (sub_symbolP) == absolute_section))
- {
- add_number -= S_GET_VALUE (sub_symbolP);
- }
-#ifdef DIFF_EXPR_OK
- else if (S_GET_SEGMENT (sub_symbolP) == this_segment_type
-#if 0 /* Okay for 68k, at least... */
- && !pcrel
-#endif
- )
+ switch (*input_line_pointer)
{
- /* Make it pc-relative. */
- add_number += (md_pcrel_from (fixP)
- - S_GET_VALUE (sub_symbolP));
- pcrel = 1;
- fixP->fx_pcrel = 1;
- sub_symbolP = 0;
- fixP->fx_subsy = 0;
+ case 'b': flags |= STYP_BSS; break;
+ case 'i': flags |= STYP_INFO; break;
+ case 'l': flags |= STYP_LIB; break;
+ case 'n': flags |= STYP_NOLOAD; break;
+ case 'o': flags |= STYP_OVER; break;
+ case 'd':
+ case 'w': flags |= STYP_DATA; break;
+ case 'x': flags |= STYP_TEXT; break;
+ case 'r': flags |= STYP_LIT; break;
+ default:
+ as_warn (_("unknown section attribute '%c'"),
+ *input_line_pointer);
+ break;
}
-#endif
- else
- {
- as_bad_where (fixP->fx_file, fixP->fx_line,
- _("Can't emit reloc {- %s-seg symbol \"%s\"} @ file address %ld."),
- segment_name (S_GET_SEGMENT (sub_symbolP)),
- S_GET_NAME (sub_symbolP),
- (long) (fragP->fr_address + where));
- } /* if absolute */
+ ++input_line_pointer;
}
- } /* if sub_symbolP */
+ if (*input_line_pointer == '"')
+ ++input_line_pointer;
+ }
+ }
- 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 */
+ subseg_new (name, (subsegT) exp);
- add_number += S_GET_VALUE (add_symbolP);
- add_number -= md_pcrel_from (fixP);
+ segment_info[now_seg].scnhdr.s_flags |= flags;
- /* We used to do
- add_number -= segP->scnhdr.s_vaddr;
- if defined (TC_I386) || defined (TE_LYNX). I now
- think that was an error propagated from the case when
- we are going to emit the relocation. If we are not
- going to emit the relocation, then we just want to
- set add_number to the difference between the symbols.
- This is a case that would only arise when there is a
- PC relative reference from a section other than .text
- to a symbol defined in the same section, and the
- reference is not relaxed. Since jump instructions on
- the i386 are relaxed, this could only arise with a
- call instruction. */
+ demand_empty_rest_of_line ();
+}
- pcrel = 0; /* Lie. Don't want further pcrel processing. */
- if (!TC_FORCE_RELOCATION (fixP))
- {
- fixP->fx_addsy = NULL;
- fixP->fx_done = 1;
- }
- }
- else
- {
- switch (add_symbol_segment)
- {
- case absolute_section:
-#ifdef TC_I960
- reloc_callj (fixP); /* See comment about reloc_callj() above*/
-#endif /* TC_I960 */
- add_number += S_GET_VALUE (add_symbolP);
- add_symbolP = NULL;
+static void
+obj_coff_text (int ignore ATTRIBUTE_UNUSED)
+{
+ subseg_new (".text", get_absolute_expression ());
+}
- if (!TC_FORCE_RELOCATION (fixP))
- {
- fixP->fx_addsy = NULL;
- fixP->fx_done = 1;
- }
- break;
- default:
+static void
+obj_coff_data (int ignore ATTRIBUTE_UNUSED)
+{
+ if (flag_readonly_data_in_text)
+ subseg_new (".text", get_absolute_expression () + 1000);
+ else
+ subseg_new (".data", get_absolute_expression ());
+}
+static void
+obj_coff_ident (int ignore ATTRIBUTE_UNUSED)
+{
+ segT current_seg = now_seg; /* Save current seg. */
+ subsegT current_subseg = now_subseg;
-#if defined(TC_A29K) || (defined(TE_PE) && defined(TC_I386)) || defined(TC_M88K)
- /* This really should be handled in the linker, but
- backward compatibility forbids. */
- add_number += S_GET_VALUE (add_symbolP);
-#else
- add_number += S_GET_VALUE (add_symbolP) +
- segment_info[S_GET_SEGMENT (add_symbolP)].scnhdr.s_paddr;
-#endif
- break;
+ subseg_new (".comment", 0); /* .comment seg. */
+ stringer (1); /* Read string. */
+ subseg_set (current_seg, current_subseg); /* Restore current seg. */
+}
- 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_where (fixP->fx_file, fixP->fx_line,
- _("can't use COBR format with external label"));
- fixP->fx_addsy = NULL;
- fixP->fx_done = 1;
- continue;
- } /* COBR */
-#endif /* TC_I960 */
-#if ((defined (TC_I386) || defined (TE_LYNX) || defined (TE_AUX)) && !defined(TE_PE)) || defined (COFF_COMMON_ADDEND)
- /* 386 COFF uses a peculiar format in which the
- value of a common symbol is stored in the .text
- segment (I've checked this on SVR3.2 and SCO
- 3.2.2) Ian Taylor <ian@cygnus.com>. */
- /* This is also true for 68k COFF on sysv machines
- (Checked on Motorola sysv68 R3V6 and R3V7.1, and also on
- UNIX System V/M68000, Release 1.0 from ATT/Bell Labs)
- Philippe De Muyter <phdm@info.ucl.ac.be>. */
- if (S_IS_COMMON (add_symbolP))
- add_number += S_GET_VALUE (add_symbolP);
-#endif
- break;
+void
+c_dot_file_symbol (const char *filename, int appfile ATTRIBUTE_UNUSED)
+{
+ symbolS *symbolP;
+ symbolP = symbol_new (".file", SEG_DEBUG, 0, & zero_address_frag);
- } /* switch on symbol seg */
- } /* if not in local seg */
- } /* if there was a + symbol */
+ S_SET_STORAGE_CLASS (symbolP, C_FILE);
+ S_SET_NUMBER_AUXILIARY (symbolP, 1);
- if (pcrel)
- {
-#if !defined(TC_M88K) && !(defined(TE_PE) && defined(TC_I386)) && !defined(TC_A29K)
- /* This adjustment is not correct on the m88k, for which the
- linker does all the computation. */
- add_number -= md_pcrel_from (fixP);
-#endif
- if (add_symbolP == 0)
- {
- fixP->fx_addsy = &abs_symbol;
- } /* if there's an add_symbol */
-#if defined (TC_I386) || defined (TE_LYNX) || defined (TC_I960) || defined (TC_M68K)
- /* On the 386 we must adjust by the segment vaddr as well.
- Ian Taylor.
+ if (strlen (filename) > FILNMLEN)
+ {
+ /* Filename is too long to fit into an auxent,
+ we stick it into the string table instead. We keep
+ a linked list of the filenames we find so we can emit
+ them later. */
+ struct filename_list *f = xmalloc (sizeof (* f));
- I changed the i960 to work this way as well. This is
- compatible with the current GNU linker behaviour. I do
- not know what other i960 COFF assemblers do. This is not
- a common case: normally, only assembler code will contain
- a PC relative reloc, and only branches which do not
- originate in the .text section will have a non-zero
- address.
+ f->filename = filename;
+ f->next = 0;
- I changed the m68k to work this way as well. This will
- break existing PC relative relocs from sections which do
- not start at address 0, but it will make ld -r work.
- Ian Taylor, 4 Oct 96. */
+ SA_SET_FILE_FNAME_ZEROS (symbolP, 0);
+ SA_SET_FILE_FNAME_OFFSET (symbolP, 1);
- add_number -= segP->scnhdr.s_vaddr;
-#endif
- } /* if pcrel */
+ if (filename_list_tail)
+ filename_list_tail->next = f;
+ else
+ filename_list_head = f;
+ filename_list_tail = f;
+ }
+ else
+ SA_SET_FILE_FNAME (symbolP, filename);
-#ifdef MD_APPLY_FIX3
- md_apply_fix3 (fixP, (valueT *) &add_number, this_segment_type);
-#else
- md_apply_fix (fixP, add_number);
+#ifndef NO_LISTING
+ {
+ extern int listing;
+ if (listing)
+ listing_source_file (filename);
+ }
#endif
- if (!fixP->fx_bit_fixP && ! fixP->fx_no_overflow)
- {
-#ifndef TC_M88K
- /* The m88k uses the offset field of the reloc to get around
- this problem. */
- if ((size == 1
- && ((add_number & ~0xFF)
- || (fixP->fx_signed && (add_number & 0x80)))
- && ((add_number & ~0xFF) != (-1 & ~0xFF)
- || (add_number & 0x80) == 0))
- || (size == 2
- && ((add_number & ~0xFFFF)
- || (fixP->fx_signed && (add_number & 0x8000)))
- && ((add_number & ~0xFFFF) != (-1 & ~0xFFFF)
- || (add_number & 0x8000) == 0)))
- {
- as_bad_where (fixP->fx_file, fixP->fx_line,
- _("Value of %ld too large for field of %d bytes at 0x%lx"),
- (long) add_number, size,
- (unsigned long) (fragP->fr_address + where));
- }
-#endif
-#ifdef WARN_SIGNED_OVERFLOW_WORD
- /* Warn if a .word value is too large when treated as a
- signed number. We already know it is not too negative.
- This is to catch over-large switches generated by gcc on
- the 68k. */
- if (!flag_signed_overflow_ok
- && size == 2
- && add_number > 0x7fff)
- as_bad_where (fixP->fx_file, fixP->fx_line,
- _("Signed .word overflow; switch may be too large; %ld at 0x%lx"),
- (long) add_number,
- (unsigned long) (fragP->fr_address + where));
-#endif
- } /* not a bit fix */
- } /* For each fixS in this segment. */
-} /* fixup_segment() */
+ SF_SET_DEBUG (symbolP);
+ S_SET_VALUE (symbolP, (valueT) previous_file_symbol);
-#endif
+ previous_file_symbol = symbolP;
+
+ /* Make sure that the symbol is first on the symbol chain. */
+ if (symbol_rootP != symbolP)
+ {
+ symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
+ symbol_insert (symbolP, symbol_rootP, &symbol_rootP, &symbol_lastP);
+ }
+}
+
+static void
+obj_coff_lcomm (int ignore ATTRIBUTE_UNUSED)
+{
+ s_lcomm (0);
+ return;
+}
/* The first entry in a .stab section is special. */
void
-obj_coff_init_stab_section (seg)
- segT seg;
+obj_coff_init_stab_section (segT seg)
{
char *file;
char *p;
char *stabstr_name;
unsigned int stroff;
- /* Make space for this first symbol. */
+ /* Make space for this first symbol. */
p = frag_more (12);
- /* Zero it out. */
+ /* Zero it out. */
memset (p, 0, 12);
as_where (&file, (unsigned int *) NULL);
- stabstr_name = (char *) alloca (strlen (segment_info[seg].name) + 4);
+ stabstr_name = alloca (strlen (segment_info[seg].name) + 4);
strcpy (stabstr_name, segment_info[seg].name);
strcat (stabstr_name, "str");
stroff = get_stab_string_offset (file, stabstr_name);
md_number_to_chars (p, stroff, 4);
}
-/* Fill in the counts in the first entry in a .stab section. */
-
-static void
-adjust_stab_section(abfd, seg)
- bfd *abfd;
- segT seg;
-{
- segT stabstrseg = SEG_UNKNOWN;
- const char *secname, *name2;
- char *name;
- char *p = NULL;
- int i, strsz = 0, nsyms;
- fragS *frag = segment_info[seg].frchainP->frch_root;
-
- /* Look for the associated string table section. */
-
- secname = segment_info[seg].name;
- name = (char *) alloca (strlen (secname) + 4);
- strcpy (name, secname);
- strcat (name, "str");
-
- for (i = SEG_E0; i < SEG_UNKNOWN; i++)
- {
- name2 = segment_info[i].name;
- if (name2 != NULL && strncmp(name2, name, 8) == 0)
- {
- stabstrseg = i;
- break;
- }
- }
-
- /* If we found the section, get its size. */
- if (stabstrseg != SEG_UNKNOWN)
- strsz = size_section (abfd, stabstrseg);
-
- nsyms = size_section (abfd, seg) / 12 - 1;
-
- /* Look for the first frag of sufficient size for the initial stab
- symbol, and collect a pointer to it. */
- while (frag && frag->fr_fix < 12)
- frag = frag->fr_next;
- assert (frag != 0);
- p = frag->fr_literal;
- assert (p != 0);
-
- /* Write in the number of stab symbols and the size of the string
- table. */
- bfd_h_put_16 (abfd, (bfd_vma) nsyms, (bfd_byte *) p + 6);
- bfd_h_put_32 (abfd, (bfd_vma) strsz, (bfd_byte *) p + 8);
-}
-
#endif /* not BFD_ASSEMBLER */
-const pseudo_typeS obj_pseudo_table[] =
+const pseudo_typeS coff_pseudo_table[] =
{
+ {"ABORT", s_abort, 0},
+ {"appline", obj_coff_ln, 1},
+ /* We accept the .bss directive for backward compatibility with
+ earlier versions of gas. */
+ {"bss", obj_coff_bss, 0},
{"def", obj_coff_def, 0},
{"dim", obj_coff_dim, 0},
{"endef", obj_coff_endef, 0},
+ {"ident", obj_coff_ident, 0},
{"line", obj_coff_line, 0},
{"ln", obj_coff_ln, 0},
-#ifdef BFD_ASSEMBLER
- {"loc", obj_coff_loc, 0},
-#endif
- {"appline", obj_coff_ln, 1},
{"scl", obj_coff_scl, 0},
+ {"sect", obj_coff_section, 0},
+ {"sect.s", obj_coff_section, 0},
+ {"section", obj_coff_section, 0},
+ {"section.s", obj_coff_section, 0},
+ /* FIXME: We ignore the MRI short attribute. */
{"size", obj_coff_size, 0},
{"tag", obj_coff_tag, 0},
{"type", obj_coff_type, 0},
{"val", obj_coff_val, 0},
- {"section", obj_coff_section, 0},
- {"sect", obj_coff_section, 0},
- /* FIXME: We ignore the MRI short attribute. */
- {"section.s", obj_coff_section, 0},
- {"sect.s", obj_coff_section, 0},
- /* We accept the .bss directive for backward compatibility with
- earlier versions of gas. */
- {"bss", obj_coff_bss, 0},
+ {"version", s_ignore, 0},
+#ifdef BFD_ASSEMBLER
+ {"loc", obj_coff_loc, 0},
+ {"optim", s_ignore, 0}, /* For sun386i cc (?) */
{"weak", obj_coff_weak, 0},
- {"ident", obj_coff_ident, 0},
-#ifndef BFD_ASSEMBLER
- {"use", obj_coff_section, 0},
- {"text", obj_coff_text, 0},
+#else
{"data", obj_coff_data, 0},
{"lcomm", obj_coff_lcomm, 0},
-#else
- {"optim", s_ignore, 0}, /* For sun386i cc (?) */
+ {"text", obj_coff_text, 0},
+ {"use", obj_coff_section, 0},
#endif
- {"version", s_ignore, 0},
- {"ABORT", s_abort, 0},
-#ifdef TC_M88K
- /* The m88k uses sdef instead of def. */
+#if defined TC_M88K || defined TC_TIC4X
+ /* The m88k and tic4x uses sdef instead of def. */
{"sdef", obj_coff_def, 0},
#endif
- {NULL, NULL, 0} /* end sentinel */
-}; /* obj_pseudo_table */
+ {NULL, NULL, 0}
+};
\f
#ifdef BFD_ASSEMBLER
-static void coff_pop_insert PARAMS ((void));
-static int coff_sec_sym_ok_for_reloc PARAMS ((asection *));
-
/* Support for a COFF emulation. */
static void
-coff_pop_insert ()
+coff_pop_insert (void)
{
- pop_insert (obj_pseudo_table);
+ pop_insert (coff_pseudo_table);
}
static int
-coff_sec_sym_ok_for_reloc (sec)
- asection *sec ATTRIBUTE_UNUSED;
+coff_separate_stab_sections (void)
{
- return 0;
+ return 1;
}
const struct format_ops coff_format_ops =
{
bfd_target_coff_flavour,
- 0,
- 1,
+ 0, /* dfl_leading_underscore */
+ 1, /* emit_section_symbols */
+ 0, /* begin */
+ c_dot_file_symbol,
coff_frob_symbol,
- 0,
+ 0, /* frob_file */
+ 0, /* frob_file_before_adjust */
+ 0, /* frob_file_before_fix */
coff_frob_file_after_relocs,
- 0, 0,
- 0, 0,
- 0,
-#if 0
- obj_generate_asm_lineno,
-#else
- 0,
-#endif
-#if 0
- obj_stab,
-#else
- 0,
-#endif
- coff_sec_sym_ok_for_reloc,
+ 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 */
+ 0, /* generate_asm_lineno */
+ 0, /* process_stab */
+ coff_separate_stab_sections,
+ obj_coff_init_stab_section,
+ 0, /* sec_sym_ok_for_reloc */
coff_pop_insert,
-#if 0
- obj_set_ext,
-#else
- 0,
-#endif
+ 0, /* ecoff_set_ext */
coff_obj_read_begin_hook,
- coff_obj_symbol_new_hook,
+ coff_obj_symbol_new_hook
};
#endif