/* Generic ECOFF (Extended-COFF) routines.
- Copyright 1990, 91, 92, 93, 94, 95, 96, 1997 Free Software Foundation, Inc.
+ Copyright 1990, 1991, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001
+ Free Software Foundation, Inc.
Original version by Per Bothner.
Full support added by Ian Lance Taylor, ian@cygnus.com.
\f
/* This stuff is somewhat copied from coffcode.h. */
-static asection bfd_debug_section = { "*DEBUG*" };
+static asection bfd_debug_section =
+{
+ /* name, id, index, next, flags, user_set_vma, reloc_done, */
+ "*DEBUG*", 0, 0, NULL, 0, 0, 0,
+ /* linker_mark, gc_mark, segment_mark, vma, lma, _cooked_size, */
+ 0, 0, 0, 0, 0, 0,
+ /* _raw_size, output_offset, output_section, alignment_power, */
+ 0, 0, NULL, 0,
+ /* relocation, orelocation, reloc_count, filepos, rel_filepos, */
+ NULL, NULL, 0, 0, 0,
+ /* line_filepos, userdata, contents, lineno, lineno_count, */
+ 0, NULL, NULL, NULL, 0,
+ /* entsize, comdat, kept_section, moving_line_filepos, */
+ 0, NULL, NULL, 0,
+ /* target_index, used_by_bfd, constructor_chain, owner, */
+ 0, NULL, NULL, NULL,
+ /* symbol, */
+ (struct symbol_cache_entry *) NULL,
+ /* symbol_ptr_ptr, */
+ (struct symbol_cache_entry **) NULL,
+ /* link_order_head, link_order_tail */
+ NULL, NULL
+};
/* Create an ECOFF object. */
boolean
_bfd_ecoff_new_section_hook (abfd, section)
- bfd *abfd;
+ bfd *abfd ATTRIBUTE_UNUSED;
asection *section;
{
section->alignment_power = 4;
break;
case ALPHA_MAGIC:
- case ALPHA_MAGIC_BSD:
arch = bfd_arch_alpha;
mach = 0;
break;
ecoff_get_magic (abfd)
bfd *abfd;
{
- extern const bfd_target bsd_ecoffalpha_little_vec;
int big, little;
switch (bfd_get_arch (abfd))
return bfd_big_endian (abfd) ? big : little;
case bfd_arch_alpha:
- return (abfd->xvec == &bsd_ecoffalpha_little_vec
- ? ALPHA_MAGIC_BSD : ALPHA_MAGIC);
+ return ALPHA_MAGIC;
default:
abort ();
}
else if (strcmp (name, _RCONST) == 0)
styp = STYP_RCONST;
- else if (flags & SEC_CODE)
+ else if (flags & SEC_CODE)
styp = STYP_TEXT;
- else if (flags & SEC_DATA)
+ else if (flags & SEC_DATA)
styp = STYP_DATA;
else if (flags & SEC_READONLY)
styp = STYP_RDATA;
/* Get the BFD flags to use for a section. */
-/*ARGSUSED*/
flagword
-_bfd_ecoff_styp_to_sec_flags (abfd, hdr, name)
- bfd *abfd;
+_bfd_ecoff_styp_to_sec_flags (abfd, hdr, name, section)
+ bfd *abfd ATTRIBUTE_UNUSED;
PTR hdr;
- const char *name;
+ const char *name ATTRIBUTE_UNUSED;
+ asection *section ATTRIBUTE_UNUSED;
{
struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr;
long styp_flags = internal_s->s_flags;
HDRR *internal_symhdr;
/* See if we've already read it in. */
- if (ecoff_data (abfd)->debug_info.symbolic_header.magic ==
+ if (ecoff_data (abfd)->debug_info.symbolic_header.magic ==
backend->debug_swap.sym_magic)
return true;
object file. This is called by gdb via the read_debug_info entry
point in the backend structure. */
-/*ARGSUSED*/
boolean
_bfd_ecoff_slurp_symbolic_info (abfd, ignore, debug)
bfd *abfd;
- asection *ignore;
+ asection *ignore ATTRIBUTE_UNUSED;
struct ecoff_debug_info *debug;
{
const struct ecoff_backend_data * const backend = ecoff_backend (abfd);
unsigned int ifd = rndx->rfd;
unsigned int indx = rndx->index;
const char *name;
-
+
if (ifd == 0xfff)
ifd = isym;
break;
default:
- sprintf (p1, "Unknown basic type %d", (int) basic_type);
+ sprintf (p1, _("Unknown basic type %d"), (int) basic_type);
break;
}
p1 += strlen (buffer1);
}
-
/*
* Deal with any qualifiers.
*/
int j;
/* Print array bounds reversed (ie, in the order the C
- programmer writes them). C is such a fun language.... */
+ programmer writes them). C is such a fun language.... */
while (i < 5 && qualifiers[i+1].type == tqArray)
i++;
/* Return information about ECOFF symbol SYMBOL in RET. */
-/*ARGSUSED*/
void
_bfd_ecoff_get_symbol_info (abfd, symbol, ret)
- bfd *abfd; /* Ignored. */
+ bfd *abfd ATTRIBUTE_UNUSED;
asymbol *symbol;
symbol_info *ret;
{
/* Return whether this is a local label. */
-/*ARGSUSED*/
boolean
_bfd_ecoff_bfd_is_local_label_name (abfd, name)
- bfd *abfd;
+ bfd *abfd ATTRIBUTE_UNUSED;
const char *name;
{
return name[0] == '$';
if (ecoffsymbol (symbol)->local)
{
SYMR ecoff_sym;
-
+
(*debug_swap->swap_sym_in) (abfd, ecoffsymbol (symbol)->native,
&ecoff_sym);
fprintf (file, "ecoff local ");
case stFile:
case stBlock:
- fprintf (file, "\n End+1 symbol: %ld",
+ fprintf (file, _("\n End+1 symbol: %ld"),
(long) (indx + sym_base));
break;
case stEnd:
if (ecoff_ext.asym.sc == scText
|| ecoff_ext.asym.sc == scInfo)
- fprintf (file, "\n First symbol: %ld",
+ fprintf (file, _("\n First symbol: %ld"),
(long) (indx + sym_base));
else
- fprintf (file, "\n First symbol: %ld",
+ fprintf (file, _("\n First symbol: %ld"),
((long)
(AUX_GET_ISYM (bigendian,
&aux_base[ecoff_ext.asym.index])
if (ECOFF_IS_STAB (&ecoff_ext.asym))
;
else if (ecoffsymbol (symbol)->local)
- fprintf (file, "\n End+1 symbol: %-7ld Type: %s",
+ fprintf (file, _("\n End+1 symbol: %-7ld Type: %s"),
((long)
(AUX_GET_ISYM (bigendian,
&aux_base[ecoff_ext.asym.index])
+ sym_base)),
ecoff_type_to_string (abfd, fdr, indx + 1));
else
- fprintf (file, "\n Local symbol: %ld",
+ fprintf (file, _("\n Local symbol: %ld"),
((long) indx
+ (long) sym_base
+ (ecoff_data (abfd)
break;
case stStruct:
- fprintf (file, "\n struct; End+1 symbol: %ld",
+ fprintf (file, _("\n struct; End+1 symbol: %ld"),
(long) (indx + sym_base));
break;
case stUnion:
- fprintf (file, "\n union; End+1 symbol: %ld",
+ fprintf (file, _("\n union; End+1 symbol: %ld"),
(long) (indx + sym_base));
break;
case stEnum:
- fprintf (file, "\n enum; End+1 symbol: %ld",
+ fprintf (file, _("\n enum; End+1 symbol: %ld"),
(long) (indx + sym_base));
break;
default:
if (! ECOFF_IS_STAB (&ecoff_ext.asym))
- fprintf (file, "\n Type: %s",
+ fprintf (file, _("\n Type: %s"),
ecoff_type_to_string (abfd, fdr, indx));
break;
}
if (_bfd_ecoff_slurp_symbol_table (abfd) == false)
return false;
-
+
internal_relocs = (arelent *) bfd_alloc (abfd,
(sizeof (arelent)
* section->reloc_count));
{
unsigned int count;
- if (section->flags & SEC_CONSTRUCTOR)
+ if (section->flags & SEC_CONSTRUCTOR)
{
arelent_chain *chain;
*relptr++ = &chain->relent;
}
else
- {
+ {
arelent *tblptr;
if (ecoff_slurp_reloc_table (abfd, section, symbols) == false)
and return the name of the source file and the line nearest to the
wanted location. */
-/*ARGSUSED*/
boolean
_bfd_ecoff_find_nearest_line (abfd, section, ignore_symbols, offset,
filename_ptr, functionname_ptr, retline_ptr)
bfd *abfd;
asection *section;
- asymbol **ignore_symbols;
+ asymbol **ignore_symbols ATTRIBUTE_UNUSED;
bfd_vma offset;
CONST char **filename_ptr;
CONST char **functionname_ptr;
/* Get the size of the section headers. */
-/*ARGSUSED*/
int
_bfd_ecoff_sizeof_headers (abfd, reloc)
bfd *abfd;
- boolean reloc;
+ boolean reloc ATTRIBUTE_UNUSED;
{
asection *current;
int c;
c = 0;
for (current = abfd->sections;
- current != (asection *)NULL;
- current = current->next)
+ current != (asection *)NULL;
+ current = current->next)
++c;
ret = (bfd_coff_filhsz (abfd)
abort ();
abfd->output_has_begun = true;
}
-
+
reloc_base = ecoff_data (abfd)->reloc_filepos;
reloc_size = 0;
for (current = abfd->sections;
- current != (asection *)NULL;
- current = current->next)
+ current != (asection *)NULL;
+ current = current->next)
{
if (current->reloc_count == 0)
current->rel_filepos = 0;
bfd_set_error (bfd_error_invalid_operation);
return 0;
}
-
+
return ecoff_data (abfd)->gp;
}
count = 1;
for (current = abfd->sections;
- current != (asection *)NULL;
- current = current->next)
+ current != (asection *)NULL;
+ current = current->next)
{
current->target_index = count;
++count;
/* Do nothing */ ;
else
abort ();
- }
+ }
/* Set up the file header. */
arelent *reloc;
asymbol *sym;
struct internal_reloc in;
-
+
memset ((PTR) &in, 0, sizeof in);
reloc = *reloc_ptr_ptr;
char *raw_ptr;
struct symdef *symdef_ptr;
char *stringbase;
-
+
/* Get the name of the first element. */
i = bfd_read ((PTR) nextname, 1, 16, abfd);
if (i == 0)
return false;
parsed_size = mapdata->parsed_size;
bfd_release (abfd, (PTR) mapdata);
-
+
raw_armap = (char *) bfd_alloc (abfd, parsed_size);
if (raw_armap == (char *) NULL)
return false;
-
+
if (bfd_read ((PTR) raw_armap, 1, parsed_size, abfd) != parsed_size)
{
if (bfd_get_error () != bfd_error_system_call)
bfd_release (abfd, (PTR) raw_armap);
return false;
}
-
+
ardata->tdata = (PTR) raw_armap;
count = bfd_h_get_32 (abfd, (PTR) raw_armap);
{
unsigned int name_offset, file_offset;
unsigned int hash, rehash, srch;
-
+
name_offset = bfd_h_get_32 (abfd, (PTR) raw_ptr);
file_offset = bfd_h_get_32 (abfd, (PTR) (raw_ptr + 4));
if (file_offset == 0)
/* Ultrix appears to use as a hash table size the least power of two
greater than twice the number of entries. */
- for (hashlog = 0; (1 << hashlog) <= 2 * orl_count; hashlog++)
+ for (hashlog = 0; ((unsigned int) 1 << hashlog) <= 2 * orl_count; hashlog++)
;
hashsize = 1 << hashlog;
padit = stridx % 2;
stringsize = stridx + padit;
- /* Include 8 bytes to store symdefsize and stringsize in output. */
+ /* Include 8 bytes to store symdefsize and stringsize in output. */
mapsize = symdefsize + stringsize + 8;
firstreal = SARMAG + sizeof (struct ar_hdr) + mapsize + elength;
armap. */
hdr.ar_uid[0] = '0';
hdr.ar_gid[0] = '0';
+#if 0
hdr.ar_mode[0] = '0';
+#else
+ /* Building gcc ends up extracting the armap as a file - twice. */
+ hdr.ar_mode[0] = '6';
+ hdr.ar_mode[1] = '4';
+ hdr.ar_mode[2] = '4';
+#endif
sprintf (hdr.ar_size, "%-10d", (int) mapsize);
/* Turn all null bytes in the header into spaces. */
for (i = 0; i < sizeof (struct ar_hdr); i++)
- if (((char *)(&hdr))[i] == '\0')
- (((char *)(&hdr))[i]) = ' ';
+ if (((char *) (&hdr))[i] == '\0')
+ (((char *) (&hdr))[i]) = ' ';
if (bfd_write ((PTR) &hdr, 1, sizeof (struct ar_hdr), abfd)
!= sizeof (struct ar_hdr))
bfd_h_put_32 (abfd, (bfd_vma) hashsize, temp);
if (bfd_write ((PTR) temp, 1, 4, abfd) != 4)
return false;
-
+
hashtable = (bfd_byte *) bfd_zalloc (abfd, symdefsize);
if (!hashtable)
return false;
hash = srch;
}
-
+
bfd_h_put_32 (abfd, (bfd_vma) map[i].namidx,
(PTR) (hashtable + hash * 8));
bfd_h_put_32 (abfd, (bfd_vma) firstreal,
bfd_ardata (abfd)->symdefs = NULL;
bfd_ardata (abfd)->extended_names = NULL;
bfd_ardata (abfd)->tdata = NULL;
-
+
if (_bfd_ecoff_slurp_armap (abfd) == false
|| _bfd_ecoff_slurp_extended_name_table (abfd) == false)
{
abfd->tdata.aout_ar_data = tdata_hold;
return (const bfd_target *) NULL;
}
-
+
if (bfd_has_map (abfd))
{
bfd *first;
bfd *output_bfd = einfo->abfd;
boolean strip;
- /* We need to check if this symbol is being stripped. */
+ /* We need to check if this symbol is being stripped. */
if (h->root.type == bfd_link_hash_undefined
|| h->root.type == bfd_link_hash_undefweak)
strip = false;
output_section = h->root.u.def.section->output_section;
name = bfd_section_name (output_section->owner, output_section);
-
+
if (strcmp (name, _TEXT) == 0)
h->esym.asym.sc = scText;
else if (strcmp (name, _DATA) == 0)
projects / deliverable / binutils-gdb.git / blobdiff