/* Support for the generic parts of most COFF variants, for BFD.
- Copyright (C) 1990-2021 Free Software Foundation, Inc.
+ Copyright (C) 1990-2023 Free Software Foundation, Inc.
Written by Cygnus Support.
This file is part of BFD, the Binary File Descriptor library.
in output BFDs at runtime; if it is false, as it will be by default
when generating an executable image, long section names are truncated;
if true, the long section names extension is employed. The hook
- points to a function that allows the value of the flag to be altered
- at runtime, on formats that support long section names at all; on
- other formats it points to a stub that returns an error indication.
+ points to a function that allows the value of a copy of the flag
+ in coff object tdata to be altered at runtime, on formats that
+ support long section names at all; on other formats it points
+ to a stub that returns an error indication.
With input BFDs, the flag is set according to whether any long section
names are detected while reading the section headers. For a completely
.typedef struct coff_ptr_struct
.{
. {* Remembers the offset from the first symbol in the file for
-. this symbol. Generated by coff_renumber_symbols. *}
+. this symbol. Generated by coff_renumber_symbols. *}
. unsigned int offset;
.
-. {* Should the value of this symbol be renumbered. Used for
-. XCOFF C_BSTAT symbols. Set by coff_slurp_symbol_table. *}
-. unsigned int fix_value : 1;
+. {* Selects between the elements of the union below. *}
+. unsigned int is_sym : 1;
.
-. {* Should the tag field of this symbol be renumbered.
-. Created by coff_pointerize_aux. *}
+. {* Selects between the elements of the x_sym.x_tagndx union. If set,
+. p is valid and the field will be renumbered. *}
. unsigned int fix_tag : 1;
.
-. {* Should the endidx field of this symbol be renumbered.
-. Created by coff_pointerize_aux. *}
+. {* Selects between the elements of the x_sym.x_fcnary.x_fcn.x_endndx
+. union. If set, p is valid and the field will be renumbered. *}
. unsigned int fix_end : 1;
.
-. {* Should the x_csect.x_scnlen field be renumbered.
-. Created by coff_pointerize_aux. *}
+. {* Selects between the elements of the x_csect.x_scnlen union. If set,
+. p is valid and the field will be renumbered. *}
. unsigned int fix_scnlen : 1;
.
-. {* Fix up an XCOFF C_BINCL/C_EINCL symbol. The value is the
-. index into the line number entries. Set by coff_slurp_symbol_table. *}
+. {* If set, u.syment.n_value contains a pointer to a symbol. The final
+. value will be the offset field. Used for XCOFF C_BSTAT symbols. *}
+. unsigned int fix_value : 1;
+.
+. {* If set, u.syment.n_value is an index into the line number entries.
+. Used for XCOFF C_BINCL/C_EINCL symbols. *}
. unsigned int fix_line : 1;
.
. {* The container for the symbol structure as read and translated
. struct internal_syment syment;
. } u;
.
-. {* Selector for the union above. *}
-. bfd_boolean is_sym;
+. {* An extra pointer which can used by format based on COFF (like XCOFF)
+. to provide extra information to their backend. *}
+. void *extrap;
.} combined_entry_type;
.
.
. struct lineno_cache_entry *lineno;
.
. {* Have the line numbers been relocated yet ? *}
-. bfd_boolean done_lineno;
+. bool done_lineno;
.} coff_symbol_type;
*/
/* Define a macro that can be used to initialise both the fields relating
to long section names in the backend data struct simultaneously. */
#if COFF_ENABLE_LONG_SECTION_NAMES
-#define COFF_DEFAULT_LONG_SECTION_NAMES (TRUE), COFF_LONG_SECTION_NAMES_SETTER
+#define COFF_DEFAULT_LONG_SECTION_NAMES (true), COFF_LONG_SECTION_NAMES_SETTER
#else /* !COFF_ENABLE_LONG_SECTION_NAMES */
-#define COFF_DEFAULT_LONG_SECTION_NAMES (FALSE), COFF_LONG_SECTION_NAMES_SETTER
+#define COFF_DEFAULT_LONG_SECTION_NAMES (false), COFF_LONG_SECTION_NAMES_SETTER
#endif /* COFF_ENABLE_LONG_SECTION_NAMES */
#if defined (COFF_LONG_SECTION_NAMES)
-static bfd_boolean bfd_coff_set_long_section_names_allowed
+static bool bfd_coff_set_long_section_names_allowed
(bfd *, int);
#else /* !defined (COFF_LONG_SECTION_NAMES) */
-static bfd_boolean bfd_coff_set_long_section_names_disallowed
+static bool bfd_coff_set_long_section_names_disallowed
(bfd *, int);
#endif /* defined (COFF_LONG_SECTION_NAMES) */
static long sec_to_styp_flags
(const char *, flagword);
-static bfd_boolean styp_to_sec_flags
+static bool styp_to_sec_flags
(bfd *, void *, const char *, asection *, flagword *);
-static bfd_boolean coff_bad_format_hook
+static bool coff_bad_format_hook
(bfd *, void *);
static void coff_set_custom_section_alignment
(bfd *, asection *, const struct coff_section_alignment_entry *,
const unsigned int);
-static bfd_boolean coff_new_section_hook
+static bool coff_new_section_hook
(bfd *, asection *);
-static bfd_boolean coff_set_arch_mach_hook
+static bool coff_set_arch_mach_hook
(bfd *, void *);
-static bfd_boolean coff_write_relocs
+static bool coff_write_relocs
(bfd *, int);
-static bfd_boolean coff_set_flags
+static bool coff_set_flags
(bfd *, unsigned int *, unsigned short *);
-static bfd_boolean coff_set_arch_mach
+static bool coff_set_arch_mach
(bfd *, enum bfd_architecture, unsigned long) ATTRIBUTE_UNUSED;
-static bfd_boolean coff_compute_section_file_positions
+static bool coff_compute_section_file_positions
(bfd *);
-static bfd_boolean coff_write_object_contents
+static bool coff_write_object_contents
(bfd *) ATTRIBUTE_UNUSED;
-static bfd_boolean coff_set_section_contents
+static bool coff_set_section_contents
(bfd *, asection *, const void *, file_ptr, bfd_size_type);
-static bfd_boolean coff_slurp_line_table
+static bool coff_slurp_line_table
(bfd *, asection *);
-static bfd_boolean coff_slurp_symbol_table
+static bool coff_slurp_symbol_table
(bfd *);
static enum coff_symbol_classification coff_classify_symbol
(bfd *, struct internal_syment *);
-static bfd_boolean coff_slurp_reloc_table
+static bool coff_slurp_reloc_table
(bfd *, asection *, asymbol **);
static long coff_canonicalize_reloc
(bfd *, asection *, arelent **, asymbol **);
(bfd *, flagword, void *, const char *, asection *);
#endif
#ifdef TICOFF
-static bfd_boolean ticoff0_bad_format_hook
+static bool ticoff0_bad_format_hook
(bfd *, void * );
-static bfd_boolean ticoff1_bad_format_hook
+static bool ticoff1_bad_format_hook
(bfd *, void * );
#endif
\f
/* void warning(); */
#if defined (COFF_LONG_SECTION_NAMES)
-static bfd_boolean
+static bool
bfd_coff_set_long_section_names_allowed (bfd *abfd, int enable)
{
- coff_backend_info (abfd)->_bfd_coff_long_section_names = enable;
- return TRUE;
+ bfd_coff_long_section_names (abfd) = enable;
+ return true;
}
#else /* !defined (COFF_LONG_SECTION_NAMES) */
-static bfd_boolean
-bfd_coff_set_long_section_names_disallowed (bfd *abfd, int enable)
+static bool
+bfd_coff_set_long_section_names_disallowed (bfd *abfd ATTRIBUTE_UNUSED,
+ int enable ATTRIBUTE_UNUSED)
{
- (void) abfd;
- (void) enable;
- return FALSE;
+ return false;
}
#endif /* defined (COFF_LONG_SECTION_NAMES) */
int i;
for (i = 0; i < XCOFF_DWSECT_NBR_NAMES; i++)
- if (!strcmp (sec_name, xcoff_dwsect_names[i].name))
+ if (!strcmp (sec_name, xcoff_dwsect_names[i].xcoff_name))
{
styp_flags = STYP_DWARF | xcoff_dwsect_names[i].flag;
break;
sec_to_styp_flags (const char *sec_name, flagword sec_flags)
{
long styp_flags = 0;
- bfd_boolean is_dbg = FALSE;
+ bool is_dbg = false;
if (startswith (sec_name, DOT_DEBUG)
|| startswith (sec_name, DOT_ZDEBUG)
|| startswith (sec_name, GNU_LINKONCE_WT)
#endif
|| startswith (sec_name, ".stab"))
- is_dbg = TRUE;
+ is_dbg = true;
/* caution: there are at least three groups of symbols that have
very similar bits and meanings: IMAGE_SCN*, SEC_*, and STYP_*.
#ifndef COFF_WITH_PE
-static bfd_boolean
+static bool
styp_to_sec_flags (bfd *abfd,
void * hdr,
const char *name,
flagword *flags_ptr)
{
struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr;
- long styp_flags = internal_s->s_flags;
+ unsigned long styp_flags = internal_s->s_flags;
flagword sec_flags = 0;
#ifdef STYP_BLOCK
#endif
if (flags_ptr == NULL)
- return FALSE;
+ return false;
* flags_ptr = sec_flags;
- return TRUE;
+ return true;
}
#else /* COFF_WITH_PE */
required information. FIXME: Is the COMDAT symbol index used for
any purpose other than objdump? */
-static bfd_boolean
+static bool
styp_to_sec_flags (bfd *abfd,
void * hdr,
const char *name,
struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr;
unsigned long styp_flags = internal_s->s_flags;
flagword sec_flags;
- bfd_boolean result = TRUE;
- bfd_boolean is_dbg = FALSE;
+ bool result = true;
+ bool is_dbg = false;
if (startswith (name, DOT_DEBUG)
|| startswith (name, DOT_ZDEBUG)
|| startswith (name, GNU_DEBUGALTLINK)
#endif
|| startswith (name, ".stab"))
- is_dbg = TRUE;
+ is_dbg = true;
/* Assume read only unless IMAGE_SCN_MEM_WRITE is specified. */
sec_flags = SEC_READONLY;
/* xgettext:c-format */
(_("%pB (%s): section flag %s (%#lx) ignored"),
abfd, name, unhandled, flag);
- result = FALSE;
+ result = false;
}
}
. unsigned int _bfd_relsz;
. unsigned int _bfd_linesz;
. unsigned int _bfd_filnmlen;
-. bfd_boolean _bfd_coff_long_filenames;
+. bool _bfd_coff_long_filenames;
.
-. bfd_boolean _bfd_coff_long_section_names;
-. bfd_boolean (*_bfd_coff_set_long_section_names)
+. bool _bfd_coff_long_section_names;
+. bool (*_bfd_coff_set_long_section_names)
. (bfd *, int);
.
. unsigned int _bfd_coff_default_section_alignment_power;
-. bfd_boolean _bfd_coff_force_symnames_in_strings;
+. bool _bfd_coff_force_symnames_in_strings;
. unsigned int _bfd_coff_debug_string_prefix_length;
. unsigned int _bfd_coff_max_nscns;
.
. void (*_bfd_coff_swap_reloc_in)
. (bfd *abfd, void *, void *);
.
-. bfd_boolean (*_bfd_coff_bad_format_hook)
+. bool (*_bfd_coff_bad_format_hook)
. (bfd *, void *);
.
-. bfd_boolean (*_bfd_coff_set_arch_mach_hook)
+. bool (*_bfd_coff_set_arch_mach_hook)
. (bfd *, void *);
.
. void * (*_bfd_coff_mkobject_hook)
. (bfd *, void *, void *);
.
-. bfd_boolean (*_bfd_styp_to_sec_flags_hook)
+. bool (*_bfd_styp_to_sec_flags_hook)
. (bfd *, void *, const char *, asection *, flagword *);
.
. void (*_bfd_set_alignment_hook)
. (bfd *, asection *, void *);
.
-. bfd_boolean (*_bfd_coff_slurp_symbol_table)
+. bool (*_bfd_coff_slurp_symbol_table)
. (bfd *);
.
-. bfd_boolean (*_bfd_coff_symname_in_debug)
+. bool (*_bfd_coff_symname_in_debug)
. (bfd *, struct internal_syment *);
.
-. bfd_boolean (*_bfd_coff_pointerize_aux_hook)
+. bool (*_bfd_coff_pointerize_aux_hook)
. (bfd *, combined_entry_type *, combined_entry_type *,
. unsigned int, combined_entry_type *);
.
-. bfd_boolean (*_bfd_coff_print_aux)
+. bool (*_bfd_coff_print_aux)
. (bfd *, FILE *, combined_entry_type *, combined_entry_type *,
. combined_entry_type *, unsigned int);
.
-. void (*_bfd_coff_reloc16_extra_cases)
+. bool (*_bfd_coff_reloc16_extra_cases)
. (bfd *, struct bfd_link_info *, struct bfd_link_order *, arelent *,
-. bfd_byte *, unsigned int *, unsigned int *);
+. bfd_byte *, size_t *, size_t *);
.
. int (*_bfd_coff_reloc16_estimate)
. (bfd *, asection *, arelent *, unsigned int,
. enum coff_symbol_classification (*_bfd_coff_classify_symbol)
. (bfd *, struct internal_syment *);
.
-. bfd_boolean (*_bfd_coff_compute_section_file_positions)
+. bool (*_bfd_coff_compute_section_file_positions)
. (bfd *);
.
-. bfd_boolean (*_bfd_coff_start_final_link)
+. bool (*_bfd_coff_start_final_link)
. (bfd *, struct bfd_link_info *);
.
-. bfd_boolean (*_bfd_coff_relocate_section)
+. bool (*_bfd_coff_relocate_section)
. (bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
. struct internal_reloc *, struct internal_syment *, asection **);
.
. (bfd *, asection *, struct internal_reloc *,
. struct coff_link_hash_entry *, struct internal_syment *, bfd_vma *);
.
-. bfd_boolean (*_bfd_coff_adjust_symndx)
+. bool (*_bfd_coff_adjust_symndx)
. (bfd *, struct bfd_link_info *, bfd *, asection *,
-. struct internal_reloc *, bfd_boolean *);
+. struct internal_reloc *, bool *);
.
-. bfd_boolean (*_bfd_coff_link_add_one_symbol)
+. bool (*_bfd_coff_link_add_one_symbol)
. (struct bfd_link_info *, bfd *, const char *, flagword,
-. asection *, bfd_vma, const char *, bfd_boolean, bfd_boolean,
+. asection *, bfd_vma, const char *, bool, bool,
. struct bfd_link_hash_entry **);
.
-. bfd_boolean (*_bfd_coff_link_output_has_begun)
+. bool (*_bfd_coff_link_output_has_begun)
. (bfd *, struct coff_final_link_info *);
.
-. bfd_boolean (*_bfd_coff_final_link_postscript)
+. bool (*_bfd_coff_final_link_postscript)
. (bfd *, struct coff_final_link_info *);
.
-. bfd_boolean (*_bfd_coff_print_pdata)
+. bool (*_bfd_coff_print_pdata)
. (bfd *, void *);
.
.} bfd_coff_backend_data;
.
.#define coff_backend_info(abfd) \
-. ((bfd_coff_backend_data *) (abfd)->xvec->backend_data)
+. ((const bfd_coff_backend_data *) (abfd)->xvec->backend_data)
.
.#define bfd_coff_swap_aux_in(a,e,t,c,ind,num,i) \
. ((coff_backend_info (a)->_bfd_coff_swap_aux_in) (a,e,t,c,ind,num,i))
.#define bfd_coff_long_filenames(abfd) \
. (coff_backend_info (abfd)->_bfd_coff_long_filenames)
.#define bfd_coff_long_section_names(abfd) \
-. (coff_backend_info (abfd)->_bfd_coff_long_section_names)
+. (coff_data (abfd)->long_section_names)
.#define bfd_coff_set_long_section_names(abfd, enable) \
. ((coff_backend_info (abfd)->_bfd_coff_set_long_section_names) (abfd, enable))
.#define bfd_coff_default_section_alignment_power(abfd) \
/* See whether the magic number matches. */
-static bfd_boolean
+static bool
coff_bad_format_hook (bfd * abfd ATTRIBUTE_UNUSED, void * filehdr)
{
struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
if (BADMAG (*internal_f))
- return FALSE;
+ return false;
- return TRUE;
+ return true;
}
#ifdef TICOFF
-static bfd_boolean
+static bool
ticoff0_bad_format_hook (bfd *abfd ATTRIBUTE_UNUSED, void * filehdr)
{
struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
if (COFF0_BADMAG (*internal_f))
- return FALSE;
+ return false;
- return TRUE;
+ return true;
}
#endif
#ifdef TICOFF
-static bfd_boolean
+static bool
ticoff1_bad_format_hook (bfd *abfd ATTRIBUTE_UNUSED, void * filehdr)
{
struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
if (COFF1_BADMAG (*internal_f))
- return FALSE;
+ return false;
- return TRUE;
+ return true;
}
#endif
/* Initialize a section structure with information peculiar to this
particular implementation of COFF. */
-static bfd_boolean
+static bool
coff_new_section_hook (bfd * abfd, asection * section)
{
combined_entry_type *native;
for (i = 0; i < XCOFF_DWSECT_NBR_NAMES; i++)
if (strcmp (bfd_section_name (section),
- xcoff_dwsect_names[i].name) == 0)
+ xcoff_dwsect_names[i].xcoff_name) == 0)
{
section->alignment_power = 0;
sclass = C_DWARF;
/* Set up the section symbol. */
if (!_bfd_generic_new_section_hook (abfd, section))
- return FALSE;
+ return false;
/* Allocate aux records for section symbols, to store size and
related info.
amt = sizeof (combined_entry_type) * 10;
native = (combined_entry_type *) bfd_zalloc (abfd, amt);
if (native == NULL)
- return FALSE;
+ return false;
/* We don't need to set up n_name, n_value, or n_scnum in the native
symbol information, since they'll be overridden by the BFD symbol
in case this symbol winds up getting written out. The value 0
for n_numaux is already correct. */
- native->is_sym = TRUE;
+ native->is_sym = true;
native->u.syment.n_type = T_NULL;
native->u.syment.n_sclass = sclass;
coff_section_alignment_table,
coff_section_alignment_table_size);
- return TRUE;
+ return true;
}
#ifdef COFF_ALIGN_IN_SECTION_HEADER
if (bfd_bread (& dst, relsz, abfd) != relsz)
return;
- coff_swap_reloc_in (abfd, &dst, &n);
+ bfd_coff_swap_reloc_in (abfd, &dst, &n);
if (bfd_seek (abfd, oldpos, 0) != 0)
return;
+ if (n.r_vaddr < 0x10000)
+ {
+ _bfd_error_handler (_("%pB: overflow reloc count too small"), abfd);
+ bfd_set_error (bfd_error_bad_value);
+ return;
+ }
section->reloc_count = hdr->s_nreloc = n.r_vaddr - 1;
section->rel_filepos += relsz;
}
if (bfd_bread (& dst, relsz, abfd) != relsz)
return;
- coff_swap_reloc_in (abfd, &dst, &n);
+ bfd_coff_swap_reloc_in (abfd, &dst, &n);
if (bfd_seek (abfd, oldpos, 0) != 0)
return;
section->reloc_count = hdr->s_nreloc = n.r_vaddr - 1;
#ifndef coff_mkobject
-static bfd_boolean
+static bool
coff_mkobject (bfd * abfd)
{
coff_data_type *coff;
abfd->tdata.coff_obj_data = bfd_zalloc (abfd, amt);
if (abfd->tdata.coff_obj_data == NULL)
- return FALSE;
+ return false;
coff = coff_data (abfd);
coff->symbols = NULL;
coff->conversion_table = NULL;
coff->relocbase = 0;
coff->local_toc_sym_map = 0;
+ bfd_coff_long_section_names (abfd)
+ = coff_backend_info (abfd)->_bfd_coff_long_section_names;
+
/* make_abs_section(abfd);*/
- return TRUE;
+ return true;
}
#endif
# else
xcoff->xcoff64 = 0;
# endif
- xcoff->full_aouthdr = TRUE;
+ xcoff->full_aouthdr = true;
xcoff->toc = internal_a->o_toc;
xcoff->sntoc = internal_a->o_sntoc;
xcoff->snentry = internal_a->o_snentry;
would be target independent and would also be much more successful
at linking together COFF files for different architectures. */
-static bfd_boolean
+static bool
coff_set_arch_mach_hook (bfd *abfd, void * filehdr)
{
unsigned long machine;
}
break;
#endif
+#ifdef AARCH64MAGIC
+ case AARCH64MAGIC:
+ arch = bfd_arch_aarch64;
+ machine = internal_f->f_flags & F_AARCH64_ARCHITECTURE_MASK;
+ break;
+#endif
+#ifdef LOONGARCH64MAGIC
+ case LOONGARCH64MAGIC:
+ arch = bfd_arch_loongarch;
+ machine = internal_f->f_flags & F_LOONGARCH64_ARCHITECTURE_MASK;
+ break;
+#endif
#ifdef Z80MAGIC
case Z80MAGIC:
arch = bfd_arch_z80;
machine = ((unsigned)internal_f->f_flags & F_MACHMASK) >> 12;
break;
default:
- return FALSE;
+ return false;
}
break;
#endif
machine = bfd_mach_z8002;
break;
default:
- return FALSE;
+ return false;
}
break;
#endif
bfd_size_type amt = bfd_coff_symesz (abfd);
if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0)
- return FALSE;
+ return false;
buf = _bfd_malloc_and_read (abfd, amt, amt);
if (buf == NULL)
- return FALSE;
+ return false;
bfd_coff_swap_sym_in (abfd, buf, & sym);
if (sym.n_sclass == C_FILE)
cputype = sym.n_type & 0xff;
}
bfd_default_set_arch_mach (abfd, arch, machine);
- return TRUE;
+ return true;
}
-static bfd_boolean
+static bool
symname_in_debug_hook (bfd *abfd ATTRIBUTE_UNUSED,
struct internal_syment *sym ATTRIBUTE_UNUSED)
{
#ifdef SYMNAME_IN_DEBUG
return SYMNAME_IN_DEBUG (sym) != 0;
#else
- return FALSE;
+ return false;
#endif
}
/* Handle the csect auxent of a C_EXT, C_AIX_WEAKEXT or C_HIDEXT symbol. */
-static bfd_boolean
+static bool
coff_pointerize_aux_hook (bfd *abfd ATTRIBUTE_UNUSED,
combined_entry_type *table_base,
combined_entry_type *symbol,
&& indaux + 1 == symbol->u.syment.n_numaux)
{
BFD_ASSERT (! aux->is_sym);
- if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) == XTY_LD)
+ if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) == XTY_LD
+ && aux->u.auxent.x_csect.x_scnlen.u64 < obj_raw_syment_count (abfd))
{
aux->u.auxent.x_csect.x_scnlen.p =
- table_base + aux->u.auxent.x_csect.x_scnlen.l;
+ table_base + aux->u.auxent.x_csect.x_scnlen.u64;
aux->fix_scnlen = 1;
}
/* Return TRUE to indicate that the caller should not do any
further work on this auxent. */
- return TRUE;
+ return true;
}
/* Return FALSE to indicate that this auxent should be handled by
the caller. */
- return FALSE;
+ return false;
}
#else
/* Print an aux entry. This returns TRUE if it has printed it. */
-static bfd_boolean
+static bool
coff_print_aux (bfd *abfd ATTRIBUTE_UNUSED,
FILE *file ATTRIBUTE_UNUSED,
combined_entry_type *table_base ATTRIBUTE_UNUSED,
if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) != XTY_LD)
{
BFD_ASSERT (! aux->fix_scnlen);
- fprintf (file, "val %5" BFD_VMA_FMT "d",
- aux->u.auxent.x_csect.x_scnlen.l);
+ fprintf (file, "val %5" PRIu64,
+ aux->u.auxent.x_csect.x_scnlen.u64);
}
else
{
fprintf (file, "indx ");
if (! aux->fix_scnlen)
- fprintf (file, "%4" BFD_VMA_FMT "d",
- aux->u.auxent.x_csect.x_scnlen.l);
+ fprintf (file, "%4" PRIu64,
+ aux->u.auxent.x_csect.x_scnlen.u64);
else
fprintf (file, "%4ld",
(long) (aux->u.auxent.x_csect.x_scnlen.p - table_base));
}
fprintf (file,
- " prmhsh %ld snhsh %u typ %d algn %d clss %u stb %ld snstb %u",
+ " prmhsh %u snhsh %u typ %d algn %d clss %u stb %u snstb %u",
aux->u.auxent.x_csect.x_parmhash,
(unsigned int) aux->u.auxent.x_csect.x_snhash,
SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp),
(unsigned int) aux->u.auxent.x_csect.x_smclas,
aux->u.auxent.x_csect.x_stab,
(unsigned int) aux->u.auxent.x_csect.x_snstab);
- return TRUE;
+ return true;
}
#endif
/* Return FALSE to indicate that no special action was taken. */
- return FALSE;
+ return false;
}
/*
#endif /* TARG_AUX */
-static bfd_boolean
+static bool
coff_write_relocs (bfd * abfd, int first_undef)
{
asection *s;
if (p == NULL)
{
if (s->reloc_count > 0)
- return FALSE;
+ return false;
}
else
{
#endif
if (bfd_seek (abfd, s->rel_filepos, SEEK_SET) != 0)
- return FALSE;
+ return false;
#ifdef COFF_WITH_EXTENDED_RELOC_COUNTER
if ((obj_pe (abfd) || obj_go32 (abfd)) && s->reloc_count >= 0xffff)
coff_swap_reloc_out (abfd, &n, &dst);
if (bfd_bwrite (& dst, (bfd_size_type) bfd_coff_relsz (abfd),
abfd) != bfd_coff_relsz (abfd))
- return FALSE;
+ return false;
}
#endif
_bfd_error_handler (_("%pB: reloc against a non-existent"
" symbol index: %ld"),
abfd, n.r_symndx);
- return FALSE;
+ return false;
}
}
}
#ifdef SELECT_RELOC
/* Work out reloc type from what is required. */
- SELECT_RELOC (n, q->howto);
+ if (q->howto)
+ SELECT_RELOC (n, q->howto);
#else
- n.r_type = q->howto->type;
+ if (q->howto)
+ n.r_type = q->howto->type;
#endif
coff_swap_reloc_out (abfd, &n, &dst);
if (bfd_bwrite (& dst, (bfd_size_type) bfd_coff_relsz (abfd),
abfd) != bfd_coff_relsz (abfd))
- return FALSE;
+ return false;
}
#ifdef TARG_AUX
#endif
}
- return TRUE;
+ return true;
}
/* Set flags and magic number of a coff file from architecture and machine
type. Result is TRUE if we can represent the arch&type, FALSE if not. */
-static bfd_boolean
+static bool
coff_set_flags (bfd * abfd,
unsigned int *magicp ATTRIBUTE_UNUSED,
unsigned short *flagsp ATTRIBUTE_UNUSED)
*flagsp = bfd_get_mach (abfd) << 12;
break;
default:
- return FALSE;
+ return false;
}
- return TRUE;
+ return true;
#endif
#ifdef Z8KMAGIC
{
case bfd_mach_z8001: *flagsp = F_Z8001; break;
case bfd_mach_z8002: *flagsp = F_Z8002; break;
- default: return FALSE;
+ default: return false;
}
- return TRUE;
+ return true;
#endif
#ifdef TIC30MAGIC
case bfd_arch_tic30:
*magicp = TIC30MAGIC;
- return TRUE;
+ return true;
#endif
#ifdef TICOFF_DEFAULT_MAGIC
*magicp = TICOFF2MAGIC;
break;
default:
- return FALSE;
+ return false;
}
}
TICOFF_TARGET_MACHINE_SET (flagsp, bfd_get_mach (abfd));
- return TRUE;
+ return true;
+#endif
+
+#ifdef AARCH64MAGIC
+ case bfd_arch_aarch64:
+ * magicp = AARCH64MAGIC;
+ return true;
+#endif
+
+#ifdef LOONGARCH64MAGIC
+ case bfd_arch_loongarch:
+ * magicp = LOONGARCH64MAGIC;
+ return true;
#endif
#ifdef ARMMAGIC
case bfd_mach_arm_5TE: * flagsp |= F_ARM_5; break;
case bfd_mach_arm_XScale: * flagsp |= F_ARM_5; break;
}
- return TRUE;
+ return true;
#endif
#if defined(I386MAGIC) || defined(AMD64MAGIC)
#if defined AMD64MAGIC
*magicp = AMD64MAGIC;
#endif
- return TRUE;
+ return true;
#endif
#ifdef IA64MAGIC
case bfd_arch_ia64:
*magicp = IA64MAGIC;
- return TRUE;
+ return true;
#endif
#ifdef SH_ARCH_MAGIC_BIG
else
*magicp = SH_ARCH_MAGIC_LITTLE;
#endif
- return TRUE;
+ return true;
#endif
#ifdef MIPS_ARCH_MAGIC_WINCE
case bfd_arch_mips:
*magicp = MIPS_ARCH_MAGIC_WINCE;
- return TRUE;
+ return true;
#endif
#ifdef SPARCMAGIC
/* Just overwrite the usual value if we're doing Lynx. */
*magicp = LYNXCOFFMAGIC;
#endif
- return TRUE;
+ return true;
#endif
#ifdef RS6000COFF_C
case bfd_arch_powerpc:
BFD_ASSERT (bfd_get_flavour (abfd) == bfd_target_xcoff_flavour);
*magicp = bfd_xcoff_magic_number (abfd);
- return TRUE;
+ return true;
#endif
#ifdef MCOREMAGIC
case bfd_arch_mcore:
* magicp = MCOREMAGIC;
- return TRUE;
+ return true;
#endif
default: /* Unknown architecture. */
- /* Fall through to "return FALSE" below, to avoid
- "statement never reached" errors on the one below. */
break;
}
- return FALSE;
+ return false;
}
-static bfd_boolean
+static bool
coff_set_arch_mach (bfd * abfd,
enum bfd_architecture arch,
unsigned long machine)
unsigned short dummy2;
if (! bfd_default_set_arch_mach (abfd, arch, machine))
- return FALSE;
+ return false;
if (arch != bfd_arch_unknown
&& ! coff_set_flags (abfd, &dummy1, &dummy2))
- return FALSE; /* We can't represent this type. */
+ return false; /* We can't represent this type. */
- return TRUE; /* We're easy... */
+ return true; /* We're easy... */
}
#ifdef COFF_IMAGE_WITH_PE
#undef ALIGN_SECTIONS_IN_FILE
#endif
-static bfd_boolean
+static bool
coff_compute_section_file_positions (bfd * abfd)
{
asection *current;
file_ptr sofar = bfd_coff_filhsz (abfd);
- bfd_boolean align_adjust;
+ bool align_adjust;
unsigned int target_index;
#ifdef ALIGN_SECTIONS_IN_FILE
asection *previous = NULL;
#endif
#ifdef COFF_IMAGE_WITH_PE
- int page_size;
+ unsigned int page_size;
if (coff_data (abfd)->link_info
|| (pe_data (abfd) && pe_data (abfd)->pe_opthdr.FileAlignment))
This repairs 'ld -r' for arm-wince-pe target. */
if (page_size == 0)
page_size = 1;
-
- /* PR 17512: file: 0ac816d3. */
- if (page_size < 0)
- {
- bfd_set_error (bfd_error_file_too_big);
- _bfd_error_handler
- /* xgettext:c-format */
- (_("%pB: page size is too large (0x%x)"), abfd, page_size);
- return FALSE;
- }
}
else
page_size = PE_DEF_FILE_ALIGNMENT;
#else
#ifdef COFF_PAGE_SIZE
- int page_size = COFF_PAGE_SIZE;
+ unsigned int page_size = COFF_PAGE_SIZE;
#endif
#endif
bfd_size_type amt;
#ifdef COFF_PAGE_SIZE
- /* Clear D_PAGED if section alignment is smaller than
- COFF_PAGE_SIZE. */
- if (pe_data (abfd)->pe_opthdr.SectionAlignment < COFF_PAGE_SIZE)
+ /* Clear D_PAGED if section / file alignment aren't suitable for
+ paging at COFF_PAGE_SIZE granularity. */
+ if (pe_data (abfd)->pe_opthdr.SectionAlignment < COFF_PAGE_SIZE
+ || page_size < COFF_PAGE_SIZE)
abfd->flags &= ~D_PAGED;
#endif
amt = sizeof (struct asection *) * (count + 1);
section_list = (asection **) bfd_malloc (amt);
if (section_list == NULL)
- return FALSE;
+ return false;
i = 0;
for (current = abfd->sections; current != NULL; current = current->next)
_bfd_error_handler
/* xgettext:c-format */
(_("%pB: too many sections (%d)"), abfd, target_index);
- return FALSE;
+ return false;
}
- align_adjust = FALSE;
+ align_adjust = false;
for (current = abfd->sections;
current != NULL;
current = current->next)
current->used_by_bfd = bfd_zalloc (abfd, amt);
if (current->used_by_bfd == NULL)
- return FALSE;
+ return false;
}
if (pei_section_data (abfd, current) == NULL)
{
coff_section_data (abfd, current)->tdata = bfd_zalloc (abfd, amt);
if (coff_section_data (abfd, current)->tdata == NULL)
- return FALSE;
+ return false;
}
if (pei_section_data (abfd, current)->virt_size == 0)
pei_section_data (abfd, current)->virt_size = current->size;
padding the previous section up if necessary. */
old_sofar = sofar;
- sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
+#ifdef COFF_IMAGE_WITH_PE
+ sofar = BFD_ALIGN (sofar, page_size);
+#else
+ sofar = BFD_ALIGN (sofar, (bfd_vma) 1 << current->alignment_power);
+#endif
#ifdef RS6000COFF_C
/* Make sure the file offset and the vma of .text/.data are at the
old_size = current->size;
current->size = BFD_ALIGN (current->size,
- 1 << current->alignment_power);
+ (bfd_vma) 1 << current->alignment_power);
align_adjust = current->size != old_size;
sofar += current->size - old_size;
}
else
{
old_sofar = sofar;
- sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
+#ifdef COFF_IMAGE_WITH_PE
+ sofar = BFD_ALIGN (sofar, page_size);
+#else
+ sofar = BFD_ALIGN (sofar, (bfd_vma) 1 << current->alignment_power);
+#endif
align_adjust = sofar != old_sofar;
current->size += sofar - old_sofar;
}
size, in case the caller only writes out data to the
unaligned size. */
if (pei_section_data (abfd, current)->virt_size < current->size)
- align_adjust = TRUE;
+ align_adjust = true;
#endif
#ifdef _LIB
b = 0;
if (bfd_seek (abfd, sofar - 1, SEEK_SET) != 0
|| bfd_bwrite (&b, (bfd_size_type) 1, abfd) != 1)
- return FALSE;
+ return false;
}
/* Make sure the relocations are aligned. We don't need to make
sure that this byte exists, because it will only matter if there
really are relocs. */
- sofar = BFD_ALIGN (sofar, 1 << COFF_DEFAULT_SECTION_ALIGNMENT_POWER);
+ sofar = BFD_ALIGN (sofar,
+ (bfd_vma) 1 << COFF_DEFAULT_SECTION_ALIGNMENT_POWER);
obj_relocbase (abfd) = sofar;
- abfd->output_has_begun = TRUE;
+ abfd->output_has_begun = true;
- return TRUE;
+ return true;
}
#ifdef COFF_IMAGE_WITH_PE
-static bfd_boolean
+static bool
coff_read_word (bfd *abfd, unsigned int *value, unsigned int *pelength)
{
unsigned char b[2];
if (status < 1)
{
*value = 0;
- return FALSE;
+ return false;
}
if (status == 1)
*pelength += status;
- return TRUE;
+ return true;
}
static unsigned int
coff_compute_checksum (bfd *abfd, unsigned int *pelength)
{
- bfd_boolean more_data;
+ bool more_data;
file_ptr filepos;
unsigned int value;
unsigned int total;
return (0xffff & (total + (total >> 0x10)));
}
-static bfd_boolean
+static bool
coff_apply_checksum (bfd *abfd)
{
unsigned int computed;
unsigned int pelength;
if (bfd_seek (abfd, 0x3c, SEEK_SET) != 0)
- return FALSE;
+ return false;
if (!coff_read_word (abfd, &peheader, &pelength))
- return FALSE;
+ return false;
if (bfd_seek (abfd, peheader + 0x58, SEEK_SET) != 0)
- return FALSE;
+ return false;
checksum = 0;
bfd_bwrite (&checksum, (bfd_size_type) 4, abfd);
if (bfd_seek (abfd, peheader, SEEK_SET) != 0)
- return FALSE;
+ return false;
computed = coff_compute_checksum (abfd, &pelength);
checksum = computed + pelength;
if (bfd_seek (abfd, peheader + 0x58, SEEK_SET) != 0)
- return FALSE;
+ return false;
bfd_bwrite (&checksum, (bfd_size_type) 4, abfd);
- return TRUE;
+ return true;
}
#endif /* COFF_IMAGE_WITH_PE */
-static bfd_boolean
+static bool
coff_write_object_contents (bfd * abfd)
{
asection *current;
- bfd_boolean hasrelocs = FALSE;
- bfd_boolean haslinno = FALSE;
+ bool hasrelocs = false;
+ bool haslinno = false;
#ifdef COFF_IMAGE_WITH_PE
- bfd_boolean hasdebug = FALSE;
+ bool hasdebug = false;
#endif
file_ptr scn_base;
file_ptr reloc_base;
file_ptr sym_base;
unsigned long reloc_size = 0, reloc_count = 0;
unsigned long lnno_size = 0;
- bfd_boolean long_section_names;
+ bool long_section_names;
asection *text_sec = NULL;
asection *data_sec = NULL;
asection *bss_sec = NULL;
if (! abfd->output_has_begun)
{
if (! coff_compute_section_file_positions (abfd))
- return FALSE;
+ return false;
}
reloc_base = obj_relocbase (abfd);
}
if (bfd_seek (abfd, scn_base, SEEK_SET) != 0)
- return FALSE;
+ return false;
- long_section_names = FALSE;
+ long_section_names = false;
for (current = abfd->sections;
current != NULL;
current = current->next)
{
struct internal_scnhdr section;
#ifdef COFF_IMAGE_WITH_PE
- bfd_boolean is_reloc_section = FALSE;
+ bool is_reloc_section = false;
if (strcmp (current->name, DOT_RELOC) == 0)
{
- is_reloc_section = TRUE;
- hasrelocs = TRUE;
+ is_reloc_section = true;
+ hasrelocs = true;
pe_data (abfd)->has_reloc_section = 1;
}
#endif
/* xgettext:c-format */
(_("%pB: section %pA: string table overflow at offset %ld"),
abfd, current, (unsigned long) string_size);
- return FALSE;
+ return false;
}
/* We do not need to use snprintf here as we have already verfied
/* Then strncpy takes care of any padding for us. */
strncpy (section.s_name, s_name_buf, SCNNMLEN);
string_size += len + 1;
- long_section_names = TRUE;
+ long_section_names = true;
}
}
#endif
#ifndef COFF_IMAGE_WITH_PE
/* In PEI, relocs come in the .reloc section. */
if (current->reloc_count != 0)
- hasrelocs = TRUE;
+ hasrelocs = true;
#endif
if (current->lineno_count != 0)
- haslinno = TRUE;
+ haslinno = true;
#ifdef COFF_IMAGE_WITH_PE
if ((current->flags & SEC_DEBUGGING) != 0
&& ! is_reloc_section)
- hasdebug = TRUE;
+ hasdebug = true;
#endif
#ifdef RS6000COFF_C
#ifdef COFF_ENCODE_ALIGNMENT
- COFF_ENCODE_ALIGNMENT(section, current->alignment_power);
- if ((unsigned int)COFF_DECODE_ALIGNMENT(section.s_flags)
- != current->alignment_power)
+ if (COFF_ENCODE_ALIGNMENT (abfd, section, current->alignment_power)
+ && (COFF_DECODE_ALIGNMENT (section.s_flags)
+ != current->alignment_power))
{
- bfd_boolean warn = coff_data (abfd)->link_info
- && !bfd_link_relocatable (coff_data (abfd)->link_info);
+ bool warn = (coff_data (abfd)->link_info
+ && !bfd_link_relocatable (coff_data (abfd)->link_info));
_bfd_error_handler
/* xgettext:c-format */
(_("%pB:%s section %s: alignment 2**%u not representable"),
- abfd, warn ? " warning:" : "", current->name,
- current->alignment_power);
+ abfd, warn ? " warning:" : "", current->name,
+ current->alignment_power);
if (!warn)
{
bfd_set_error (bfd_error_nonrepresentable_section);
- return FALSE;
+ return false;
}
}
#endif
if (bfd_coff_swap_scnhdr_out (abfd, §ion, &buff) == 0
|| bfd_bwrite (& buff, amt, abfd) != amt)
- return FALSE;
+ return false;
}
#ifdef COFF_WITH_PE
amt = bfd_coff_scnhsz (abfd);
if (bfd_coff_swap_scnhdr_out (abfd, &scnhdr, &buff) == 0
|| bfd_bwrite (& buff, amt, abfd) != amt)
- return FALSE;
+ return false;
}
}
#endif
bfd_byte *b = bfd_zmalloc (fill_size);
if (b)
{
- bfd_bwrite ((PTR)b, fill_size, abfd);
+ bfd_bwrite (b, fill_size, abfd);
free (b);
}
}
internal_f.f_flags |= IMAGE_FILE_LARGE_ADDRESS_AWARE;
#endif
-#ifndef COFF_WITH_pex64
+#if !defined(COFF_WITH_pex64) && !defined(COFF_WITH_peAArch64) && !defined(COFF_WITH_peLoongArch64)
#ifdef COFF_WITH_PE
internal_f.f_flags |= IMAGE_FILE_32BIT_MACHINE;
#else
internal_a.magic = ZMAGIC;
#endif
+#if defined(AARCH64)
+#define __A_MAGIC_SET__
+ internal_a.magic = ZMAGIC;
+#endif
+
+#if defined(LOONGARCH64)
+#define __A_MAGIC_SET__
+ internal_a.magic = ZMAGIC;
+#endif
+
#if defined MCORE_PE
#define __A_MAGIC_SET__
internal_a.magic = IMAGE_NT_OPTIONAL_HDR_MAGIC;
#endif
}
+#ifdef RS6000COFF_C
+ /* XCOFF 32bit needs this to have new behaviour for n_type field. */
+ internal_a.vstamp = 2;
+#else
/* FIXME: Does anybody ever set this to another value? */
internal_a.vstamp = 0;
+#endif
/* Now should write relocs, strings, syms. */
obj_sym_filepos (abfd) = sym_base;
int firstundef;
if (!coff_renumber_symbols (abfd, &firstundef))
- return FALSE;
+ return false;
coff_mangle_symbols (abfd);
if (! coff_write_symbols (abfd))
- return FALSE;
+ return false;
if (! coff_write_linenumbers (abfd))
- return FALSE;
+ return false;
if (! coff_write_relocs (abfd, firstundef))
- return FALSE;
+ return false;
}
#ifdef COFF_LONG_SECTION_NAMES
else if (long_section_names && ! obj_coff_strings_written (abfd))
/* If we have long section names we have to write out the string
table even if there are no symbols. */
if (! coff_write_symbols (abfd))
- return FALSE;
+ return false;
}
#endif
/* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
bfd_vma toc;
asection *loader_sec;
- internal_a.vstamp = 1;
+ internal_a.vstamp = 2;
internal_a.o_snentry = xcoff_data (abfd)->snentry;
if (internal_a.o_snentry == 0)
/* Now write header. */
if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
- return FALSE;
+ return false;
{
char * buff;
buff = (char *) bfd_malloc (amount);
if (buff == NULL)
- return FALSE;
+ return false;
bfd_coff_swap_filehdr_out (abfd, & internal_f, buff);
amount = bfd_bwrite (buff, amount, abfd);
free (buff);
if (amount != bfd_coff_filhsz (abfd))
- return FALSE;
+ return false;
}
if (abfd->flags & EXEC_P)
buff = (char *) bfd_malloc (amount);
if (buff == NULL)
- return FALSE;
+ return false;
coff_swap_aouthdr_out (abfd, & internal_a, buff);
amount = bfd_bwrite (buff, amount, abfd);
free (buff);
if (amount != bfd_coff_aoutsz (abfd))
- return FALSE;
+ return false;
#ifdef COFF_IMAGE_WITH_PE
if (! coff_apply_checksum (abfd))
- return FALSE;
+ return false;
#endif
}
#ifdef RS6000COFF_C
else
size = SMALL_AOUTSZ;
if (bfd_bwrite (& buff, (bfd_size_type) size, abfd) != size)
- return FALSE;
+ return false;
}
#endif
#endif
- return TRUE;
+ return true;
}
-static bfd_boolean
+static bool
coff_set_section_contents (bfd * abfd,
sec_ptr section,
const void * location,
if (! abfd->output_has_begun) /* Set by bfd.c handler. */
{
if (! coff_compute_section_file_positions (abfd))
- return FALSE;
+ return false;
}
#if defined(_LIB) && !defined(TARG_AUX)
rec = (bfd_byte *) location;
recend = rec + count;
- while (rec < recend)
+ while (recend - rec >= 4)
{
+ size_t len = bfd_get_32 (abfd, rec);
+ if (len == 0 || len > (size_t) (recend - rec) / 4)
+ break;
+ rec += len * 4;
++section->lma;
- rec += bfd_get_32 (abfd, rec) * 4;
}
BFD_ASSERT (rec == recend);
/* Don't write out bss sections - one way to do this is to
see if the filepos has not been set. */
if (section->filepos == 0)
- return TRUE;
+ return true;
if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0)
- return FALSE;
+ return false;
if (count == 0)
- return TRUE;
+ return true;
return bfd_bwrite (location, count, abfd) == count;
}
}
if (bfd_seek (abfd, where, SEEK_SET) != 0)
return NULL;
- return _bfd_alloc_and_read (abfd, amt, amt);
+ return _bfd_malloc_and_read (abfd, amt, amt);
}
/*
return 0;
}
-static bfd_boolean
+static bool
coff_slurp_line_table (bfd *abfd, asection *asect)
{
LINENO *native_lineno;
unsigned int counter;
alent *cache_ptr;
bfd_vma prev_offset = 0;
- bfd_boolean ordered = TRUE;
+ bool ordered = true;
unsigned int nbr_func;
LINENO *src;
- bfd_boolean have_func;
- bfd_boolean ret = TRUE;
+ bool have_func;
+ bool ret = true;
size_t amt;
if (asect->lineno_count == 0)
- return TRUE;
+ return true;
BFD_ASSERT (asect->lineno == NULL);
- if (asect->lineno_count > asect->size)
+ native_lineno = (LINENO *) buy_and_read (abfd, asect->line_filepos,
+ asect->lineno_count,
+ bfd_coff_linesz (abfd));
+ if (native_lineno == NULL)
{
_bfd_error_handler
- (_("%pB: warning: line number count (%#lx) exceeds section size (%#lx)"),
- abfd, (unsigned long) asect->lineno_count, (unsigned long) asect->size);
- return FALSE;
+ (_("%pB: warning: line number table read failed"), abfd);
+ return false;
}
if (_bfd_mul_overflow (asect->lineno_count + 1, sizeof (alent), &amt))
{
bfd_set_error (bfd_error_file_too_big);
- return FALSE;
+ free (native_lineno);
+ return false;
}
lineno_cache = (alent *) bfd_alloc (abfd, amt);
if (lineno_cache == NULL)
- return FALSE;
-
- native_lineno = (LINENO *) buy_and_read (abfd, asect->line_filepos,
- asect->lineno_count,
- bfd_coff_linesz (abfd));
- if (native_lineno == NULL)
{
- _bfd_error_handler
- (_("%pB: warning: line number table read failed"), abfd);
- bfd_release (abfd, lineno_cache);
- return FALSE;
+ free (native_lineno);
+ return false;
}
cache_ptr = lineno_cache;
asect->lineno = lineno_cache;
src = native_lineno;
nbr_func = 0;
- have_func = FALSE;
+ have_func = false;
for (counter = 0; counter < asect->lineno_count; counter++, src++)
{
unsigned long symndx;
coff_symbol_type *sym;
- have_func = FALSE;
+ have_func = false;
symndx = dst.l_addr.l_symndx;
if (symndx >= obj_raw_syment_count (abfd))
{
(_("%pB: warning: illegal symbol index 0x%lx in line number entry %d"),
abfd, symndx, counter);
cache_ptr->line_number = -1;
- ret = FALSE;
+ ret = false;
continue;
}
(_("%pB: warning: illegal symbol index 0x%lx in line number entry %d"),
abfd, symndx, counter);
cache_ptr->line_number = -1;
- ret = FALSE;
+ ret = false;
continue;
}
sym = (coff_symbol_type *) (ent->u.syment._n._n_n._n_zeroes);
(_("%pB: warning: illegal symbol in line number entry %d"),
abfd, counter);
cache_ptr->line_number = -1;
- ret = FALSE;
+ ret = false;
continue;
}
- have_func = TRUE;
+ have_func = true;
nbr_func++;
cache_ptr->u.sym = (asymbol *) sym;
if (sym->lineno != NULL)
sym->lineno = cache_ptr;
if (sym->symbol.value < prev_offset)
- ordered = FALSE;
+ ordered = false;
prev_offset = sym->symbol.value;
}
else if (!have_func)
asect->lineno_count = cache_ptr - lineno_cache;
memset (cache_ptr, 0, sizeof (*cache_ptr));
- bfd_release (abfd, native_lineno);
+ free (native_lineno);
/* On some systems (eg AIX5.3) the lineno table may not be sorted. */
if (!ordered)
if (_bfd_mul_overflow (nbr_func, sizeof (alent *), &amt))
{
bfd_set_error (bfd_error_file_too_big);
- ret = FALSE;
+ ret = false;
}
else if ((func_table = (alent **) bfd_alloc (abfd, amt)) != NULL)
{
if (_bfd_mul_overflow (asect->lineno_count, sizeof (alent), &amt))
{
bfd_set_error (bfd_error_file_too_big);
- ret = FALSE;
+ ret = false;
}
else if ((n_lineno_cache = (alent *) bfd_alloc (abfd, amt)) != NULL)
{
asect->lineno_count * sizeof (alent));
}
else
- ret = FALSE;
+ ret = false;
bfd_release (abfd, func_table);
}
else
- ret = FALSE;
+ ret = false;
}
return ret;
that if coff_relocate_section is defined, the linker will read
symbols via coff_link_add_symbols, rather than via this routine. */
-static bfd_boolean
+static bool
coff_slurp_symbol_table (bfd * abfd)
{
combined_entry_type *native_symbols;
coff_symbol_type *cached_area;
unsigned int *table_ptr;
unsigned int number_of_symbols = 0;
- bfd_boolean ret = TRUE;
+ bool ret = true;
size_t amt;
if (obj_symbols (abfd))
- return TRUE;
+ return true;
/* Read in the symbol table. */
if ((native_symbols = coff_get_normalized_symtab (abfd)) == NULL)
- return FALSE;
+ return false;
/* Allocate enough room for all the symbols in cached form. */
if (_bfd_mul_overflow (obj_raw_syment_count (abfd),
sizeof (*cached_area), &amt))
{
bfd_set_error (bfd_error_file_too_big);
- return FALSE;
+ return false;
}
cached_area = (coff_symbol_type *) bfd_alloc (abfd, amt);
if (cached_area == NULL)
- return FALSE;
+ return false;
if (_bfd_mul_overflow (obj_raw_syment_count (abfd),
sizeof (*table_ptr), &amt))
{
bfd_set_error (bfd_error_file_too_big);
- return FALSE;
+ return false;
}
table_ptr = (unsigned int *) bfd_zalloc (abfd, amt);
if (table_ptr == NULL)
- return FALSE;
+ return false;
else
{
coff_symbol_type *dst = cached_area;
BFD_ASSERT (src->is_sym);
dst->symbol.name = (char *) (src->u.syment._n._n_n._n_offset);
/* We use the native name field to point to the cached field. */
- src->u.syment._n._n_n._n_zeroes = (bfd_hostptr_t) dst;
+ src->u.syment._n._n_n._n_zeroes = (uintptr_t) dst;
dst->symbol.section = coff_section_from_bfd_index (abfd,
src->u.syment.n_scnum);
dst->symbol.flags = 0;
/* PR 17512: file: 079-7098-0.001:0.1. */
dst->symbol.value = 0;
- dst->done_lineno = FALSE;
+ dst->done_lineno = false;
switch (src->u.syment.n_sclass)
{
dst->symbol.value = src->u.syment.n_value;
break;
+ case C_FILE: /* File name. */
+ dst->symbol.flags = BSF_FILE;
+ /* Fall through. */
case C_MOS: /* Member of structure. */
case C_EOS: /* End of structure. */
case C_REGPARM: /* Register parameter. */
case C_MOE: /* Member of enumeration. */
case C_MOU: /* Member of union. */
case C_UNTAG: /* Union tag. */
- dst->symbol.flags = BSF_DEBUGGING;
- dst->symbol.value = (src->u.syment.n_value);
- break;
-
- case C_FILE: /* File name. */
case C_STRTAG: /* Structure tag. */
#ifdef RS6000COFF_C
case C_GSYM:
case C_FUN:
case C_ESTAT:
#endif
- dst->symbol.flags = BSF_DEBUGGING;
+ dst->symbol.flags |= BSF_DEBUGGING;
dst->symbol.value = (src->u.syment.n_value);
break;
case C_BSTAT:
dst->symbol.flags = BSF_DEBUGGING;
- /* The value is actually a symbol index. Save a pointer
- to the symbol instead of the index. FIXME: This
- should use a union. */
- src->u.syment.n_value =
- (long) (intptr_t) (native_symbols + src->u.syment.n_value);
- dst->symbol.value = src->u.syment.n_value;
- src->fix_value = 1;
+ if (src->u.syment.n_value >= obj_raw_syment_count (abfd))
+ dst->symbol.value = 0;
+ else
+ {
+ /* The value is actually a symbol index. Save a pointer
+ to the symbol instead of the index. FIXME: This
+ should use a union. */
+ src->u.syment.n_value
+ = (uintptr_t) (native_symbols + src->u.syment.n_value);
+ dst->symbol.value = src->u.syment.n_value;
+ src->fix_value = 1;
+ }
break;
#endif
(_("%pB: unrecognized storage class %d for %s symbol `%s'"),
abfd, src->u.syment.n_sclass,
dst->symbol.section->name, dst->symbol.name);
- ret = FALSE;
+ ret = false;
/* Fall through. */
case C_HIDDEN: /* Ext symbol in dmert public lib. */
/* PR 20722: These symbols can also be generated by
while (p)
{
if (! coff_slurp_line_table (abfd, p))
- return FALSE;
+ return false;
p = p->next;
}
}
breaks gas generated objects. */
if (syment->n_value == 0)
{
- asection *sec;
- char * name;
+ const asection *sec;
+ const char *name;
char buf[SYMNMLEN + 1];
- name = _bfd_coff_internal_syment_name (abfd, syment, buf)
+ name = _bfd_coff_internal_syment_name (abfd, syment, buf);
sec = coff_section_from_bfd_index (abfd, syment->n_scnum);
if (sec != NULL && name != NULL
&& (strcmp (bfd_section_name (sec), name) == 0))
structure, in a back end specific way. For instance, the 386
uses the @code{r_type} to directly produce an index
into a howto table vector.
+
+ o Note that @code{arelent.addend} for COFF is often not what
+ most people understand as a relocation addend, but rather an
+ adjustment to the relocation addend stored in section contents
+ of relocatable object files. The value found in section
+ contents may also be confusing, depending on both symbol value
+ and addend somewhat similar to the field value for a
+ final-linked object. See @code{CALC_ADDEND}.
*/
#ifndef CALC_ADDEND
}
#endif
-static bfd_boolean
+static bool
coff_slurp_reloc_table (bfd * abfd, sec_ptr asect, asymbol ** symbols)
{
- RELOC *native_relocs;
+ bfd_byte *native_relocs;
arelent *reloc_cache;
arelent *cache_ptr;
unsigned int idx;
size_t amt;
if (asect->relocation)
- return TRUE;
+ return true;
if (asect->reloc_count == 0)
- return TRUE;
+ return true;
if (asect->flags & SEC_CONSTRUCTOR)
- return TRUE;
+ return true;
if (!coff_slurp_symbol_table (abfd))
- return FALSE;
+ return false;
+
+ native_relocs = (bfd_byte *) buy_and_read (abfd, asect->rel_filepos,
+ asect->reloc_count,
+ bfd_coff_relsz (abfd));
+ if (native_relocs == NULL)
+ return false;
- native_relocs = (RELOC *) buy_and_read (abfd, asect->rel_filepos,
- asect->reloc_count,
- bfd_coff_relsz (abfd));
if (_bfd_mul_overflow (asect->reloc_count, sizeof (arelent), &amt))
{
bfd_set_error (bfd_error_file_too_big);
- return FALSE;
+ return false;
}
reloc_cache = (arelent *) bfd_alloc (abfd, amt);
- if (reloc_cache == NULL || native_relocs == NULL)
- return FALSE;
+ if (reloc_cache == NULL)
+ {
+ free (native_relocs);
+ return false;
+ }
for (idx = 0; idx < asect->reloc_count; idx++)
{
struct internal_reloc dst;
- struct external_reloc *src;
+ void *src;
#ifndef RELOC_PROCESSING
asymbol *ptr;
#endif
cache_ptr = reloc_cache + idx;
- src = native_relocs + idx;
+ src = native_relocs + idx * (size_t) bfd_coff_relsz (abfd);
dst.r_offset = 0;
- coff_swap_reloc_in (abfd, src, &dst);
+ bfd_coff_swap_reloc_in (abfd, src, &dst);
#ifdef RELOC_PROCESSING
RELOC_PROCESSING (cache_ptr, &dst, symbols, abfd, asect);
(_("%pB: illegal relocation type %d at address %#" PRIx64),
abfd, dst.r_type, (uint64_t) dst.r_vaddr);
bfd_set_error (bfd_error_bad_value);
- return FALSE;
+ free (native_relocs);
+ return false;
}
}
+ free (native_relocs);
asect->relocation = reloc_cache;
- return TRUE;
+ return true;
}
#ifndef coff_rtype_to_howto
#define coff_reloc16_extra_cases dummy_reloc16_extra_cases
-/* This works even if abort is not declared in any header file. */
-
-static void
+static bool
dummy_reloc16_extra_cases (bfd *abfd ATTRIBUTE_UNUSED,
struct bfd_link_info *link_info ATTRIBUTE_UNUSED,
struct bfd_link_order *link_order ATTRIBUTE_UNUSED,
arelent *reloc ATTRIBUTE_UNUSED,
bfd_byte *data ATTRIBUTE_UNUSED,
- unsigned int *src_ptr ATTRIBUTE_UNUSED,
- unsigned int *dst_ptr ATTRIBUTE_UNUSED)
+ size_t *src_ptr ATTRIBUTE_UNUSED,
+ size_t *dst_ptr ATTRIBUTE_UNUSED)
{
- abort ();
+ return false;
}
#endif
#ifndef coff_link_output_has_begun
-static bfd_boolean
+static bool
coff_link_output_has_begun (bfd * abfd,
struct coff_final_link_info * info ATTRIBUTE_UNUSED)
{
#ifndef coff_final_link_postscript
-static bfd_boolean
+static bool
coff_final_link_postscript (bfd * abfd ATTRIBUTE_UNUSED,
struct coff_final_link_info * pfinfo ATTRIBUTE_UNUSED)
{
- return TRUE;
+ return true;
}
#endif
#define coff_SWAP_scnhdr_in coff_swap_scnhdr_in
#endif
-static bfd_coff_backend_data bfd_coff_std_swap_table ATTRIBUTE_UNUSED =
+static const bfd_coff_backend_data bfd_coff_std_swap_table ATTRIBUTE_UNUSED =
{
coff_SWAP_aux_in, coff_SWAP_sym_in, coff_SWAP_lineno_in,
coff_SWAP_aux_out, coff_SWAP_sym_out,
coff_SWAP_scnhdr_out,
FILHSZ, AOUTSZ, SCNHSZ, SYMESZ, AUXESZ, RELSZ, LINESZ, FILNMLEN,
#ifdef COFF_LONG_FILENAMES
- TRUE,
+ true,
#else
- FALSE,
+ false,
#endif
COFF_DEFAULT_LONG_SECTION_NAMES,
COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
#ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
- TRUE,
+ true,
#else
- FALSE,
+ false,
#endif
#ifdef COFF_DEBUG_STRING_WIDE_PREFIX
4,
#ifdef TICOFF
/* COFF0 differs in file/section header size and relocation entry size. */
-static bfd_coff_backend_data ticoff0_swap_table =
+static const bfd_coff_backend_data ticoff0_swap_table =
{
coff_SWAP_aux_in, coff_SWAP_sym_in, coff_SWAP_lineno_in,
coff_SWAP_aux_out, coff_SWAP_sym_out,
- coff_SWAP_lineno_out, coff_SWAP_reloc_out,
+ coff_SWAP_lineno_out, coff_swap_reloc_v0_out,
coff_SWAP_filehdr_out, coff_SWAP_aouthdr_out,
coff_SWAP_scnhdr_out,
FILHSZ_V0, AOUTSZ, SCNHSZ_V01, SYMESZ, AUXESZ, RELSZ_V0, LINESZ, FILNMLEN,
#ifdef COFF_LONG_FILENAMES
- TRUE,
+ true,
#else
- FALSE,
+ false,
#endif
COFF_DEFAULT_LONG_SECTION_NAMES,
COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
#ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
- TRUE,
+ true,
#else
- FALSE,
+ false,
#endif
#ifdef COFF_DEBUG_STRING_WIDE_PREFIX
4,
#endif
32768,
coff_SWAP_filehdr_in, coff_SWAP_aouthdr_in, coff_SWAP_scnhdr_in,
- coff_SWAP_reloc_in, ticoff0_bad_format_hook, coff_set_arch_mach_hook,
+ coff_swap_reloc_v0_in, ticoff0_bad_format_hook, coff_set_arch_mach_hook,
coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook,
coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook,
coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate,
#ifdef TICOFF
/* COFF1 differs in section header size. */
-static bfd_coff_backend_data ticoff1_swap_table =
+static const bfd_coff_backend_data ticoff1_swap_table =
{
coff_SWAP_aux_in, coff_SWAP_sym_in, coff_SWAP_lineno_in,
coff_SWAP_aux_out, coff_SWAP_sym_out,
coff_SWAP_scnhdr_out,
FILHSZ, AOUTSZ, SCNHSZ_V01, SYMESZ, AUXESZ, RELSZ, LINESZ, FILNMLEN,
#ifdef COFF_LONG_FILENAMES
- TRUE,
+ true,
#else
- FALSE,
+ false,
#endif
COFF_DEFAULT_LONG_SECTION_NAMES,
COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
#ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
- TRUE,
+ true,
#else
- FALSE,
+ false,
#endif
#ifdef COFF_DEBUG_STRING_WIDE_PREFIX
4,
if (numaux > 1)
{
if (indx == 0)
- memcpy (in->x_file.x_fname, ext->File.Name,
+ memcpy (in->x_file.x_n.x_fname, ext->File.Name,
numaux * sizeof (AUXENT_BIGOBJ));
}
else
- memcpy (in->x_file.x_fname, ext->File.Name, sizeof (ext->File.Name));
+ memcpy (in->x_file.x_n.x_fname, ext->File.Name, sizeof (ext->File.Name));
break;
case C_STAT:
break;
default:
- in->x_sym.x_tagndx.l = H_GET_32 (abfd, ext->Sym.WeakDefaultSymIndex);
+ in->x_sym.x_tagndx.u32 = H_GET_32 (abfd, ext->Sym.WeakDefaultSymIndex);
/* Characteristics is ignored. */
break;
}
switch (in_class)
{
case C_FILE:
- memcpy (ext->File.Name, in->x_file.x_fname, sizeof (ext->File.Name));
+ memcpy (ext->File.Name, in->x_file.x_n.x_fname, sizeof (ext->File.Name));
return AUXESZ;
break;
}
- H_PUT_32 (abfd, in->x_sym.x_tagndx.l, ext->Sym.WeakDefaultSymIndex);
+ H_PUT_32 (abfd, in->x_sym.x_tagndx.u32, ext->Sym.WeakDefaultSymIndex);
H_PUT_32 (abfd, 1, ext->Sym.WeakSearchType);
return AUXESZ;
}
-static bfd_coff_backend_data bigobj_swap_table =
+static const bfd_coff_backend_data bigobj_swap_table =
{
coff_bigobj_swap_aux_in, coff_bigobj_swap_sym_in, coff_SWAP_lineno_in,
coff_bigobj_swap_aux_out, coff_bigobj_swap_sym_out,
coff_SWAP_scnhdr_out,
FILHSZ_BIGOBJ, AOUTSZ, SCNHSZ, SYMESZ_BIGOBJ, AUXESZ_BIGOBJ,
RELSZ, LINESZ, FILNMLEN_BIGOBJ,
- TRUE,
+ true,
COFF_DEFAULT_LONG_SECTION_NAMES,
COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
- FALSE,
+ false,
2,
1U << 31,
coff_bigobj_swap_filehdr_in, coff_SWAP_aouthdr_in, coff_SWAP_scnhdr_in,
projects / binutils-gdb.git / blobdiff