/* coff object file format
Copyright 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
- 1999, 2000, 2001
+ 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
/* This is used to hold the symbol built by a sequence of pseudo-ops
from .def and .endef. */
static symbolS *def_symbol_in_progress;
+#ifdef TE_PE
+/* PE weak alternate symbols begin with this string. */
+static const char weak_altprefix[] = ".weak.";
+#endif /* TE_PE */
typedef struct
{
}
stack;
-static stack *stack_init PARAMS ((unsigned long, unsigned long));
-static char *stack_push PARAMS ((stack *, char *));
-static char *stack_pop PARAMS ((stack *));
-static void tag_init PARAMS ((void));
-static void tag_insert PARAMS ((const char *, symbolS *));
-static symbolS *tag_find PARAMS ((char *));
-static symbolS *tag_find_or_make PARAMS ((char *));
-static void obj_coff_bss PARAMS ((int));
-static void obj_coff_weak 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));
-#endif
\f
-/* stack stuff */
+/* 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 ();
-
-#if defined BFD_ASSEMBLER || defined S_SET_WEAK
- 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 segT fetch_coff_debug_section PARAMS ((void));
-static void SA_SET_SYM_TAGNDX PARAMS ((symbolS *, symbolS *));
-static int S_GET_DATA_TYPE PARAMS ((symbolS *));
-void c_symbol_merge PARAMS ((symbolS *, symbolS *));
-static void add_lineno PARAMS ((fragS *, addressT, int));
-
#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. */
-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. */
SF_SET_DEBUG_FIELD (normal, SF_GET_DEBUG_FIELD (debug));
}
void
-c_dot_file_symbol (filename)
- const 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;
}
\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;
- addressT 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 ();
- }
+ abort ();
#ifndef OBJ_XCOFF
- /* The native aix assembler accepts negative line number */
+ /* The native aix assembler accepts negative line number. */
if (num <= 0)
{
}
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;
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 = 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. */
switch (S_GET_STORAGE_CLASS (def_symbol_in_progress))
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);
case C_EFCN:
SF_SET_LOCAL (def_symbol_in_progress); /* Do not emit this symbol. */
- /* intentional fallthrough */
+ /* 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':
#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
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. */
/* 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 */
+ /* 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;
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;
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. */
#ifndef BFD_HEADERS
}
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_LOCAL (symp)
&& !SF_GET_STATICS (symp)
&& S_GET_STORAGE_CLASS (symp) != C_LABEL
- && symbol_constant_p(symp)
- && (real = symbol_find_base (S_GET_NAME (symp), DO_NOT_STRIP))
+ && symbol_constant_p (symp)
+ && (real = symbol_find (S_GET_NAME (symp)))
&& S_GET_STORAGE_CLASS (real) == C_NULL
&& real != 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
{
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)));
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;
}
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;
{
case 'b': flags |= SEC_ALLOC; flags &=~ SEC_LOAD; break;
case 'n': flags &=~ SEC_LOAD; flags |= SEC_NEVER_LOAD; break;
- case 'd': flags |= SEC_DATA | SEC_LOAD; /* fall through */
+
+ 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;
/* 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 (strncmp (name, ".gnu.linkonce", sizeof (".gnu.linkonce") - 1) == 0)
- flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
+ 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 ()));
+ 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
+ /* 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_SHARED | SEC_NEVER_LOAD);
+ | SEC_DATA | SEC_COFF_SHARED | SEC_NEVER_LOAD);
if ((flags ^ oldflags) & matchflags)
as_warn (_("Ignoring changed section attributes for %s"), name);
}
}
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;
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_before_reloc (sec);
+ size = bfd_get_section_size (sec);
mask = ((bfd_vma) 1 << align_power) - 1;
#if !defined(TICOFF)
if (size & mask)
fragp = seg_info (sec)->frchainP->frch_root;
last = seg_info (sec)->frchainP->frch_last;
while (fragp->fr_next != last)
- fragp = fragp->fr_next;
+ fragp = fragp->fr_next;
last->fr_address = size;
fragp->fr_offset += new_size - size;
}
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;
/* 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 */
#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 */
+ 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 void fixup_segment PARAMS ((segment_info_type *segP,
- segT this_segment_type));
-
-static void fixup_mdeps PARAMS ((fragS *,
- object_headers *,
- segT));
-
-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));
+static symbolS *previous_file_symbol;
+static int line_base;
/* When not using BFD_ASSEMBLER, we permit up to 40 sections.
#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;
}
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;
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_bwrite ((PTR) external_reloc_vec,
+ /* Write out the reloc table. */
+ bfd_bwrite ((void *) external_reloc_vec,
(bfd_size_type) external_reloc_size, abfd);
free (external_reloc_vec);
}
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 postions
-*/
+/* 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. */
+
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;
}
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:
{
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)
}
}
-/* 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];
unsigned long string_size = 4;
#endif
- bfd_seek (abfd, (file_ptr) 0, 0);
+ bfd_seek (abfd, 0, 0);
#ifndef OBJ_COFF_OMIT_OPTIONAL_HEADER
H_SET_MAGIC_NUMBER (h, COFF_MAGIC);
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) */
string_size += strlen (segment_info[i].name) + 1;
}
#endif
-
size = bfd_coff_swap_scnhdr_out (abfd,
&(segment_info[i].scnhdr),
buffer);
}
}
-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 */
+ /* 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. */
switch (S_GET_STORAGE_CLASS (def_symbol_in_progress))
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 . */
def_symbol_in_progress->sy_frag = frag_now;
S_SET_VALUE (def_symbol_in_progress, (valueT) frag_now_fix ());
#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
&& !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,
/* 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 */
+ /* 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;
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 =
{
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. */
#ifndef BFD_HEADERS
}
/* 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. */
&& !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. */
/* 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. */
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);
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. */
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))
+ 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);
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.
- */
+ 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;
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;
((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;
*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
+#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
-#ifdef md_do_align
- md_do_align (SUB_SEGMENT_ALIGN (now_seg), (char *) NULL, 0, 0,
- alignment_done);
#endif
- if (subseg_text_p (now_seg))
- frag_align_code (SUB_SEGMENT_ALIGN (now_seg), 0);
- else
- frag_align (SUB_SEGMENT_ALIGN (now_seg), 0, 0);
-#ifdef md_do_align
- alignment_done:
-#endif
+static void
+w_symbols (bfd * abfd, char *where, symbolS * symbol_rootP)
+{
+ symbolS *symbolP;
+ unsigned int i;
- frag_wane (frag_now);
- frag_now->fr_fix = 0;
- know (frag_now->fr_next == NULL);
+ /* 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);
+ }
}
- remove_subsegs ();
-
- 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))
{
- relax_segment (segment_info[i].frchainP->frch_root, 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. */
+ char *temp;
- /* Relaxation has completed. Freeze all syms. */
- finalize_syms = 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;
- H_SET_NUMBER_OF_SECTIONS (&headers, 0);
+ tc_coff_symbol_emit_hook (symbolP);
- /* Find out how big the sections are, and set the addresses. */
- addr = 0;
- for (i = SEG_E0; i < SEG_UNKNOWN; i++)
- {
- long size;
-
- segment_info[i].scnhdr.s_paddr = addr;
- segment_info[i].scnhdr.s_vaddr = addr;
-
- if (segment_info[i].scnhdr.s_name[0])
+ temp = S_GET_NAME (symbolP);
+ if (SF_GET_STRING (symbolP))
{
- H_SET_NUMBER_OF_SECTIONS (&headers,
- H_GET_NUMBER_OF_SECTIONS (&headers) + 1);
-
-#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;
-
- len = strlen (segment_info[i].name);
- if (len > SCNNMLEN)
- string_byte_count += len + 1;
- }
-#endif /* COFF_LONG_SECTION_NAMES */
+ 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);
+#ifndef TC_FORCE_RELOCATION
+#define TC_FORCE_RELOCATION(fix) 0
+#endif
- if (string_byte_count == 4)
- string_byte_count = 0;
+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;
- H_SET_STRING_SIZE (&headers, string_byte_count);
+ for (fixP = segP->fix_root; fixP; fixP = fixP->fx_next)
+ {
+ fragP = fixP->fx_frag;
+ know (fragP);
+ where = fixP->fx_where;
+ place = fragP->fr_literal + where;
+ size = fixP->fx_size;
+ add_symbolP = fixP->fx_addsy;
+ sub_symbolP = fixP->fx_subsy;
+ add_number = fixP->fx_offset;
+ pcrel = fixP->fx_pcrel;
-#ifdef tc_frob_file
- tc_frob_file ();
-#endif
+ /* 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.
- for (i = SEG_E0; i < SEG_UNKNOWN; i++)
- {
- fixup_mdeps (segment_info[i].frchainP->frch_root, &headers, i);
- fixup_segment (&segment_info[i], i);
- }
+ 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;
- /* Look for ".stab" segments and fill in their initial symbols
- correctly. */
- for (i = SEG_E0; i < SEG_UNKNOWN; i++)
- {
- name = segment_info[i].name;
+#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
- if (name != NULL
- && strncmp (".stab", name, 5) == 0
- && strncmp (".stabstr", name, 8) != 0)
- adjust_stab_section (abfd, i);
- }
+ /* 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);
- file_cursor = H_GET_TEXT_FILE_OFFSET (&headers);
+ 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;
- bfd_seek (abfd, (file_ptr) file_cursor, 0);
+ /* 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;
+ }
+ }
- /* Plant the data */
+ if (sub_symbolP != NULL && ! sub_symbolP->sy_resolved)
+ resolve_symbol_value (sub_symbolP);
- fill_section (abfd, &headers, &file_cursor);
+ 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;
+ }
- do_relocs_for (abfd, &headers, &file_cursor);
+ if (add_symbolP)
+ add_symbol_segment = S_GET_SEGMENT (add_symbolP);
- do_linenos_for (abfd, &headers, &file_cursor);
+ 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;
+ }
- 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);
+ /* 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 */
-#ifndef COFF_FLAGS
-#define COFF_FLAGS 0
-#endif
+ /* 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;
-#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));
+ 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)));
- {
- unsigned int symtable_size = H_GET_SYMBOL_TABLE_SIZE (&headers);
- char *buffer1 = xmalloc (symtable_size + string_byte_count + 1);
+ if ((S_GET_SEGMENT (sub_symbolP) == absolute_section))
+ add_number -= S_GET_VALUE (sub_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_bwrite (buffer1, (bfd_size_type) symtable_size + string_byte_count,
- abfd);
- free (buffer1);
- }
-
- 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;
- }
+#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));
+ }
+ }
+ }
-}
-
-/* Add a new segment. This is called from subseg_new via the
- obj_new_segment macro. */
-
-segT
-obj_coff_add_segment (name)
- const char *name;
-{
- unsigned int i;
-
-#ifndef COFF_LONG_SECTION_NAMES
- char buf[SCNNMLEN + 1];
-
- strncpy (buf, name, SCNNMLEN);
- buf[SCNNMLEN] = '\0';
- name = buf;
+ 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
- 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;
- }
-
- /* 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 ());
-}
-
-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 ());
-}
+/* Fill in the counts in the first entry in a .stab section. */
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 */
-}
+ 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;
-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));
+ /* Look for the associated string table section. */
- 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 */
+ secname = segment_info[seg].name;
+ name = alloca (strlen (secname) + 4);
+ strcpy (name, secname);
+ strcat (name, "str");
- if (S_GET_NUMBER_AUXILIARY (debug) > 0)
+ for (i = SEG_E0; i < SEG_UNKNOWN; i++)
{
- 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() */
-
-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));
+ name2 = segment_info[i].name;
+ if (name2 != NULL && strneq (name2, name, 8))
+ {
+ stabstrseg = i;
+ break;
+ }
+ }
- segment_info_type *s = segment_info + now_seg;
- new_line->line.l_lnno = line_number;
+ /* If we found the section, get its size. */
+ if (stabstrseg != SEG_UNKNOWN)
+ strsz = size_section (abfd, stabstrseg);
- 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;
- }
+ nsyms = size_section (abfd, seg) / 12 - 1;
- new_line->frag = (char *) frag;
- new_line->next = (struct lineno_list *) NULL;
+ /* 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);
- 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++;
+ /* 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.
- */
-
-symbolS *
-c_section_symbol (name, idx)
- char *name;
- int idx;
-{
- symbolS *symbolP;
+ bfd_set_format (abfd, bfd_object);
+ bfd_set_arch_mach (abfd, BFD_ARCH, machine);
- symbolP = symbol_find_base (name, DO_NOT_STRIP);
- if (symbolP == NULL)
- symbolP = symbol_new (name, idx, 0, &zero_address_frag);
- else
+ string_byte_count = 4;
+
+ /* 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);
- demand_empty_rest_of_line ();
+ /* 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
-}
-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_align_test:
- case rs_org:
-#ifdef HANDLE_ALIGN
- HANDLE_ALIGN (frags);
+#ifndef COFF_FLAGS
+#define COFF_FLAGS 0
#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;
- }
+
+#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
+
+ {
+ 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. */
-#ifndef TC_FORCE_RELOCATION
-#define TC_FORCE_RELOCATION(fix) 0
+segT
+obj_coff_add_segment (const char *name)
+{
+ unsigned int i;
+
+#ifndef COFF_LONG_SECTION_NAMES
+ char buf[SCNNMLEN + 1];
+
+ 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;
+ as_bad (_("Too many new sections; can't add \"%s\""), name);
+ return now_seg;
+ }
- /* 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.
+ /* 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);
- 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;
+ return (segT) i;
+}
-#ifdef TC_I960
- if (fixP->fx_tcbit && SF_GET_CALLNAME (add_symbolP))
- {
- /* Relocation should be done via the associated 'bal' entry
- point symbol. */
+/* 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. */
- 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
+void
+obj_coff_section (int ignore ATTRIBUTE_UNUSED)
+{
+ /* Strip out the section name. */
+ char *section_name, *name;
+ char c;
+ unsigned int exp;
+ long flags;
- /* 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);
+ if (flag_mri)
+ {
+ char type;
- 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;
+ 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;
- /* 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;
- }
- }
+ return;
+ }
- if (sub_symbolP != NULL && ! sub_symbolP->sy_resolved)
- resolve_symbol_value (sub_symbolP);
+ section_name = input_line_pointer;
+ c = get_symbol_end ();
- 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;
- }
+ name = xmalloc (input_line_pointer - section_name + 1);
+ strcpy (name, section_name);
- if (add_symbolP)
- {
- add_symbol_segment = S_GET_SEGMENT (add_symbolP);
- } /* if there is an addend */
+ *input_line_pointer = c;
- 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;
- }
+ exp = 0;
+ flags = 0;
- /* 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 */
+ SKIP_WHITESPACE ();
+ if (*input_line_pointer == ',')
+ {
+ ++input_line_pointer;
+ SKIP_WHITESPACE ();
- /* 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))
+ 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])
{
- /* 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;
-
- if (!TC_FORCE_RELOCATION (fixP))
+ switch (*input_line_pointer)
{
- 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
+ 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;
}
- else
- {
- /* Different segments in subtraction. */
- know (!(S_IS_EXTERNAL (sub_symbolP) && (S_GET_SEGMENT (sub_symbolP) == absolute_section)));
+ if (*input_line_pointer == '"')
+ ++input_line_pointer;
+ }
+ }
- 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
- )
- {
- /* 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));
- } /* if absolute */
- }
- } /* if sub_symbolP */
+ subseg_new (name, (subsegT) exp);
- 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 */
+ segment_info[now_seg].scnhdr.s_flags |= flags;
- add_number += S_GET_VALUE (add_symbolP);
- add_number -= md_pcrel_from (fixP);
+ demand_empty_rest_of_line ();
+}
- /* 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. */
+static void
+obj_coff_text (int ignore ATTRIBUTE_UNUSED)
+{
+ subseg_new (".text", get_absolute_expression ());
+}
- 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_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 ());
+}
- if (!TC_FORCE_RELOCATION (fixP))
- {
- fixP->fx_addsy = NULL;
- fixP->fx_done = 1;
- }
- break;
- default:
+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;
- } /* switch on symbol seg */
- } /* if not in local seg */
- } /* if there was a + symbol */
+ symbolP = symbol_new (".file", SEG_DEBUG, 0, & zero_address_frag);
- 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.
+ S_SET_STORAGE_CLASS (symbolP, C_FILE);
+ S_SET_NUMBER_AUXILIARY (symbolP, 1);
- 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.
+ 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 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. */
+ f->filename = filename;
+ f->next = 0;
- add_number -= segP->scnhdr.s_vaddr;
-#endif
- } /* if pcrel */
+ SA_SET_FILE_FNAME_ZEROS (symbolP, 0);
+ SA_SET_FILE_FNAME_OFFSET (symbolP, 1);
-#ifdef MD_APPLY_FIX3
- md_apply_fix3 (fixP, (valueT *) &add_number, this_segment_type);
-#else
- md_apply_fix (fixP, add_number);
-#endif
+ 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);
- 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));
+#ifndef NO_LISTING
+ {
+ extern int listing;
+ if (listing)
+ listing_source_file (filename);
+ }
#endif
- } /* not a bit fix */
- } /* For each fixS in this segment. */
-} /* fixup_segment() */
-#endif
+ SF_SET_DEBUG (symbolP);
+ S_SET_VALUE (symbolP, (valueT) previous_file_symbol);
+
+ 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;
/* 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 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 */
-}; /* coff_pseudo_table */
+ {NULL, NULL, 0}
+};
\f
#ifdef BFD_ASSEMBLER
/* Support for a COFF emulation. */
-static void coff_pop_insert PARAMS ((void));
-static int coff_separate_stab_sections PARAMS ((void));
-
static void
-coff_pop_insert ()
+coff_pop_insert (void)
{
pop_insert (coff_pseudo_table);
}
static int
-coff_separate_stab_sections ()
+coff_separate_stab_sections (void)
{
return 1;
}
coff_frob_symbol,
0, /* frob_file */
0, /* frob_file_before_adjust */
+ 0, /* frob_file_before_fix */
coff_frob_file_after_relocs,
0, /* s_get_size */
0, /* s_set_size */
projects / deliverable / binutils-gdb.git / blobdiff