/* BFD semi-generic back-end for a.out binaries.
Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 2000,
- 2001
+ 2001, 2002, 2003, 2004
Free Software Foundation, Inc.
Written by Cygnus Support.
-This file is part of BFD, the Binary File Descriptor library.
+ This file is part of BFD, the Binary File Descriptor library.
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
-You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/*
SECTION
in the @file{config/@var{XXX}.mt} file, and modify @file{configure.in}
to use the
@file{@var{XXX}.mt} file (by setting "<<bfd_target=XXX>>") when your
- configuration is selected.
-
-*/
+ configuration is selected. */
/* Some assumptions:
* Any BFD with D_PAGED set is ZMAGIC, and vice versa.
#include "aout/stab_gnu.h"
#include "aout/ar.h"
-static boolean aout_get_external_symbols PARAMS ((bfd *));
-static boolean translate_from_native_sym_flags
+static bfd_boolean aout_get_external_symbols
+ PARAMS ((bfd *));
+static bfd_boolean translate_from_native_sym_flags
PARAMS ((bfd *, aout_symbol_type *));
-static boolean translate_to_native_sym_flags
+static bfd_boolean translate_to_native_sym_flags
PARAMS ((bfd *, asymbol *, struct external_nlist *));
-static void adjust_o_magic PARAMS ((bfd *, struct internal_exec *));
-static void adjust_z_magic PARAMS ((bfd *, struct internal_exec *));
-static void adjust_n_magic PARAMS ((bfd *, struct internal_exec *));
+static void adjust_o_magic
+ PARAMS ((bfd *, struct internal_exec *));
+static void adjust_z_magic
+ PARAMS ((bfd *, struct internal_exec *));
+static void adjust_n_magic
+ PARAMS ((bfd *, struct internal_exec *));
reloc_howto_type * NAME(aout,reloc_type_lookup)
PARAMS ((bfd *, bfd_reloc_code_real_type));
The standard records contain only an
address, a symbol index, and a type field. The extended records
(used on 29ks and sparcs) also have a full integer for an
- addend.
+ addend. */
-*/
#ifndef CTOR_TABLE_RELOC_HOWTO
#define CTOR_TABLE_RELOC_IDX 2
#define CTOR_TABLE_RELOC_HOWTO(BFD) \
reloc_howto_type howto_table_ext[] =
{
- /* type rs size bsz pcrel bitpos ovrf sf name part_inpl readmask setmask pcdone */
- HOWTO(RELOC_8, 0, 0, 8, false, 0, complain_overflow_bitfield,0,"8", false, 0,0x000000ff, false),
- HOWTO(RELOC_16, 0, 1, 16, false, 0, complain_overflow_bitfield,0,"16", false, 0,0x0000ffff, false),
- HOWTO(RELOC_32, 0, 2, 32, false, 0, complain_overflow_bitfield,0,"32", false, 0,0xffffffff, false),
- HOWTO(RELOC_DISP8, 0, 0, 8, true, 0, complain_overflow_signed,0,"DISP8", false, 0,0x000000ff, false),
- HOWTO(RELOC_DISP16, 0, 1, 16, true, 0, complain_overflow_signed,0,"DISP16", false, 0,0x0000ffff, false),
- HOWTO(RELOC_DISP32, 0, 2, 32, true, 0, complain_overflow_signed,0,"DISP32", false, 0,0xffffffff, false),
- HOWTO(RELOC_WDISP30,2, 2, 30, true, 0, complain_overflow_signed,0,"WDISP30", false, 0,0x3fffffff, false),
- HOWTO(RELOC_WDISP22,2, 2, 22, true, 0, complain_overflow_signed,0,"WDISP22", false, 0,0x003fffff, false),
- HOWTO(RELOC_HI22, 10, 2, 22, false, 0, complain_overflow_bitfield,0,"HI22", false, 0,0x003fffff, false),
- HOWTO(RELOC_22, 0, 2, 22, false, 0, complain_overflow_bitfield,0,"22", false, 0,0x003fffff, false),
- HOWTO(RELOC_13, 0, 2, 13, false, 0, complain_overflow_bitfield,0,"13", false, 0,0x00001fff, false),
- HOWTO(RELOC_LO10, 0, 2, 10, false, 0, complain_overflow_dont,0,"LO10", false, 0,0x000003ff, false),
- HOWTO(RELOC_SFA_BASE,0, 2, 32, false, 0, complain_overflow_bitfield,0,"SFA_BASE", false, 0,0xffffffff, false),
- HOWTO(RELOC_SFA_OFF13,0,2, 32, false, 0, complain_overflow_bitfield,0,"SFA_OFF13",false, 0,0xffffffff, false),
- HOWTO(RELOC_BASE10, 0, 2, 10, false, 0, complain_overflow_dont,0,"BASE10", false, 0,0x000003ff, false),
- HOWTO(RELOC_BASE13, 0, 2, 13, false, 0, complain_overflow_signed,0,"BASE13", false, 0,0x00001fff, false),
- HOWTO(RELOC_BASE22, 10, 2, 22, false, 0, complain_overflow_bitfield,0,"BASE22", false, 0,0x003fffff, false),
- HOWTO(RELOC_PC10, 0, 2, 10, true, 0, complain_overflow_dont,0,"PC10", false, 0,0x000003ff, true),
- HOWTO(RELOC_PC22, 10, 2, 22, true, 0, complain_overflow_signed,0,"PC22", false, 0,0x003fffff, true),
- HOWTO(RELOC_JMP_TBL,2, 2, 30, true, 0, complain_overflow_signed,0,"JMP_TBL", false, 0,0x3fffffff, false),
- HOWTO(RELOC_SEGOFF16,0, 2, 0, false, 0, complain_overflow_bitfield,0,"SEGOFF16", false, 0,0x00000000, false),
- HOWTO(RELOC_GLOB_DAT,0, 2, 0, false, 0, complain_overflow_bitfield,0,"GLOB_DAT", false, 0,0x00000000, false),
- HOWTO(RELOC_JMP_SLOT,0, 2, 0, false, 0, complain_overflow_bitfield,0,"JMP_SLOT", false, 0,0x00000000, false),
- HOWTO(RELOC_RELATIVE,0, 2, 0, false, 0, complain_overflow_bitfield,0,"RELATIVE", false, 0,0x00000000, false),
- HOWTO(0, 0, 0, 0, false, 0, complain_overflow_dont, 0, "R_SPARC_NONE", false,0,0x00000000,true),
- HOWTO(0, 0, 0, 0, false, 0, complain_overflow_dont, 0, "R_SPARC_NONE", false,0,0x00000000,true),
+ /* type rs size bsz pcrel bitpos ovrf sf name part_inpl readmask setmask pcdone. */
+ HOWTO(RELOC_8, 0, 0, 8, FALSE, 0, complain_overflow_bitfield,0,"8", FALSE, 0,0x000000ff, FALSE),
+ HOWTO(RELOC_16, 0, 1, 16, FALSE, 0, complain_overflow_bitfield,0,"16", FALSE, 0,0x0000ffff, FALSE),
+ HOWTO(RELOC_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,0,"32", FALSE, 0,0xffffffff, FALSE),
+ HOWTO(RELOC_DISP8, 0, 0, 8, TRUE, 0, complain_overflow_signed,0,"DISP8", FALSE, 0,0x000000ff, FALSE),
+ HOWTO(RELOC_DISP16, 0, 1, 16, TRUE, 0, complain_overflow_signed,0,"DISP16", FALSE, 0,0x0000ffff, FALSE),
+ HOWTO(RELOC_DISP32, 0, 2, 32, TRUE, 0, complain_overflow_signed,0,"DISP32", FALSE, 0,0xffffffff, FALSE),
+ HOWTO(RELOC_WDISP30,2, 2, 30, TRUE, 0, complain_overflow_signed,0,"WDISP30", FALSE, 0,0x3fffffff, FALSE),
+ HOWTO(RELOC_WDISP22,2, 2, 22, TRUE, 0, complain_overflow_signed,0,"WDISP22", FALSE, 0,0x003fffff, FALSE),
+ HOWTO(RELOC_HI22, 10, 2, 22, FALSE, 0, complain_overflow_bitfield,0,"HI22", FALSE, 0,0x003fffff, FALSE),
+ HOWTO(RELOC_22, 0, 2, 22, FALSE, 0, complain_overflow_bitfield,0,"22", FALSE, 0,0x003fffff, FALSE),
+ HOWTO(RELOC_13, 0, 2, 13, FALSE, 0, complain_overflow_bitfield,0,"13", FALSE, 0,0x00001fff, FALSE),
+ HOWTO(RELOC_LO10, 0, 2, 10, FALSE, 0, complain_overflow_dont,0,"LO10", FALSE, 0,0x000003ff, FALSE),
+ HOWTO(RELOC_SFA_BASE,0, 2, 32, FALSE, 0, complain_overflow_bitfield,0,"SFA_BASE", FALSE, 0,0xffffffff, FALSE),
+ HOWTO(RELOC_SFA_OFF13,0,2, 32, FALSE, 0, complain_overflow_bitfield,0,"SFA_OFF13",FALSE, 0,0xffffffff, FALSE),
+ HOWTO(RELOC_BASE10, 0, 2, 10, FALSE, 0, complain_overflow_dont,0,"BASE10", FALSE, 0,0x000003ff, FALSE),
+ HOWTO(RELOC_BASE13, 0, 2, 13, FALSE, 0, complain_overflow_signed,0,"BASE13", FALSE, 0,0x00001fff, FALSE),
+ HOWTO(RELOC_BASE22, 10, 2, 22, FALSE, 0, complain_overflow_bitfield,0,"BASE22", FALSE, 0,0x003fffff, FALSE),
+ HOWTO(RELOC_PC10, 0, 2, 10, TRUE, 0, complain_overflow_dont,0,"PC10", FALSE, 0,0x000003ff, TRUE),
+ HOWTO(RELOC_PC22, 10, 2, 22, TRUE, 0, complain_overflow_signed,0,"PC22", FALSE, 0,0x003fffff, TRUE),
+ HOWTO(RELOC_JMP_TBL,2, 2, 30, TRUE, 0, complain_overflow_signed,0,"JMP_TBL", FALSE, 0,0x3fffffff, FALSE),
+ HOWTO(RELOC_SEGOFF16,0, 2, 0, FALSE, 0, complain_overflow_bitfield,0,"SEGOFF16", FALSE, 0,0x00000000, FALSE),
+ HOWTO(RELOC_GLOB_DAT,0, 2, 0, FALSE, 0, complain_overflow_bitfield,0,"GLOB_DAT", FALSE, 0,0x00000000, FALSE),
+ HOWTO(RELOC_JMP_SLOT,0, 2, 0, FALSE, 0, complain_overflow_bitfield,0,"JMP_SLOT", FALSE, 0,0x00000000, FALSE),
+ HOWTO(RELOC_RELATIVE,0, 2, 0, FALSE, 0, complain_overflow_bitfield,0,"RELATIVE", FALSE, 0,0x00000000, FALSE),
+ HOWTO(0, 0, 0, 0, FALSE, 0, complain_overflow_dont, 0, "R_SPARC_NONE", FALSE,0,0x00000000,TRUE),
+ HOWTO(0, 0, 0, 0, FALSE, 0, complain_overflow_dont, 0, "R_SPARC_NONE", FALSE,0,0x00000000,TRUE),
#define RELOC_SPARC_REV32 RELOC_WDISP19
- HOWTO(RELOC_SPARC_REV32, 0, 2, 32, false, 0, complain_overflow_dont,0,"R_SPARC_REV32", false, 0,0xffffffff, false),
+ HOWTO(RELOC_SPARC_REV32, 0, 2, 32, FALSE, 0, complain_overflow_dont,0,"R_SPARC_REV32", FALSE, 0,0xffffffff, FALSE),
};
/* Convert standard reloc records to "arelent" format (incl byte swap). */
-reloc_howto_type howto_table_std[] = {
- /* type rs size bsz pcrel bitpos ovrf sf name part_inpl readmask setmask pcdone */
-HOWTO ( 0, 0, 0, 8, false, 0, complain_overflow_bitfield,0,"8", true, 0x000000ff,0x000000ff, false),
-HOWTO ( 1, 0, 1, 16, false, 0, complain_overflow_bitfield,0,"16", true, 0x0000ffff,0x0000ffff, false),
-HOWTO ( 2, 0, 2, 32, false, 0, complain_overflow_bitfield,0,"32", true, 0xffffffff,0xffffffff, false),
-HOWTO ( 3, 0, 4, 64, false, 0, complain_overflow_bitfield,0,"64", true, 0xdeaddead,0xdeaddead, false),
-HOWTO ( 4, 0, 0, 8, true, 0, complain_overflow_signed, 0,"DISP8", true, 0x000000ff,0x000000ff, false),
-HOWTO ( 5, 0, 1, 16, true, 0, complain_overflow_signed, 0,"DISP16", true, 0x0000ffff,0x0000ffff, false),
-HOWTO ( 6, 0, 2, 32, true, 0, complain_overflow_signed, 0,"DISP32", true, 0xffffffff,0xffffffff, false),
-HOWTO ( 7, 0, 4, 64, true, 0, complain_overflow_signed, 0,"DISP64", true, 0xfeedface,0xfeedface, false),
-HOWTO ( 8, 0, 2, 0, false, 0, complain_overflow_bitfield,0,"GOT_REL", false, 0,0x00000000, false),
-HOWTO ( 9, 0, 1, 16, false, 0, complain_overflow_bitfield,0,"BASE16", false,0xffffffff,0xffffffff, false),
-HOWTO (10, 0, 2, 32, false, 0, complain_overflow_bitfield,0,"BASE32", false,0xffffffff,0xffffffff, false),
+reloc_howto_type howto_table_std[] =
+{
+ /* type rs size bsz pcrel bitpos ovrf sf name part_inpl readmask setmask pcdone. */
+HOWTO ( 0, 0, 0, 8, FALSE, 0, complain_overflow_bitfield,0,"8", TRUE, 0x000000ff,0x000000ff, FALSE),
+HOWTO ( 1, 0, 1, 16, FALSE, 0, complain_overflow_bitfield,0,"16", TRUE, 0x0000ffff,0x0000ffff, FALSE),
+HOWTO ( 2, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,0,"32", TRUE, 0xffffffff,0xffffffff, FALSE),
+HOWTO ( 3, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,0,"64", TRUE, 0xdeaddead,0xdeaddead, FALSE),
+HOWTO ( 4, 0, 0, 8, TRUE, 0, complain_overflow_signed, 0,"DISP8", TRUE, 0x000000ff,0x000000ff, FALSE),
+HOWTO ( 5, 0, 1, 16, TRUE, 0, complain_overflow_signed, 0,"DISP16", TRUE, 0x0000ffff,0x0000ffff, FALSE),
+HOWTO ( 6, 0, 2, 32, TRUE, 0, complain_overflow_signed, 0,"DISP32", TRUE, 0xffffffff,0xffffffff, FALSE),
+HOWTO ( 7, 0, 4, 64, TRUE, 0, complain_overflow_signed, 0,"DISP64", TRUE, 0xfeedface,0xfeedface, FALSE),
+HOWTO ( 8, 0, 2, 0, FALSE, 0, complain_overflow_bitfield,0,"GOT_REL", FALSE, 0,0x00000000, FALSE),
+HOWTO ( 9, 0, 1, 16, FALSE, 0, complain_overflow_bitfield,0,"BASE16", FALSE,0xffffffff,0xffffffff, FALSE),
+HOWTO (10, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,0,"BASE32", FALSE,0xffffffff,0xffffffff, FALSE),
EMPTY_HOWTO (-1),
EMPTY_HOWTO (-1),
EMPTY_HOWTO (-1),
EMPTY_HOWTO (-1),
EMPTY_HOWTO (-1),
- HOWTO (16, 0, 2, 0, false, 0, complain_overflow_bitfield,0,"JMP_TABLE", false, 0,0x00000000, false),
+ HOWTO (16, 0, 2, 0, FALSE, 0, complain_overflow_bitfield,0,"JMP_TABLE", FALSE, 0,0x00000000, FALSE),
EMPTY_HOWTO (-1),
EMPTY_HOWTO (-1),
EMPTY_HOWTO (-1),
EMPTY_HOWTO (-1),
EMPTY_HOWTO (-1),
EMPTY_HOWTO (-1),
- HOWTO (32, 0, 2, 0, false, 0, complain_overflow_bitfield,0,"RELATIVE", false, 0,0x00000000, false),
+ HOWTO (32, 0, 2, 0, FALSE, 0, complain_overflow_bitfield,0,"RELATIVE", FALSE, 0,0x00000000, FALSE),
EMPTY_HOWTO (-1),
EMPTY_HOWTO (-1),
EMPTY_HOWTO (-1),
EMPTY_HOWTO (-1),
EMPTY_HOWTO (-1),
EMPTY_HOWTO (-1),
- HOWTO (40, 0, 2, 0, false, 0, complain_overflow_bitfield,0,"BASEREL", false, 0,0x00000000, false),
+ HOWTO (40, 0, 2, 0, FALSE, 0, complain_overflow_bitfield,0,"BASEREL", FALSE, 0,0x00000000, FALSE),
};
#define TABLE_SIZE(TABLE) (sizeof (TABLE) / sizeof (TABLE[0]))
#define EXT(i, j) case i: return &howto_table_ext[j]
#define STD(i, j) case i: return &howto_table_std[j]
int ext = obj_reloc_entry_size (abfd) == RELOC_EXT_SIZE;
+
if (code == BFD_RELOC_CTOR)
switch (bfd_get_arch_info (abfd)->bits_per_address)
{
code = BFD_RELOC_64;
break;
}
+
if (ext)
switch (code)
{
default: return (reloc_howto_type *) NULL;
}
else
- /* std relocs */
+ /* std relocs. */
switch (code)
{
+ STD (BFD_RELOC_8, 0);
STD (BFD_RELOC_16, 1);
STD (BFD_RELOC_32, 2);
STD (BFD_RELOC_8_PCREL, 4);
/* Make all the section for an a.out file. */
-boolean
+bfd_boolean
NAME(aout,make_sections) (abfd)
bfd *abfd;
{
if (obj_textsec (abfd) == (asection *) NULL
&& bfd_make_section (abfd, ".text") == (asection *) NULL)
- return false;
+ return FALSE;
if (obj_datasec (abfd) == (asection *) NULL
&& bfd_make_section (abfd, ".data") == (asection *) NULL)
- return false;
+ return FALSE;
if (obj_bsssec (abfd) == (asection *) NULL
&& bfd_make_section (abfd, ".bss") == (asection *) NULL)
- return false;
- return true;
+ return FALSE;
+ return TRUE;
}
/*
*abfd->tdata.aout_data = *oldrawptr;
abfd->tdata.aout_data->a.hdr = &rawptr->e;
- *(abfd->tdata.aout_data->a.hdr) = *execp; /* Copy in the internal_exec struct */
+ /* Copy in the internal_exec struct. */
+ *(abfd->tdata.aout_data->a.hdr) = *execp;
execp = abfd->tdata.aout_data->a.hdr;
- /* Set the file flags */
+ /* Set the file flags. */
abfd->flags = BFD_NO_FLAGS;
if (execp->a_drsize || execp->a_trsize)
abfd->flags |= HAS_RELOC;
- /* Setting of EXEC_P has been deferred to the bottom of this function */
+ /* Setting of EXEC_P has been deferred to the bottom of this function. */
if (execp->a_syms)
abfd->flags |= HAS_LINENO | HAS_DEBUG | HAS_SYMS | HAS_LOCALS;
if (N_DYNAMIC (*execp))
obj_aout_sym_hashes (abfd) = NULL;
if (! NAME(aout,make_sections) (abfd))
- return NULL;
+ goto error_ret;
- obj_datasec (abfd)->_raw_size = execp->a_data;
- obj_bsssec (abfd)->_raw_size = execp->a_bss;
+ obj_datasec (abfd)->size = execp->a_data;
+ obj_bsssec (abfd)->size = execp->a_bss;
obj_textsec (abfd)->flags =
(execp->a_trsize != 0
struct exec *execp = exec_hdr (abfd);
obj_textsec (abfd)->size = N_TXTSIZE (*execp);
- obj_textsec (abfd)->raw_size = N_TXTSIZE (*execp);
- /* data and bss are already filled in since they're so standard */
+ /* Data and bss are already filled in since they're so standard. */
- /* The virtual memory addresses of the sections */
+ /* The virtual memory addresses of the sections. */
obj_textsec (abfd)->vma = N_TXTADDR (*execp);
obj_datasec (abfd)->vma = N_DATADDR (*execp);
obj_bsssec (abfd)->vma = N_BSSADDR (*execp);
- /* The file offsets of the sections */
+ /* The file offsets of the sections. */
obj_textsec (abfd)->filepos = N_TXTOFF (*execp);
obj_datasec (abfd)->filepos = N_DATOFF (*execp);
- /* The file offsets of the relocation info */
+ /* The file offsets of the relocation info. */
obj_textsec (abfd)->rel_filepos = N_TRELOFF (*execp);
obj_datasec (abfd)->rel_filepos = N_DRELOFF (*execp);
if (execp->a_entry != 0
|| (execp->a_entry >= obj_textsec (abfd)->vma
&& execp->a_entry < (obj_textsec (abfd)->vma
- + obj_textsec (abfd)->_raw_size)))
+ + obj_textsec (abfd)->size)))
abfd->flags |= EXEC_P;
#ifdef STAT_FOR_EXEC
else
#endif /* STAT_FOR_EXEC */
if (result)
- {
-#if 0 /* These should be set correctly anyways. */
- abfd->sections = obj_textsec (abfd);
- obj_textsec (abfd)->next = obj_datasec (abfd);
- obj_datasec (abfd)->next = obj_bsssec (abfd);
-#endif
- }
- else
- {
- free (rawptr);
- abfd->tdata.aout_data = oldrawptr;
- }
- return result;
+ return result;
+
+ error_ret:
+ bfd_release (abfd, rawptr);
+ abfd->tdata.aout_data = oldrawptr;
+ return NULL;
}
/*
aout_@var{size}_mkobject
SYNOPSIS
- boolean aout_@var{size}_mkobject, (bfd *abfd);
+ bfd_boolean aout_@var{size}_mkobject, (bfd *abfd);
DESCRIPTION
Initialize BFD @var{abfd} for use with a.out files.
*/
-boolean
+bfd_boolean
NAME(aout,mkobject) (abfd)
bfd *abfd;
{
rawptr = (struct aout_data_struct *) bfd_zalloc (abfd, amt);
if (rawptr == NULL)
- return false;
+ return FALSE;
abfd->tdata.aout_data = rawptr;
exec_hdr (abfd) = &(rawptr->e);
obj_datasec (abfd) = (asection *) NULL;
obj_bsssec (abfd) = (asection *) NULL;
- return true;
+ return TRUE;
}
/*
NAME(aout,machine_type) (arch, machine, unknown)
enum bfd_architecture arch;
unsigned long machine;
- boolean *unknown;
+ bfd_boolean *unknown;
{
enum machine_type arch_flags;
arch_flags = M_UNKNOWN;
- *unknown = true;
+ *unknown = TRUE;
switch (arch)
{
switch (machine)
{
case 0: arch_flags = M_68010; break;
- case bfd_mach_m68000: arch_flags = M_UNKNOWN; *unknown = false; break;
+ case bfd_mach_m68000: arch_flags = M_UNKNOWN; *unknown = FALSE; break;
case bfd_mach_m68010: arch_flags = M_68010; break;
case bfd_mach_m68020: arch_flags = M_68020; break;
default: arch_flags = M_UNKNOWN; break;
break;
case bfd_arch_i386:
- if (machine == 0)
+ if (machine == 0
+ || machine == bfd_mach_i386_i386
+ || machine == bfd_mach_i386_i386_intel_syntax)
arch_flags = M_386;
break;
case bfd_mach_mips4600:
case bfd_mach_mips4650:
case bfd_mach_mips8000:
+ case bfd_mach_mips9000:
case bfd_mach_mips10000:
case bfd_mach_mips12000:
case bfd_mach_mips16:
case bfd_mach_mipsisa32:
+ case bfd_mach_mipsisa32r2:
case bfd_mach_mips5:
case bfd_mach_mipsisa64:
+ case bfd_mach_mipsisa64r2:
case bfd_mach_mips_sb1:
/* FIXME: These should be MIPS3, MIPS4, MIPS16, MIPS32, etc. */
arch_flags = M_MIPS2;
break;
case bfd_arch_vax:
- *unknown = false;
+ *unknown = FALSE;
break;
case bfd_arch_cris:
arch_flags = M_CRIS;
break;
+ case bfd_arch_m88k:
+ *unknown = FALSE;
+ break;
+
default:
arch_flags = M_UNKNOWN;
}
if (arch_flags != M_UNKNOWN)
- *unknown = false;
+ *unknown = FALSE;
return arch_flags;
}
aout_@var{size}_set_arch_mach
SYNOPSIS
- boolean aout_@var{size}_set_arch_mach,
+ bfd_boolean aout_@var{size}_set_arch_mach,
(bfd *,
enum bfd_architecture arch,
unsigned long machine));
can support the architecture required.
*/
-boolean
+bfd_boolean
NAME(aout,set_arch_mach) (abfd, arch, machine)
bfd *abfd;
enum bfd_architecture arch;
unsigned long machine;
{
if (! bfd_default_set_arch_mach (abfd, arch, machine))
- return false;
+ return FALSE;
if (arch != bfd_arch_unknown)
{
- boolean unknown;
+ bfd_boolean unknown;
NAME(aout,machine_type) (arch, machine, &unknown);
if (unknown)
- return false;
+ return FALSE;
}
- /* Determine the size of a relocation entry */
+ /* Determine the size of a relocation entry. */
switch (arch)
{
case bfd_arch_sparc:
else
vma = obj_textsec (abfd)->vma;
- pos += obj_textsec (abfd)->_raw_size;
- vma += obj_textsec (abfd)->_raw_size;
+ pos += obj_textsec (abfd)->size;
+ vma += obj_textsec (abfd)->size;
/* Data. */
if (!obj_datasec (abfd)->user_set_vma)
{
-#if 0 /* ?? Does alignment in the file image really matter? */
- pad = align_power (vma, obj_datasec (abfd)->alignment_power) - vma;
-#endif
- obj_textsec (abfd)->_raw_size += pad;
+ obj_textsec (abfd)->size += pad;
pos += pad;
vma += pad;
obj_datasec (abfd)->vma = vma;
else
vma = obj_datasec (abfd)->vma;
obj_datasec (abfd)->filepos = pos;
- pos += obj_datasec (abfd)->_raw_size;
- vma += obj_datasec (abfd)->_raw_size;
+ pos += obj_datasec (abfd)->size;
+ vma += obj_datasec (abfd)->size;
/* BSS. */
if (!obj_bsssec (abfd)->user_set_vma)
{
-#if 0
- pad = align_power (vma, obj_bsssec (abfd)->alignment_power) - vma;
-#endif
- obj_datasec (abfd)->_raw_size += pad;
+ obj_datasec (abfd)->size += pad;
pos += pad;
vma += pad;
obj_bsssec (abfd)->vma = vma;
pad = obj_bsssec (abfd)->vma - vma;
if (pad > 0)
{
- obj_datasec (abfd)->_raw_size += pad;
+ obj_datasec (abfd)->size += pad;
pos += pad;
}
}
obj_bsssec (abfd)->filepos = pos;
/* Fix up the exec header. */
- execp->a_text = obj_textsec (abfd)->_raw_size;
- execp->a_data = obj_datasec (abfd)->_raw_size;
- execp->a_bss = obj_bsssec (abfd)->_raw_size;
+ execp->a_text = obj_textsec (abfd)->size;
+ execp->a_data = obj_datasec (abfd)->size;
+ execp->a_bss = obj_bsssec (abfd)->size;
N_SET_MAGIC (*execp, OMAGIC);
}
/* Find start of data. */
if (ztih)
{
- text_end = obj_textsec (abfd)->filepos + obj_textsec (abfd)->_raw_size;
+ text_end = obj_textsec (abfd)->filepos + obj_textsec (abfd)->size;
text_pad += BFD_ALIGN (text_end, adata (abfd).page_size) - text_end;
}
else
/* Note that if page_size == zmagic_disk_block_size, then
filepos == page_size, and this case is the same as the ztih
case. */
- text_end = obj_textsec (abfd)->_raw_size;
+ text_end = obj_textsec (abfd)->size;
text_pad += BFD_ALIGN (text_end, adata (abfd).page_size) - text_end;
text_end += obj_textsec (abfd)->filepos;
}
- obj_textsec (abfd)->_raw_size += text_pad;
+ obj_textsec (abfd)->size += text_pad;
text_end += text_pad;
/* Data. */
if (!obj_datasec (abfd)->user_set_vma)
{
bfd_vma vma;
- vma = obj_textsec (abfd)->vma + obj_textsec (abfd)->_raw_size;
+ vma = obj_textsec (abfd)->vma + obj_textsec (abfd)->size;
obj_datasec (abfd)->vma = BFD_ALIGN (vma, adata (abfd).segment_size);
}
if (abdp && abdp->zmagic_mapped_contiguous)
asection * text = obj_textsec (abfd);
asection * data = obj_datasec (abfd);
- text_pad = data->vma - (text->vma + text->_raw_size);
+ text_pad = data->vma - (text->vma + text->size);
/* Only pad the text section if the data
section is going to be placed after it. */
if (text_pad > 0)
- text->_raw_size += text_pad;
+ text->size += text_pad;
}
obj_datasec (abfd)->filepos = (obj_textsec (abfd)->filepos
- + obj_textsec (abfd)->_raw_size);
+ + obj_textsec (abfd)->size);
/* Fix up exec header while we're at it. */
- execp->a_text = obj_textsec (abfd)->_raw_size;
+ execp->a_text = obj_textsec (abfd)->size;
if (ztih && (!abdp || (abdp && !abdp->exec_header_not_counted)))
execp->a_text += adata (abfd).exec_bytes_size;
if (obj_aout_subformat (abfd) == q_magic_format)
N_SET_MAGIC (*execp, ZMAGIC);
/* Spec says data section should be rounded up to page boundary. */
- obj_datasec (abfd)->_raw_size
- = align_power (obj_datasec (abfd)->_raw_size,
+ obj_datasec (abfd)->size
+ = align_power (obj_datasec (abfd)->size,
obj_bsssec (abfd)->alignment_power);
- execp->a_data = BFD_ALIGN (obj_datasec (abfd)->_raw_size,
+ execp->a_data = BFD_ALIGN (obj_datasec (abfd)->size,
adata (abfd).page_size);
- data_pad = execp->a_data - obj_datasec (abfd)->_raw_size;
+ data_pad = execp->a_data - obj_datasec (abfd)->size;
/* BSS. */
if (!obj_bsssec (abfd)->user_set_vma)
obj_bsssec (abfd)->vma = (obj_datasec (abfd)->vma
- + obj_datasec (abfd)->_raw_size);
+ + obj_datasec (abfd)->size);
/* If the BSS immediately follows the data section and extra space
in the page is left after the data section, fudge data
in the header so that the bss section looks smaller by that
could have explicitly set the BSS vma to immediately follow
the data section.) */
if (align_power (obj_bsssec (abfd)->vma, obj_bsssec (abfd)->alignment_power)
- == obj_datasec (abfd)->vma + obj_datasec (abfd)->_raw_size)
- execp->a_bss = (data_pad > obj_bsssec (abfd)->_raw_size
- ? 0 : obj_bsssec (abfd)->_raw_size - data_pad);
+ == obj_datasec (abfd)->vma + obj_datasec (abfd)->size)
+ execp->a_bss = (data_pad > obj_bsssec (abfd)->size
+ ? 0 : obj_bsssec (abfd)->size - data_pad);
else
- execp->a_bss = obj_bsssec (abfd)->_raw_size;
+ execp->a_bss = obj_bsssec (abfd)->size;
}
static void
obj_textsec (abfd)->vma = vma;
else
vma = obj_textsec (abfd)->vma;
- pos += obj_textsec (abfd)->_raw_size;
- vma += obj_textsec (abfd)->_raw_size;
+ pos += obj_textsec (abfd)->size;
+ vma += obj_textsec (abfd)->size;
/* Data. */
obj_datasec (abfd)->filepos = pos;
vma = obj_datasec (abfd)->vma;
/* Since BSS follows data immediately, see if it needs alignment. */
- vma += obj_datasec (abfd)->_raw_size;
+ vma += obj_datasec (abfd)->size;
pad = align_power (vma, obj_bsssec (abfd)->alignment_power) - vma;
- obj_datasec (abfd)->_raw_size += pad;
- pos += obj_datasec (abfd)->_raw_size;
+ obj_datasec (abfd)->size += pad;
+ pos += obj_datasec (abfd)->size;
/* BSS. */
if (!obj_bsssec (abfd)->user_set_vma)
vma = obj_bsssec (abfd)->vma;
/* Fix up exec header. */
- execp->a_text = obj_textsec (abfd)->_raw_size;
- execp->a_data = obj_datasec (abfd)->_raw_size;
- execp->a_bss = obj_bsssec (abfd)->_raw_size;
+ execp->a_text = obj_textsec (abfd)->size;
+ execp->a_data = obj_datasec (abfd)->size;
+ execp->a_bss = obj_bsssec (abfd)->size;
N_SET_MAGIC (*execp, NMAGIC);
}
-boolean
+bfd_boolean
NAME(aout,adjust_sizes_and_vmas) (abfd, text_size, text_end)
bfd *abfd;
bfd_size_type *text_size;
struct internal_exec *execp = exec_hdr (abfd);
if (! NAME(aout,make_sections) (abfd))
- return false;
+ return FALSE;
if (adata (abfd).magic != undecided_magic)
- return true;
+ return TRUE;
- obj_textsec (abfd)->_raw_size =
- align_power (obj_textsec (abfd)->_raw_size,
+ obj_textsec (abfd)->size =
+ align_power (obj_textsec (abfd)->size,
obj_textsec (abfd)->alignment_power);
- *text_size = obj_textsec (abfd)->_raw_size;
+ *text_size = obj_textsec (abfd)->size;
/* Rule (heuristic) for when to pad to a new page. Note that there
are (at least) two ways demand-paged (ZMAGIC) files have been
handled. Most Berkeley-based systems start the text segment at
}
str;
}),
- obj_textsec (abfd)->vma, obj_textsec (abfd)->_raw_size,
+ obj_textsec (abfd)->vma, obj_textsec (abfd)->size,
obj_textsec (abfd)->alignment_power,
- obj_datasec (abfd)->vma, obj_datasec (abfd)->_raw_size,
+ obj_datasec (abfd)->vma, obj_datasec (abfd)->size,
obj_datasec (abfd)->alignment_power,
- obj_bsssec (abfd)->vma, obj_bsssec (abfd)->_raw_size,
+ obj_bsssec (abfd)->vma, obj_bsssec (abfd)->size,
obj_bsssec (abfd)->alignment_power);
#endif
#endif
#ifdef BFD_AOUT_DEBUG
fprintf (stderr, " text=<%x,%x,%x> data=<%x,%x,%x> bss=<%x,%x>\n",
- obj_textsec (abfd)->vma, obj_textsec (abfd)->_raw_size,
+ obj_textsec (abfd)->vma, obj_textsec (abfd)->size,
obj_textsec (abfd)->filepos,
- obj_datasec (abfd)->vma, obj_datasec (abfd)->_raw_size,
+ obj_datasec (abfd)->vma, obj_datasec (abfd)->size,
obj_datasec (abfd)->filepos,
- obj_bsssec (abfd)->vma, obj_bsssec (abfd)->_raw_size);
+ obj_bsssec (abfd)->vma, obj_bsssec (abfd)->size);
#endif
- return true;
+ return TRUE;
}
/*
aout_@var{size}_new_section_hook
SYNOPSIS
- boolean aout_@var{size}_new_section_hook,
+ bfd_boolean aout_@var{size}_new_section_hook,
(bfd *abfd,
asection *newsect));
Called by the BFD in response to a @code{bfd_make_section}
request.
*/
-boolean
+bfd_boolean
NAME(aout,new_section_hook) (abfd, newsect)
bfd *abfd;
asection *newsect;
{
- /* align to double at least */
+ /* Align to double at least. */
newsect->alignment_power = bfd_get_arch_info (abfd)->section_align_power;
if (bfd_get_format (abfd) == bfd_object)
- {
- if (obj_textsec (abfd) == NULL && !strcmp (newsect->name, ".text"))
- {
- obj_textsec (abfd)= newsect;
- newsect->target_index = N_TEXT;
- return true;
- }
-
- if (obj_datasec (abfd) == NULL && !strcmp (newsect->name, ".data"))
- {
- obj_datasec (abfd) = newsect;
- newsect->target_index = N_DATA;
- return true;
- }
+ {
+ if (obj_textsec (abfd) == NULL && !strcmp (newsect->name, ".text"))
+ {
+ obj_textsec (abfd)= newsect;
+ newsect->target_index = N_TEXT;
+ return TRUE;
+ }
- if (obj_bsssec (abfd) == NULL && !strcmp (newsect->name, ".bss"))
- {
- obj_bsssec (abfd) = newsect;
- newsect->target_index = N_BSS;
- return true;
- }
+ if (obj_datasec (abfd) == NULL && !strcmp (newsect->name, ".data"))
+ {
+ obj_datasec (abfd) = newsect;
+ newsect->target_index = N_DATA;
+ return TRUE;
+ }
- }
+ if (obj_bsssec (abfd) == NULL && !strcmp (newsect->name, ".bss"))
+ {
+ obj_bsssec (abfd) = newsect;
+ newsect->target_index = N_BSS;
+ return TRUE;
+ }
+ }
- /* We allow more than three sections internally */
- return true;
+ /* We allow more than three sections internally. */
+ return TRUE;
}
-boolean
+bfd_boolean
NAME(aout,set_section_contents) (abfd, section, location, offset, count)
bfd *abfd;
sec_ptr section;
- PTR location;
+ const PTR location;
file_ptr offset;
bfd_size_type count;
{
if (! abfd->output_has_begun)
{
if (! NAME(aout,adjust_sizes_and_vmas) (abfd, &text_size, &text_end))
- return false;
+ return FALSE;
}
if (section == obj_bsssec (abfd))
{
bfd_set_error (bfd_error_no_contents);
- return false;
+ return FALSE;
}
if (section != obj_textsec (abfd)
&& section != obj_datasec (abfd))
{
- (*_bfd_error_handler)
- (_("%s: can not represent section `%s' in a.out object file format"),
- bfd_get_filename (abfd), bfd_get_section_name (abfd, section));
- bfd_set_error (bfd_error_nonrepresentable_section);
- return false;
+ if (aout_section_merge_with_text_p (abfd, section))
+ section->filepos = obj_textsec (abfd)->filepos +
+ (section->vma - obj_textsec (abfd)->vma);
+ else
+ {
+ (*_bfd_error_handler)
+ (_("%s: can not represent section `%s' in a.out object file format"),
+ bfd_get_filename (abfd), bfd_get_section_name (abfd, section));
+ bfd_set_error (bfd_error_nonrepresentable_section);
+ return FALSE;
+ }
}
if (count != 0)
{
if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0
|| bfd_bwrite (location, count, abfd) != count)
- return false;
+ return FALSE;
}
- return true;
+ return TRUE;
}
\f
/* Read the external symbols from an a.out file. */
-static boolean
+static bfd_boolean
aout_get_external_symbols (abfd)
bfd *abfd;
{
count = exec_hdr (abfd)->a_syms / EXTERNAL_NLIST_SIZE;
#ifdef USE_MMAP
- if (bfd_get_file_window (abfd,
- obj_sym_filepos (abfd), exec_hdr (abfd)->a_syms,
- &obj_aout_sym_window (abfd), true) == false)
- return false;
+ if (! bfd_get_file_window (abfd, obj_sym_filepos (abfd),
+ exec_hdr (abfd)->a_syms,
+ &obj_aout_sym_window (abfd), TRUE))
+ return FALSE;
syms = (struct external_nlist *) obj_aout_sym_window (abfd).data;
#else
/* We allocate using malloc to make the values easy to free
syms = ((struct external_nlist *)
bfd_malloc (count * EXTERNAL_NLIST_SIZE));
if (syms == (struct external_nlist *) NULL && count != 0)
- return false;
+ return FALSE;
amt = exec_hdr (abfd)->a_syms;
if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0
|| bfd_bread (syms, amt, abfd) != amt)
{
free (syms);
- return false;
+ return FALSE;
}
#endif
/* Get the size of the strings. */
if (bfd_seek (abfd, obj_str_filepos (abfd), SEEK_SET) != 0
|| bfd_bread ((PTR) string_chars, amt, abfd) != amt)
- return false;
+ return FALSE;
stringsize = GET_WORD (abfd, string_chars);
#ifdef USE_MMAP
- if (bfd_get_file_window (abfd, obj_str_filepos (abfd), stringsize,
- &obj_aout_string_window (abfd), true) == false)
- return false;
+ if (! bfd_get_file_window (abfd, obj_str_filepos (abfd), stringsize,
+ &obj_aout_string_window (abfd), TRUE))
+ return FALSE;
strings = (char *) obj_aout_string_window (abfd).data;
#else
strings = (char *) bfd_malloc (stringsize + 1);
if (strings == NULL)
- return false;
+ return FALSE;
/* Skip space for the string count in the buffer for convenience
when using indexes. */
if (bfd_bread (strings + BYTES_IN_WORD, amt, abfd) != amt)
{
free (strings);
- return false;
+ return FALSE;
}
#endif
obj_aout_external_string_size (abfd) = stringsize;
}
- return true;
+ return TRUE;
}
/* Translate an a.out symbol into a BFD symbol. The desc, other, type
nlist structure. This function is responsible for setting
symbol->flags and symbol->section, and adjusting symbol->value. */
-static boolean
+static bfd_boolean
translate_from_native_sym_flags (abfd, cache_ptr)
bfd *abfd;
aout_symbol_type *cache_ptr;
asection *sec;
/* This is a debugging symbol. */
-
cache_ptr->symbol.flags = BSF_DEBUGGING;
/* Work out the symbol section. */
cache_ptr->symbol.section = sec;
cache_ptr->symbol.value -= sec->vma;
- return true;
+ return TRUE;
}
/* Get the default visibility. This does not apply to all types, so
/* This code is no longer needed. It used to be used to make
the linker handle set symbols, but they are now handled in
the add_symbols routine instead. */
-#if 0
- asection *section;
- arelent_chain *reloc;
- asection *into_section;
- bfd_size_type amt;
-
- /* This is a set symbol. The name of the symbol is the name
- of the set (e.g., __CTOR_LIST__). The value of the symbol
- is the value to add to the set. We create a section with
- the same name as the symbol, and add a reloc to insert the
- appropriate value into the section.
-
- This action is actually obsolete; it used to make the
- linker do the right thing, but the linker no longer uses
- this function. */
-
- section = bfd_get_section_by_name (abfd, cache_ptr->symbol.name);
- if (section == NULL)
- {
- char *copy;
-
- amt = strlen (cache_ptr->symbol.name) + 1;
- copy = bfd_alloc (abfd, amt);
- if (copy == NULL)
- return false;
-
- strcpy (copy, cache_ptr->symbol.name);
- section = bfd_make_section (abfd, copy);
- if (section == NULL)
- return false;
- }
-
- amt = sizeof (arelent_chain);
- reloc = (arelent_chain *) bfd_alloc (abfd, amt);
- if (reloc == NULL)
- return false;
-
- /* Build a relocation entry for the constructor. */
- switch (cache_ptr->type & N_TYPE)
- {
- case N_SETA:
- into_section = bfd_abs_section_ptr;
- cache_ptr->type = N_ABS;
- break;
- case N_SETT:
- into_section = obj_textsec (abfd);
- cache_ptr->type = N_TEXT;
- break;
- case N_SETD:
- into_section = obj_datasec (abfd);
- cache_ptr->type = N_DATA;
- break;
- case N_SETB:
- into_section = obj_bsssec (abfd);
- cache_ptr->type = N_BSS;
- break;
- }
-
- /* Build a relocation pointing into the constructor section
- pointing at the symbol in the set vector specified. */
- reloc->relent.addend = cache_ptr->symbol.value;
- cache_ptr->symbol.section = into_section;
- reloc->relent.sym_ptr_ptr = into_section->symbol_ptr_ptr;
-
- /* We modify the symbol to belong to a section depending upon
- the name of the symbol, and add to the size of the section
- to contain a pointer to the symbol. Build a reloc entry to
- relocate to this symbol attached to this section. */
- section->flags = SEC_CONSTRUCTOR | SEC_RELOC;
-
- section->reloc_count++;
- section->alignment_power = 2;
-
- reloc->next = section->constructor_chain;
- section->constructor_chain = reloc;
- reloc->relent.address = section->_raw_size;
- section->_raw_size += BYTES_IN_WORD;
-
- reloc->relent.howto = CTOR_TABLE_RELOC_HOWTO (abfd);
-
-#endif /* 0 */
-
switch (cache_ptr->type & N_TYPE)
{
case N_SETA:
break;
}
- return true;
+ return TRUE;
}
/* Set the fields of SYM_POINTER according to CACHE_PTR. */
-static boolean
+static bfd_boolean
translate_to_native_sym_flags (abfd, cache_ptr, sym_pointer)
bfd *abfd;
asymbol *cache_ptr;
bfd_get_filename (abfd),
cache_ptr->name != NULL ? cache_ptr->name : _("*unknown*"));
bfd_set_error (bfd_error_nonrepresentable_section);
- return false;
+ return FALSE;
}
if (sec->output_section != NULL)
sym_pointer->e_type[0] = N_UNDF | N_EXT;
else
{
- (*_bfd_error_handler)
- (_("%s: can not represent section `%s' in a.out object file format"),
- bfd_get_filename (abfd), bfd_get_section_name (abfd, sec));
- bfd_set_error (bfd_error_nonrepresentable_section);
- return false;
+ if (aout_section_merge_with_text_p (abfd, sec))
+ sym_pointer->e_type[0] |= N_TEXT;
+ else
+ {
+ (*_bfd_error_handler)
+ (_("%s: can not represent section `%s' in a.out object file format"),
+ bfd_get_filename (abfd), bfd_get_section_name (abfd, sec));
+ bfd_set_error (bfd_error_nonrepresentable_section);
+ return FALSE;
+ }
}
- /* Turn the symbol from section relative to absolute again */
+ /* Turn the symbol from section relative to absolute again. */
value += sec->vma + off;
if ((cache_ptr->flags & BSF_WARNING) != 0)
if ((cache_ptr->flags & BSF_CONSTRUCTOR) != 0)
{
int type = ((aout_symbol_type *) cache_ptr)->type;
+
switch (type)
{
case N_ABS: type = N_SETA; break;
PUT_WORD (abfd, value, sym_pointer->e_value);
- return true;
+ return TRUE;
}
\f
/* Native-level interface to symbols. */
/* Translate a set of internal symbols into external symbols. */
-boolean
+bfd_boolean
NAME(aout,translate_symbol_table) (abfd, in, ext, count, str, strsize, dynamic)
bfd *abfd;
aout_symbol_type *in;
bfd_size_type count;
char *str;
bfd_size_type strsize;
- boolean dynamic;
+ bfd_boolean dynamic;
{
struct external_nlist *ext_end;
else if (x < strsize)
in->symbol.name = str + x;
else
- return false;
+ return FALSE;
in->symbol.value = GET_SWORD (abfd, ext->e_value);
in->desc = H_GET_16 (abfd, ext->e_desc);
in->symbol.udata.p = NULL;
if (! translate_from_native_sym_flags (abfd, in))
- return false;
+ return FALSE;
if (dynamic)
in->symbol.flags |= BSF_DYNAMIC;
}
- return true;
+ return TRUE;
}
/* We read the symbols into a buffer, which is discarded when this
function exits. We read the strings into a buffer large enough to
hold them all plus all the cached symbol entries. */
-boolean
+bfd_boolean
NAME(aout,slurp_symbol_table) (abfd)
bfd *abfd;
{
aout_symbol_type *cached;
bfd_size_type cached_size;
- /* If there's no work to be done, don't do any */
+ /* If there's no work to be done, don't do any. */
if (obj_aout_symbols (abfd) != (aout_symbol_type *) NULL)
- return true;
+ return TRUE;
old_external_syms = obj_aout_external_syms (abfd);
if (! aout_get_external_symbols (abfd))
- return false;
+ return FALSE;
cached_size = obj_aout_external_sym_count (abfd);
cached_size *= sizeof (aout_symbol_type);
- cached = (aout_symbol_type *) bfd_malloc (cached_size);
+ cached = (aout_symbol_type *) bfd_zmalloc (cached_size);
if (cached == NULL && cached_size != 0)
- return false;
- if (cached_size != 0)
- memset (cached, 0, (size_t) cached_size);
+ return FALSE;
/* Convert from external symbol information to internal. */
if (! (NAME(aout,translate_symbol_table)
obj_aout_external_sym_count (abfd),
obj_aout_external_strings (abfd),
obj_aout_external_string_size (abfd),
- false)))
+ FALSE)))
{
free (cached);
- return false;
+ return FALSE;
}
bfd_get_symcount (abfd) = obj_aout_external_sym_count (abfd);
obj_aout_external_syms (abfd) = NULL;
}
- return true;
+ return TRUE;
}
\f
/* We use a hash table when writing out symbols so that we only write
if BFD_TRADITIONAL_FORMAT is set. */
static bfd_size_type add_to_stringtab
- PARAMS ((bfd *, struct bfd_strtab_hash *, const char *, boolean));
-static boolean emit_stringtab PARAMS ((bfd *, struct bfd_strtab_hash *));
+ PARAMS ((bfd *, struct bfd_strtab_hash *, const char *, bfd_boolean));
+static bfd_boolean emit_stringtab
+ PARAMS ((bfd *, struct bfd_strtab_hash *));
/* Get the index of a string in a strtab, adding it if it is not
already present. */
bfd *abfd;
struct bfd_strtab_hash *tab;
const char *str;
- boolean copy;
+ bfd_boolean copy;
{
- boolean hash;
+ bfd_boolean hash;
bfd_size_type index;
/* An index of 0 always means the empty string. */
/* Don't hash if BFD_TRADITIONAL_FORMAT is set, because SunOS dbx
doesn't understand a hashed string table. */
- hash = true;
+ hash = TRUE;
if ((abfd->flags & BFD_TRADITIONAL_FORMAT) != 0)
- hash = false;
+ hash = FALSE;
index = _bfd_stringtab_add (tab, str, hash, copy);
/* Write out a strtab. ABFD is already at the right location in the
file. */
-static boolean
+static bfd_boolean
emit_stringtab (abfd, tab)
register bfd *abfd;
struct bfd_strtab_hash *tab;
/* The string table starts with the size. */
PUT_WORD (abfd, _bfd_stringtab_size (tab) + BYTES_IN_WORD, buffer);
if (bfd_bwrite ((PTR) buffer, amt, abfd) != amt)
- return false;
+ return FALSE;
return _bfd_stringtab_emit (abfd, tab);
}
\f
-boolean
+bfd_boolean
NAME(aout,write_syms) (abfd)
bfd *abfd;
{
strtab = _bfd_stringtab_init ();
if (strtab == NULL)
- return false;
+ return FALSE;
for (count = 0; count < bfd_get_symcount (abfd); count++)
{
struct external_nlist nsp;
bfd_size_type amt;
- indx = add_to_stringtab (abfd, strtab, g->name, false);
+ indx = add_to_stringtab (abfd, strtab, g->name, FALSE);
if (indx == (bfd_size_type) -1)
goto error_return;
PUT_WORD (abfd, indx, (bfd_byte *) nsp.e_strx);
_bfd_stringtab_free (strtab);
- return true;
+ return TRUE;
error_return:
_bfd_stringtab_free (strtab);
- return false;
+ return FALSE;
}
\f
long
-NAME(aout,get_symtab) (abfd, location)
+NAME(aout,canonicalize_symtab) (abfd, location)
bfd *abfd;
asymbol **location;
{
return bfd_get_symcount (abfd);
}
\f
-/* Standard reloc stuff */
+/* Standard reloc stuff. */
/* Output standard relocation information to a file in target byte order. */
extern void NAME(aout,swap_std_reloc_out)
PUT_WORD (abfd, g->address, natptr->r_address);
- r_length = g->howto->size ; /* Size as a power of two */
- r_pcrel = (int) g->howto->pc_relative; /* Relative to PC? */
+ r_length = g->howto->size ; /* Size as a power of two. */
+ r_pcrel = (int) g->howto->pc_relative; /* Relative to PC? */
/* XXX This relies on relocs coming from a.out files. */
r_baserel = (g->howto->type & 8) != 0;
r_jmptable = (g->howto->type & 16) != 0;
r_relative = (g->howto->type & 32) != 0;
-#if 0
- /* For a standard reloc, the addend is in the object file. */
- r_addend = g->addend + (*(g->sym_ptr_ptr))->section->output_section->vma;
-#endif
-
- /* name was clobbered by aout_write_syms to be symbol index */
+ /* Name was clobbered by aout_write_syms to be symbol index. */
/* If this relocation is relative to a symbol then set the
r_index to the symbols index, and the r_extern bit.
Absolute symbols can come in in two ways, either as an offset
from the abs section, or as a symbol which has an abs value.
- check for that here
- */
+ check for that here. */
if (bfd_is_com_section (output_section)
|| bfd_is_abs_section (output_section)
|| bfd_is_und_section (output_section))
{
if (bfd_abs_section_ptr->symbol == sym)
- {
- /* Whoops, looked like an abs symbol, but is really an offset
- from the abs section */
- r_index = N_ABS;
- r_extern = 0;
- }
+ {
+ /* Whoops, looked like an abs symbol, but is
+ really an offset from the abs section. */
+ r_index = N_ABS;
+ r_extern = 0;
+ }
else
- {
- /* Fill in symbol */
- r_extern = 1;
- r_index = (*(g->sym_ptr_ptr))->KEEPIT;
-
- }
+ {
+ /* Fill in symbol. */
+ r_extern = 1;
+ r_index = (*(g->sym_ptr_ptr))->KEEPIT;
+ }
}
else
{
- /* Just an ordinary section */
+ /* Just an ordinary section. */
r_extern = 0;
r_index = output_section->target_index;
}
- /* now the fun stuff */
+ /* Now the fun stuff. */
if (bfd_header_big_endian (abfd))
{
natptr->r_index[0] = r_index >> 16;
}
}
-/* Extended stuff */
+/* Extended stuff. */
/* Output extended relocation information to a file in target byte order. */
extern void NAME(aout,swap_ext_reloc_out)
Absolute symbols can come in in two ways, either as an offset
from the abs section, or as a symbol which has an abs value.
check for that here. */
-
if (bfd_is_abs_section (bfd_get_section (sym)))
{
r_extern = 0;
}
else
{
- /* Just an ordinary section */
+ /* Just an ordinary section. */
r_extern = 0;
r_index = output_section->target_index;
}
- /* now the fun stuff */
+ /* Now the fun stuff. */
if (bfd_header_big_endian (abfd))
{
natptr->r_index[0] = r_index >> 16;
cache_ptr->address = (GET_SWORD (abfd, bytes->r_address));
- /* now the fun stuff */
+ /* Now the fun stuff. */
if (bfd_header_big_endian (abfd))
{
- r_index = ((bytes->r_index[0] << 16)
- | (bytes->r_index[1] << 8)
+ r_index = (((unsigned int) bytes->r_index[0] << 16)
+ | ((unsigned int) bytes->r_index[1] << 8)
| bytes->r_index[2]);
r_extern = (0 != (bytes->r_type[0] & RELOC_EXT_BITS_EXTERN_BIG));
r_type = ((bytes->r_type[0] & RELOC_EXT_BITS_TYPE_BIG)
}
else
{
- r_index = ((bytes->r_index[2] << 16)
- | (bytes->r_index[1] << 8)
+ r_index = (((unsigned int) bytes->r_index[2] << 16)
+ | ((unsigned int) bytes->r_index[1] << 8)
| bytes->r_index[0]);
r_extern = (0 != (bytes->r_type[0] & RELOC_EXT_BITS_EXTERN_LITTLE));
r_type = ((bytes->r_type[0] & RELOC_EXT_BITS_TYPE_LITTLE)
/* Base relative relocs are always against the symbol table,
regardless of the setting of r_extern. r_extern just reflects
whether the symbol the reloc is against is local or global. */
- if (r_type == RELOC_BASE10
- || r_type == RELOC_BASE13
- || r_type == RELOC_BASE22)
+ if (r_type == (unsigned int) RELOC_BASE10
+ || r_type == (unsigned int) RELOC_BASE13
+ || r_type == (unsigned int) RELOC_BASE22)
r_extern = 1;
if (r_extern && r_index > symcount)
cache_ptr->address = H_GET_32 (abfd, bytes->r_address);
- /* now the fun stuff */
+ /* Now the fun stuff. */
if (bfd_header_big_endian (abfd))
{
- r_index = ((bytes->r_index[0] << 16)
- | (bytes->r_index[1] << 8)
+ r_index = (((unsigned int) bytes->r_index[0] << 16)
+ | ((unsigned int) bytes->r_index[1] << 8)
| bytes->r_index[2]);
r_extern = (0 != (bytes->r_type[0] & RELOC_STD_BITS_EXTERN_BIG));
r_pcrel = (0 != (bytes->r_type[0] & RELOC_STD_BITS_PCREL_BIG));
}
else
{
- r_index = ((bytes->r_index[2] << 16)
- | (bytes->r_index[1] << 8)
+ r_index = (((unsigned int) bytes->r_index[2] << 16)
+ | ((unsigned int) bytes->r_index[1] << 8)
| bytes->r_index[0]);
r_extern = (0 != (bytes->r_type[0] & RELOC_STD_BITS_EXTERN_LITTLE));
r_pcrel = (0 != (bytes->r_type[0] & RELOC_STD_BITS_PCREL_LITTLE));
/* Read and swap the relocs for a section. */
-boolean
+bfd_boolean
NAME(aout,slurp_reloc_table) (abfd, asect, symbols)
bfd *abfd;
sec_ptr asect;
bfd_size_type amt;
if (asect->relocation)
- return true;
+ return TRUE;
if (asect->flags & SEC_CONSTRUCTOR)
- return true;
+ return TRUE;
if (asect == obj_datasec (abfd))
reloc_size = exec_hdr (abfd)->a_drsize;
else
{
bfd_set_error (bfd_error_invalid_operation);
- return false;
+ return FALSE;
}
if (bfd_seek (abfd, asect->rel_filepos, SEEK_SET) != 0)
- return false;
+ return FALSE;
each_size = obj_reloc_entry_size (abfd);
count = reloc_size / each_size;
amt = count * sizeof (arelent);
- reloc_cache = (arelent *) bfd_malloc (amt);
+ reloc_cache = (arelent *) bfd_zmalloc (amt);
if (reloc_cache == NULL && count != 0)
- return false;
- memset (reloc_cache, 0, (size_t) amt);
+ return FALSE;
relocs = bfd_malloc (reloc_size);
if (relocs == NULL && reloc_size != 0)
{
free (reloc_cache);
- return false;
+ return FALSE;
}
if (bfd_bread (relocs, reloc_size, abfd) != reloc_size)
{
free (relocs);
free (reloc_cache);
- return false;
+ return FALSE;
}
cache_ptr = reloc_cache;
asect->relocation = reloc_cache;
asect->reloc_count = cache_ptr - reloc_cache;
- return true;
+ return TRUE;
}
/* Write out a relocation section into an object file. */
-boolean
+bfd_boolean
NAME(aout,squirt_out_relocs) (abfd, section)
bfd *abfd;
asection *section;
bfd_size_type natsize;
if (count == 0 || section->orelocation == NULL)
- return true;
+ return TRUE;
each_size = obj_reloc_entry_size (abfd);
natsize = (bfd_size_type) each_size * count;
native = (unsigned char *) bfd_zalloc (abfd, natsize);
if (!native)
- return false;
+ return FALSE;
generic = section->orelocation;
if (bfd_bwrite ((PTR) native, natsize, abfd) != natsize)
{
bfd_release (abfd, native);
- return false;
+ return FALSE;
}
bfd_release (abfd, native);
- return true;
+ return TRUE;
}
-/* This is stupid. This function should be a boolean predicate */
+/* This is stupid. This function should be a boolean predicate. */
+
long
NAME(aout,canonicalize_reloc) (abfd, section, relptr, symbols)
bfd *abfd;
bfd_set_error (bfd_error_invalid_operation);
return -1;
}
+
if (asect->flags & SEC_CONSTRUCTOR)
- {
- return (sizeof (arelent *) * (asect->reloc_count+1));
- }
+ return (sizeof (arelent *) * (asect->reloc_count+1));
if (asect == obj_datasec (abfd))
return (sizeof (arelent *)
long
NAME(aout,read_minisymbols) (abfd, dynamic, minisymsp, sizep)
bfd *abfd;
- boolean dynamic;
+ bfd_boolean dynamic;
PTR *minisymsp;
unsigned int *sizep;
{
asymbol *
NAME(aout,minisymbol_to_symbol) (abfd, dynamic, minisym, sym)
bfd *abfd;
- boolean dynamic;
+ bfd_boolean dynamic;
const PTR minisym;
asymbol *sym;
{
(bfd_size_type) 1,
obj_aout_external_strings (abfd),
obj_aout_external_string_size (abfd),
- false)))
+ FALSE)))
return NULL;
return sym;
}
-/*
- provided a BFD, a section and an offset into the section, calculate
- and return the name of the source file and the line nearest to the
- wanted location.
-*/
+/* Provided a BFD, a section and an offset into the section, calculate
+ and return the name of the source file and the line nearest to the
+ wanted location. */
-boolean
+bfd_boolean
NAME(aout,find_nearest_line)
(abfd, section, symbols, offset, filename_ptr, functionname_ptr, line_ptr)
bfd *abfd;
const char **functionname_ptr;
unsigned int *line_ptr;
{
- /* Run down the file looking for the filename, function and linenumber */
+ /* Run down the file looking for the filename, function and linenumber. */
asymbol **p;
const char *directory_name = NULL;
const char *main_file_name = NULL;
*filename_ptr = abfd->filename;
*functionname_ptr = 0;
*line_ptr = 0;
+
if (symbols != (asymbol **)NULL)
{
for (p = symbols; *p; p++)
break;
case N_FUN:
{
- /* We'll keep this if it is nearer than the one we have already */
+ /* We'll keep this if it is nearer than the one we have already. */
if (q->symbol.value >= low_func_vma &&
- q->symbol.value <= offset) {
- low_func_vma = q->symbol.value;
- func = (asymbol *)q;
- }
+ q->symbol.value <= offset)
+ {
+ low_func_vma = q->symbol.value;
+ func = (asymbol *)q;
+ }
else if (q->symbol.value > offset)
goto done;
}
filelen = 0;
else
filelen = strlen (directory_name) + strlen (main_file_name);
+
if (func == NULL)
funclen = 0;
else
if (adata (abfd).line_buf != NULL)
free (adata (abfd).line_buf);
+
if (filelen + funclen == 0)
adata (abfd).line_buf = buf = NULL;
else
buf = (char *) bfd_malloc (filelen + funclen + 3);
adata (abfd).line_buf = buf;
if (buf == NULL)
- return false;
+ return FALSE;
}
if (main_file_name != NULL)
buf[0] = bfd_get_symbol_leading_char (abfd);
strcpy (buf + 1, function);
}
- /* Have to remove : stuff */
+ /* Have to remove : stuff. */
colon = strchr (buf, ':');
if (colon != NULL)
*colon = '\0';
*functionname_ptr = buf;
}
- return true;
+ return TRUE;
}
int
NAME(aout,sizeof_headers) (abfd, execable)
bfd *abfd;
- boolean execable ATTRIBUTE_UNUSED;
+ bfd_boolean execable ATTRIBUTE_UNUSED;
{
return adata (abfd).exec_bytes_size;
}
/* Free all information we have cached for this BFD. We can always
read it again later if we need it. */
-boolean
+bfd_boolean
NAME(aout,bfd_free_cached_info) (abfd)
bfd *abfd;
{
if (bfd_get_format (abfd) != bfd_object
|| abfd->tdata.aout_data == NULL)
- return true;
+ return TRUE;
#define BFCI_FREE(x) if (x != NULL) { free (x); x = NULL; }
BFCI_FREE (obj_aout_symbols (abfd));
BFCI_FREE (o->relocation);
#undef BFCI_FREE
- return true;
+ return TRUE;
}
\f
/* a.out link code. */
-static boolean aout_link_add_object_symbols
+static bfd_boolean aout_link_add_object_symbols
PARAMS ((bfd *, struct bfd_link_info *));
-static boolean aout_link_check_archive_element
- PARAMS ((bfd *, struct bfd_link_info *, boolean *));
-static boolean aout_link_free_symbols PARAMS ((bfd *));
-static boolean aout_link_check_ar_symbols
- PARAMS ((bfd *, struct bfd_link_info *, boolean *pneeded));
-static boolean aout_link_add_symbols
+static bfd_boolean aout_link_check_archive_element
+ PARAMS ((bfd *, struct bfd_link_info *, bfd_boolean *));
+static bfd_boolean aout_link_free_symbols
+ PARAMS ((bfd *));
+static bfd_boolean aout_link_check_ar_symbols
+ PARAMS ((bfd *, struct bfd_link_info *, bfd_boolean *pneeded));
+static bfd_boolean aout_link_add_symbols
PARAMS ((bfd *, struct bfd_link_info *));
/* Routine to create an entry in an a.out link hash table. */
if (ret)
{
/* Set local fields. */
- ret->written = false;
+ ret->written = FALSE;
ret->indx = -1;
}
/* Initialize an a.out link hash table. */
-boolean
+bfd_boolean
NAME(aout,link_hash_table_init) (table, abfd, newfunc)
struct aout_link_hash_table *table;
bfd *abfd;
- struct bfd_hash_entry *(*newfunc) PARAMS ((struct bfd_hash_entry *,
- struct bfd_hash_table *,
- const char *));
+ struct bfd_hash_entry *(*newfunc)
+ PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *,
+ const char *));
{
return _bfd_link_hash_table_init (&table->root, abfd, newfunc);
}
struct aout_link_hash_table *ret;
bfd_size_type amt = sizeof (struct aout_link_hash_table);
- ret = (struct aout_link_hash_table *) bfd_alloc (abfd, amt);
+ ret = (struct aout_link_hash_table *) bfd_malloc (amt);
if (ret == NULL)
return (struct bfd_link_hash_table *) NULL;
+
if (! NAME(aout,link_hash_table_init) (ret, abfd,
NAME(aout,link_hash_newfunc)))
{
/* Given an a.out BFD, add symbols to the global hash table as
appropriate. */
-boolean
+bfd_boolean
NAME(aout,link_add_symbols) (abfd, info)
bfd *abfd;
struct bfd_link_info *info;
(abfd, info, aout_link_check_archive_element);
default:
bfd_set_error (bfd_error_wrong_format);
- return false;
+ return FALSE;
}
}
/* Add symbols from an a.out object file. */
-static boolean
+static bfd_boolean
aout_link_add_object_symbols (abfd, info)
bfd *abfd;
struct bfd_link_info *info;
{
if (! aout_get_external_symbols (abfd))
- return false;
+ return FALSE;
if (! aout_link_add_symbols (abfd, info))
- return false;
+ return FALSE;
if (! info->keep_memory)
{
if (! aout_link_free_symbols (abfd))
- return false;
+ return FALSE;
}
- return true;
+ return TRUE;
}
/* Check a single archive element to see if we need to include it in
needed in the link or not. This is called from
_bfd_generic_link_add_archive_symbols. */
-static boolean
+static bfd_boolean
aout_link_check_archive_element (abfd, info, pneeded)
bfd *abfd;
struct bfd_link_info *info;
- boolean *pneeded;
+ bfd_boolean *pneeded;
{
if (! aout_get_external_symbols (abfd))
- return false;
+ return FALSE;
if (! aout_link_check_ar_symbols (abfd, info, pneeded))
- return false;
+ return FALSE;
if (*pneeded)
{
if (! aout_link_add_symbols (abfd, info))
- return false;
+ return FALSE;
}
if (! info->keep_memory || ! *pneeded)
{
if (! aout_link_free_symbols (abfd))
- return false;
+ return FALSE;
}
- return true;
+ return TRUE;
}
/* Free up the internal symbols read from an a.out file. */
-static boolean
+static bfd_boolean
aout_link_free_symbols (abfd)
bfd *abfd;
{
#endif
obj_aout_external_strings (abfd) = (char *) NULL;
}
- return true;
+ return TRUE;
}
/* Look through the internal symbols to see if this object file should
known symbol but we do not include the object file in the link
(unless there is some other reason to include it). */
-static boolean
+static bfd_boolean
aout_link_check_ar_symbols (abfd, info, pneeded)
bfd *abfd;
struct bfd_link_info *info;
- boolean *pneeded;
+ bfd_boolean *pneeded;
{
register struct external_nlist *p;
struct external_nlist *pend;
char *strings;
- *pneeded = false;
+ *pneeded = FALSE;
/* Look through all the symbols. */
p = obj_aout_external_syms (abfd);
}
name = strings + GET_WORD (abfd, p->e_strx);
- h = bfd_link_hash_lookup (info->hash, name, false, false, true);
+ h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);
/* We are only interested in symbols that are currently
undefined or common. */
{
/* This object file defines this symbol. We must link it
in. This is true regardless of whether the current
- definition of the symbol is undefined or common. If the
- current definition is common, we have a case in which we
- have already seen an object file including
+ definition of the symbol is undefined or common.
+
+ If the current definition is common, we have a case in
+ which we have already seen an object file including:
int a;
- and this object file from the archive includes
+ and this object file from the archive includes:
int a = 5;
- In such a case we must include this object file.
+ In such a case, whether to include this object is target
+ dependant for backward compatibility.
FIXME: The SunOS 4.1.3 linker will pull in the archive
element if the symbol is defined in the .data section,
but not if it is defined in the .text section. That
- seems a bit crazy to me, and I haven't implemented it.
- However, it might be correct. */
+ seems a bit crazy to me, and it has not been implemented
+ yet. However, it might be correct. */
+ if (h->type == bfd_link_hash_common)
+ {
+ int skip = 0;
+
+ switch (info->common_skip_ar_aymbols)
+ {
+ case bfd_link_common_skip_text:
+ skip = (type == (N_TEXT | N_EXT));
+ break;
+ case bfd_link_common_skip_data:
+ skip = (type == (N_DATA | N_EXT));
+ break;
+ default:
+ case bfd_link_common_skip_all:
+ skip = 1;
+ break;
+ }
+
+ if (skip)
+ continue;
+ }
+
if (! (*info->callbacks->add_archive_element) (info, abfd, name))
- return false;
- *pneeded = true;
- return true;
+ return FALSE;
+ *pneeded = TRUE;
+ return TRUE;
}
if (type == (N_UNDF | N_EXT))
if (! (*info->callbacks->add_archive_element) (info,
abfd,
name))
- return false;
- *pneeded = true;
- return true;
+ return FALSE;
+ *pneeded = TRUE;
+ return TRUE;
}
/* Turn the current link symbol into a common
symbol. It is already on the undefs list. */
bfd_hash_allocate (&info->hash->table,
sizeof (struct bfd_link_hash_common_entry)));
if (h->u.c.p == NULL)
- return false;
+ return FALSE;
h->u.c.size = value;
if (h->type == bfd_link_hash_undefined)
{
if (! (*info->callbacks->add_archive_element) (info, abfd, name))
- return false;
- *pneeded = true;
- return true;
+ return FALSE;
+ *pneeded = TRUE;
+ return TRUE;
}
}
}
/* We do not need this object file. */
- return true;
+ return TRUE;
}
/* Add all symbols from an object file to the hash table. */
-static boolean
+static bfd_boolean
aout_link_add_symbols (abfd, info)
bfd *abfd;
struct bfd_link_info *info;
{
- boolean (*add_one_symbol) PARAMS ((struct bfd_link_info *, bfd *,
- const char *, flagword, asection *,
- bfd_vma, const char *, boolean,
- boolean,
- struct bfd_link_hash_entry **));
+ bfd_boolean (*add_one_symbol)
+ PARAMS ((struct bfd_link_info *, bfd *, const char *, flagword, asection *,
+ bfd_vma, const char *, bfd_boolean, bfd_boolean,
+ struct bfd_link_hash_entry **));
struct external_nlist *syms;
bfd_size_type sym_count;
char *strings;
- boolean copy;
+ bfd_boolean copy;
struct aout_link_hash_entry **sym_hash;
register struct external_nlist *p;
struct external_nlist *pend;
sym_count = obj_aout_external_sym_count (abfd);
strings = obj_aout_external_strings (abfd);
if (info->keep_memory)
- copy = false;
+ copy = FALSE;
else
- copy = true;
+ copy = TRUE;
if (aout_backend_info (abfd)->add_dynamic_symbols != NULL)
{
if (! ((*aout_backend_info (abfd)->add_dynamic_symbols)
(abfd, info, &syms, &sym_count, &strings)))
- return false;
+ return FALSE;
}
/* We keep a list of the linker hash table entries that correspond
amt = sym_count * sizeof (struct aout_link_hash_entry *);
sym_hash = (struct aout_link_hash_entry **) bfd_alloc (abfd, amt);
if (sym_hash == NULL && sym_count != 0)
- return false;
+ return FALSE;
obj_aout_sym_hashes (abfd) = sym_hash;
add_one_symbol = aout_backend_info (abfd)->add_one_symbol;
}
if (! ((*add_one_symbol)
- (info, abfd, name, flags, section, value, string, copy, false,
+ (info, abfd, name, flags, section, value, string, copy, FALSE,
(struct bfd_link_hash_entry **) sym_hash)))
- return false;
+ return FALSE;
/* Restrict the maximum alignment of a common symbol based on
the architecture, since a.out has no way to represent
++sym_hash;
}
- return true;
+ return TRUE;
}
\f
/* A hash table used for header files with N_BINCL entries. */
static struct bfd_hash_entry *aout_link_includes_newfunc
PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
-static boolean aout_link_input_bfd
+static bfd_boolean aout_link_input_bfd
PARAMS ((struct aout_final_link_info *, bfd *input_bfd));
-static boolean aout_link_write_symbols
+static bfd_boolean aout_link_write_symbols
PARAMS ((struct aout_final_link_info *, bfd *input_bfd));
-static boolean aout_link_write_other_symbol
+static bfd_boolean aout_link_write_other_symbol
PARAMS ((struct aout_link_hash_entry *, PTR));
-static boolean aout_link_input_section
+static bfd_boolean aout_link_input_section
PARAMS ((struct aout_final_link_info *, bfd *input_bfd,
asection *input_section, file_ptr *reloff_ptr,
bfd_size_type rel_size));
-static boolean aout_link_input_section_std
+static bfd_boolean aout_link_input_section_std
PARAMS ((struct aout_final_link_info *, bfd *input_bfd,
asection *input_section, struct reloc_std_external *,
bfd_size_type rel_size, bfd_byte *contents));
-static boolean aout_link_input_section_ext
+static bfd_boolean aout_link_input_section_ext
PARAMS ((struct aout_final_link_info *, bfd *input_bfd,
asection *input_section, struct reloc_ext_external *,
bfd_size_type rel_size, bfd_byte *contents));
static INLINE asection *aout_reloc_index_to_section
PARAMS ((bfd *, int));
-static boolean aout_link_reloc_link_order
+static bfd_boolean aout_link_reloc_link_order
PARAMS ((struct aout_final_link_info *, asection *,
struct bfd_link_order *));
of bfd_link_order structures which list all the input sections for
the output section. */
-boolean
+bfd_boolean
NAME(aout,final_link) (abfd, info, callback)
bfd *abfd;
struct bfd_link_info *info;
void (*callback) PARAMS ((bfd *, file_ptr *, file_ptr *, file_ptr *));
{
struct aout_final_link_info aout_info;
- boolean includes_hash_initialized = false;
+ bfd_boolean includes_hash_initialized = FALSE;
register bfd *sub;
bfd_size_type trsize, drsize;
bfd_size_type max_contents_size;
file_ptr text_end;
register struct bfd_link_order *p;
asection *o;
- boolean have_link_order_relocs;
+ bfd_boolean have_link_order_relocs;
if (info->shared)
abfd->flags |= DYNAMIC;
aout_link_includes_newfunc,
251))
goto error_return;
- includes_hash_initialized = true;
+ includes_hash_initialized = TRUE;
/* Figure out the largest section size. Also, if generating
- relocateable output, count the relocs. */
+ relocatable output, count the relocs. */
trsize = 0;
drsize = 0;
max_contents_size = 0;
{
bfd_size_type sz;
- if (info->relocateable)
+ if (info->relocatable)
{
if (bfd_get_flavour (sub) == bfd_target_aout_flavour)
{
work out the number of relocs needed, and then multiply
by the reloc size. */
(*_bfd_error_handler)
- (_("%s: relocateable link from %s to %s not supported"),
+ (_("%s: relocatable link from %s to %s not supported"),
bfd_get_filename (abfd),
sub->xvec->name, abfd->xvec->name);
bfd_set_error (bfd_error_invalid_operation);
if (bfd_get_flavour (sub) == bfd_target_aout_flavour)
{
- sz = bfd_section_size (sub, obj_textsec (sub));
+ sz = obj_textsec (sub)->size;
if (sz > max_contents_size)
max_contents_size = sz;
- sz = bfd_section_size (sub, obj_datasec (sub));
+ sz = obj_datasec (sub)->size;
if (sz > max_contents_size)
max_contents_size = sz;
}
}
- if (info->relocateable)
+ if (info->relocatable)
{
if (obj_textsec (abfd) != (asection *) NULL)
trsize += (_bfd_count_link_order_relocs (obj_textsec (abfd)
struct aout_link_hash_entry *h;
h = aout_link_hash_lookup (aout_hash_table (info), "__DYNAMIC",
- false, false, false);
+ FALSE, FALSE, FALSE);
if (h != NULL)
aout_link_write_other_symbol (h, &aout_info);
}
We use the output_has_begun field of the input BFDs to see
whether we have already handled it. */
for (sub = info->input_bfds; sub != (bfd *) NULL; sub = sub->link_next)
- sub->output_has_begun = false;
+ sub->output_has_begun = FALSE;
/* Mark all sections which are to be included in the link. This
will normally be every section. We need to do this so that we
for (o = abfd->sections; o != NULL; o = o->next)
{
for (p = o->link_order_head; p != NULL; p = p->next)
- {
- if (p->type == bfd_indirect_link_order)
- p->u.indirect.section->linker_mark = true;
- }
+ if (p->type == bfd_indirect_link_order)
+ p->u.indirect.section->linker_mark = TRUE;
}
- have_link_order_relocs = false;
+ have_link_order_relocs = FALSE;
for (o = abfd->sections; o != (asection *) NULL; o = o->next)
{
for (p = o->link_order_head;
{
if (! aout_link_input_bfd (&aout_info, input_bfd))
goto error_return;
- input_bfd->output_has_begun = true;
+ input_bfd->output_has_begun = TRUE;
}
}
else if (p->type == bfd_section_reloc_link_order
|| p->type == bfd_symbol_reloc_link_order)
{
/* These are handled below. */
- have_link_order_relocs = true;
+ have_link_order_relocs = TRUE;
}
else
{
if (includes_hash_initialized)
{
bfd_hash_table_free (&aout_info.includes.root);
- includes_hash_initialized = false;
+ includes_hash_initialized = FALSE;
}
/* Finish up any dynamic linking we may be doing. */
goto error_return;
}
- return true;
+ return TRUE;
error_return:
if (aout_info.contents != NULL)
free (aout_info.output_syms);
if (includes_hash_initialized)
bfd_hash_table_free (&aout_info.includes.root);
- return false;
+ return FALSE;
}
/* Link an a.out input BFD into the output file. */
-static boolean
+static bfd_boolean
aout_link_input_bfd (finfo, input_bfd)
struct aout_final_link_info *finfo;
bfd *input_bfd;
}
/* Get the symbols. We probably have them already, unless
- finfo->info->keep_memory is false. */
+ finfo->info->keep_memory is FALSE. */
if (! aout_get_external_symbols (input_bfd))
- return false;
+ return FALSE;
sym_count = obj_aout_external_sym_count (input_bfd);
/* Write out the symbols and get a map of the new indices. The map
is placed into finfo->symbol_map. */
if (! aout_link_write_symbols (finfo, input_bfd))
- return false;
+ return FALSE;
/* Relocate and write out the sections. These functions use the
symbol map created by aout_link_write_symbols. The linker_mark
obj_textsec (input_bfd),
&finfo->treloff,
exec_hdr (input_bfd)->a_trsize))
- return false;
+ return FALSE;
}
if (obj_datasec (input_bfd)->linker_mark)
{
obj_datasec (input_bfd),
&finfo->dreloff,
exec_hdr (input_bfd)->a_drsize))
- return false;
+ return FALSE;
}
/* If we are not keeping memory, we don't need the symbols any
if (! finfo->info->keep_memory)
{
if (! aout_link_free_symbols (input_bfd))
- return false;
+ return FALSE;
}
- return true;
+ return TRUE;
}
/* Adjust and write out the symbols for an a.out file. Set the new
symbol indices into a symbol_map. */
-static boolean
+static bfd_boolean
aout_link_write_symbols (finfo, input_bfd)
struct aout_final_link_info *finfo;
bfd *input_bfd;
struct external_nlist *sym_end;
struct aout_link_hash_entry **sym_hash;
int *symbol_map;
- boolean pass;
- boolean skip_next;
+ bfd_boolean pass;
+ bfd_boolean skip_next;
output_bfd = finfo->output_bfd;
sym_count = obj_aout_external_sym_count (input_bfd);
if (strip != strip_all
&& (strip != strip_some
|| bfd_hash_lookup (finfo->info->keep_hash, input_bfd->filename,
- false, false) != NULL)
+ FALSE, FALSE) != NULL)
&& discard != discard_all)
{
H_PUT_8 (output_bfd, N_TEXT, outsym->e_type);
H_PUT_8 (output_bfd, 0, outsym->e_other);
H_PUT_16 (output_bfd, 0, outsym->e_desc);
strtab_index = add_to_stringtab (output_bfd, finfo->strtab,
- input_bfd->filename, false);
+ input_bfd->filename, FALSE);
if (strtab_index == (bfd_size_type) -1)
- return false;
+ return FALSE;
PUT_WORD (output_bfd, strtab_index, outsym->e_strx);
PUT_WORD (output_bfd,
(bfd_get_section_vma (output_bfd,
++outsym;
}
- pass = false;
- skip_next = false;
+ pass = FALSE;
+ skip_next = FALSE;
sym = obj_aout_external_syms (input_bfd);
sym_end = sym + sym_count;
sym_hash = obj_aout_sym_hashes (input_bfd);
const char *name;
int type;
struct aout_link_hash_entry *h;
- boolean skip;
+ bfd_boolean skip;
asection *symsec;
bfd_vma val = 0;
- boolean copy;
+ bfd_boolean copy;
/* We set *symbol_map to 0 above for all symbols. If it has
already been set to -1 for this symbol, it means that we are
/* Pass this symbol through. It is the target of an
indirect or warning symbol. */
val = GET_WORD (input_bfd, sym->e_value);
- pass = false;
+ pass = FALSE;
}
else if (skip_next)
{
/* Skip this symbol, which is the target of an indirect
symbol that we have changed to no longer be an indirect
symbol. */
- skip_next = false;
+ skip_next = FALSE;
continue;
}
else
/* Use the name from the hash table, in case the symbol was
wrapped. */
- if (h != NULL)
+ if (h != NULL
+ && h->root.type != bfd_link_hash_warning)
name = h->root.root.string;
/* If this is an indirect or warning symbol, then change
/* If the symbol has already been written out, skip it. */
if (h != (struct aout_link_hash_entry *) NULL
- && h->root.type != bfd_link_hash_warning
&& h->written)
{
if ((type & N_TYPE) == N_INDR
|| type == N_WARNING)
- skip_next = true;
+ skip_next = TRUE;
*symbol_map = h->indx;
continue;
}
/* See if we are stripping this symbol. */
- skip = false;
+ skip = FALSE;
switch (strip)
{
case strip_none:
break;
case strip_debugger:
if ((type & N_STAB) != 0)
- skip = true;
+ skip = TRUE;
break;
case strip_some:
- if (bfd_hash_lookup (finfo->info->keep_hash, name, false, false)
+ if (bfd_hash_lookup (finfo->info->keep_hash, name, FALSE, FALSE)
== NULL)
- skip = true;
+ skip = TRUE;
break;
case strip_all:
- skip = true;
+ skip = TRUE;
break;
}
if (skip)
{
if (h != (struct aout_link_hash_entry *) NULL)
- h->written = true;
+ h->written = TRUE;
continue;
}
the indirect symbol was defined, we output it with
the correct definition so the debugger will
understand it. */
- pass = true;
+ pass = TRUE;
val = GET_WORD (input_bfd, sym->e_value);
symsec = NULL;
}
a case we do not want to output the next symbol,
which is the target of the indirection. */
if ((type & N_TYPE) == N_INDR)
- skip_next = true;
+ skip_next = TRUE;
symsec = NULL;
it is a local symbol see if we should discard it. */
if (h != (struct aout_link_hash_entry *) NULL)
{
- h->written = true;
+ h->written = TRUE;
h->indx = obj_aout_external_sym_count (output_bfd);
}
else if ((type & N_TYPE) != N_SETT
case discard_l:
if ((type & N_STAB) == 0
&& bfd_is_local_label_name (input_bfd, name))
- skip = true;
+ skip = TRUE;
break;
case discard_all:
- skip = true;
+ skip = TRUE;
break;
}
if (skip)
{
- pass = false;
+ pass = FALSE;
continue;
}
}
characters in the symbol names, not including the file
numbers in types (the first number after an open
parenthesis). */
- if (type == N_BINCL)
+ if (type == (int) N_BINCL)
{
struct external_nlist *incl_sym;
int nest;
int incl_type;
incl_type = H_GET_8 (input_bfd, incl_sym->e_type);
- if (incl_type == N_EINCL)
+ if (incl_type == (int) N_EINCL)
{
if (nest == 0)
break;
--nest;
}
- else if (incl_type == N_BINCL)
+ else if (incl_type == (int) N_BINCL)
++nest;
else if (nest == 0)
{
/* If we have already included a header file with the
same value, then replace this one with an N_EXCL
symbol. */
- copy = ! finfo->info->keep_memory;
+ copy = (bfd_boolean) (! finfo->info->keep_memory);
incl_entry = aout_link_includes_lookup (&finfo->includes,
- name, true, copy);
+ name, TRUE, copy);
if (incl_entry == NULL)
- return false;
+ return FALSE;
for (t = incl_entry->totals; t != NULL; t = t->next)
if (t->total == val)
break;
bfd_hash_allocate (&finfo->includes.root,
sizeof *t));
if (t == NULL)
- return false;
+ return FALSE;
t->total = val;
t->next = incl_entry->totals;
incl_entry->totals = t;
/* This is a duplicate header file. We must change
it to be an N_EXCL entry, and mark all the
included symbols to prevent outputting them. */
- type = N_EXCL;
+ type = (int) N_EXCL;
nest = 0;
for (incl_sym = sym + 1, incl_map = symbol_map + 1;
int incl_type;
incl_type = H_GET_8 (input_bfd, incl_sym->e_type);
- if (incl_type == N_EINCL)
+ if (incl_type == (int) N_EINCL)
{
if (nest == 0)
{
}
--nest;
}
- else if (incl_type == N_BINCL)
+ else if (incl_type == (int) N_BINCL)
++nest;
else if (nest == 0)
*incl_map = -1;
H_PUT_8 (output_bfd, type, outsym->e_type);
H_PUT_8 (output_bfd, H_GET_8 (input_bfd, sym->e_other), outsym->e_other);
H_PUT_16 (output_bfd, H_GET_16 (input_bfd, sym->e_desc), outsym->e_desc);
- copy = false;
+ copy = FALSE;
if (! finfo->info->keep_memory)
{
/* name points into a string table which we are going to
if (h != (struct aout_link_hash_entry *) NULL)
name = h->root.root.string;
else
- copy = true;
+ copy = TRUE;
}
strtab_index = add_to_stringtab (output_bfd, finfo->strtab,
name, copy);
if (strtab_index == (bfd_size_type) -1)
- return false;
+ return FALSE;
PUT_WORD (output_bfd, strtab_index, outsym->e_strx);
PUT_WORD (output_bfd, val, outsym->e_value);
*symbol_map = obj_aout_external_sym_count (output_bfd);
bfd_size_type outsym_size;
if (bfd_seek (output_bfd, finfo->symoff, SEEK_SET) != 0)
- return false;
+ return FALSE;
outsym_size = outsym - finfo->output_syms;
outsym_size *= EXTERNAL_NLIST_SIZE;
if (bfd_bwrite ((PTR) finfo->output_syms, outsym_size, output_bfd)
!= outsym_size)
- return false;
+ return FALSE;
finfo->symoff += outsym_size;
}
- return true;
+ return TRUE;
}
/* Write out a symbol that was not associated with an a.out input
object. */
-static boolean
+static bfd_boolean
aout_link_write_other_symbol (h, data)
struct aout_link_hash_entry *h;
PTR data;
bfd_size_type indx;
bfd_size_type amt;
+ if (h->root.type == bfd_link_hash_warning)
+ {
+ h = (struct aout_link_hash_entry *) h->root.u.i.link;
+ if (h->root.type == bfd_link_hash_new)
+ return TRUE;
+ }
+
output_bfd = finfo->output_bfd;
if (aout_backend_info (output_bfd)->write_dynamic_symbol != NULL)
}
if (h->written)
- return true;
+ return TRUE;
- h->written = true;
+ h->written = TRUE;
/* An indx of -2 means the symbol must be written. */
if (h->indx != -2
&& (finfo->info->strip == strip_all
|| (finfo->info->strip == strip_some
&& bfd_hash_lookup (finfo->info->keep_hash, h->root.root.string,
- false, false) == NULL)))
- return true;
+ FALSE, FALSE) == NULL)))
+ return TRUE;
switch (h->root.type)
{
default:
+ case bfd_link_hash_warning:
abort ();
/* Avoid variable not initialized warnings. */
- return true;
+ return TRUE;
case bfd_link_hash_new:
/* This can happen for set symbols when sets are not being
built. */
- return true;
+ return TRUE;
case bfd_link_hash_undefined:
type = N_UNDF | N_EXT;
val = 0;
type = N_WEAKU;
val = 0;
case bfd_link_hash_indirect:
- case bfd_link_hash_warning:
- /* FIXME: Ignore these for now. The circumstances under which
- they should be written out are not clear to me. */
- return true;
+ /* We ignore these symbols, since the indirected symbol is
+ already in the hash table. */
+ return TRUE;
}
H_PUT_8 (output_bfd, type, outsym.e_type);
H_PUT_8 (output_bfd, 0, outsym.e_other);
H_PUT_16 (output_bfd, 0, outsym.e_desc);
indx = add_to_stringtab (output_bfd, finfo->strtab, h->root.root.string,
- false);
+ FALSE);
if (indx == - (bfd_size_type) 1)
{
/* FIXME: No way to handle errors. */
h->indx = obj_aout_external_sym_count (output_bfd);
++obj_aout_external_sym_count (output_bfd);
- return true;
+ return TRUE;
}
/* Link an a.out section into the output file. */
-static boolean
+static bfd_boolean
aout_link_input_section (finfo, input_bfd, input_section, reloff_ptr,
rel_size)
struct aout_final_link_info *finfo;
PTR relocs;
/* Get the section contents. */
- input_size = bfd_section_size (input_bfd, input_section);
+ input_size = input_section->size;
if (! bfd_get_section_contents (input_bfd, input_section,
(PTR) finfo->contents,
(file_ptr) 0, input_size))
- return false;
+ return FALSE;
/* Read in the relocs if we haven't already done it. */
if (aout_section_data (input_section) != NULL
{
if (bfd_seek (input_bfd, input_section->rel_filepos, SEEK_SET) != 0
|| bfd_bread (relocs, rel_size, input_bfd) != rel_size)
- return false;
+ return FALSE;
}
}
if (! aout_link_input_section_std (finfo, input_bfd, input_section,
(struct reloc_std_external *) relocs,
rel_size, finfo->contents))
- return false;
+ return FALSE;
}
else
{
if (! aout_link_input_section_ext (finfo, input_bfd, input_section,
(struct reloc_ext_external *) relocs,
rel_size, finfo->contents))
- return false;
+ return FALSE;
}
/* Write out the section contents. */
(PTR) finfo->contents,
(file_ptr) input_section->output_offset,
input_size))
- return false;
+ return FALSE;
- /* If we are producing relocateable output, the relocs were
+ /* If we are producing relocatable output, the relocs were
modified, and we now write them out. */
- if (finfo->info->relocateable && rel_size > 0)
+ if (finfo->info->relocatable && rel_size > 0)
{
if (bfd_seek (finfo->output_bfd, *reloff_ptr, SEEK_SET) != 0)
- return false;
+ return FALSE;
if (bfd_bwrite (relocs, rel_size, finfo->output_bfd) != rel_size)
- return false;
+ return FALSE;
*reloff_ptr += rel_size;
/* Assert that the relocs have not run into the symbols, and
<= obj_datasec (finfo->output_bfd)->rel_filepos)));
}
- return true;
+ return TRUE;
}
/* Get the section corresponding to a reloc index. */
/* Relocate an a.out section using standard a.out relocs. */
-static boolean
+static bfd_boolean
aout_link_input_section_std (finfo, input_bfd, input_section, relocs,
rel_size, contents)
struct aout_final_link_info *finfo;
bfd_size_type rel_size;
bfd_byte *contents;
{
- boolean (*check_dynamic_reloc) PARAMS ((struct bfd_link_info *,
- bfd *, asection *,
- struct aout_link_hash_entry *,
- PTR, bfd_byte *, boolean *,
- bfd_vma *));
+ bfd_boolean (*check_dynamic_reloc)
+ PARAMS ((struct bfd_link_info *, bfd *, asection *,
+ struct aout_link_hash_entry *, PTR, bfd_byte *, bfd_boolean *,
+ bfd_vma *));
bfd *output_bfd;
- boolean relocateable;
+ bfd_boolean relocatable;
struct external_nlist *syms;
char *strings;
struct aout_link_hash_entry **sym_hashes;
BFD_ASSERT (input_bfd->xvec->header_byteorder
== output_bfd->xvec->header_byteorder);
- relocateable = finfo->info->relocateable;
+ relocatable = finfo->info->relocatable;
syms = obj_aout_external_syms (input_bfd);
strings = obj_aout_external_strings (input_bfd);
sym_hashes = obj_aout_sym_hashes (input_bfd);
if (bfd_header_big_endian (input_bfd))
{
- r_index = ((rel->r_index[0] << 16)
- | (rel->r_index[1] << 8)
+ r_index = (((unsigned int) rel->r_index[0] << 16)
+ | ((unsigned int) rel->r_index[1] << 8)
| rel->r_index[2]);
r_extern = (0 != (rel->r_type[0] & RELOC_STD_BITS_EXTERN_BIG));
r_pcrel = (0 != (rel->r_type[0] & RELOC_STD_BITS_PCREL_BIG));
}
else
{
- r_index = ((rel->r_index[2] << 16)
- | (rel->r_index[1] << 8)
+ r_index = (((unsigned int) rel->r_index[2] << 16)
+ | ((unsigned int) rel->r_index[1] << 8)
| rel->r_index[0]);
r_extern = (0 != (rel->r_type[0] & RELOC_STD_BITS_EXTERN_LITTLE));
r_pcrel = (0 != (rel->r_type[0] & RELOC_STD_BITS_PCREL_LITTLE));
}
#endif
- if (relocateable)
+ if (relocatable)
{
- /* We are generating a relocateable output file, and must
+ /* We are generating a relocatable output file, and must
modify the reloc accordingly. */
if (r_extern)
{
if (h->indx < 0)
{
h->indx = -2;
- h->written = false;
+ h->written = FALSE;
if (! aout_link_write_other_symbol (h,
(PTR) finfo))
- return false;
+ return FALSE;
}
r_index = h->indx;
}
if (! ((*finfo->info->callbacks->unattached_reloc)
(finfo->info, name, input_bfd, input_section,
r_addr)))
- return false;
+ return FALSE;
r_index = 0;
}
}
}
else
{
- boolean hundef;
+ bfd_boolean hundef;
/* We are generating an executable, and must do a full
relocation. */
- hundef = false;
+ hundef = FALSE;
if (r_extern)
{
relocation = 0;
else
{
- hundef = true;
+ hundef = TRUE;
relocation = 0;
}
}
if (check_dynamic_reloc != NULL)
{
- boolean skip;
+ bfd_boolean skip;
if (! ((*check_dynamic_reloc)
(finfo->info, input_bfd, input_section, h,
(PTR) rel, contents, &skip, &relocation)))
- return false;
+ return FALSE;
if (skip)
continue;
}
name = strings + GET_WORD (input_bfd, syms[r_index].e_strx);
if (! ((*finfo->info->callbacks->undefined_symbol)
(finfo->info, name, input_bfd, input_section,
- r_addr, true)))
- return false;
+ r_addr, TRUE)))
+ return FALSE;
}
r = MY_final_link_relocate (howto,
const char *name;
if (h != NULL)
- name = h->root.root.string;
+ name = NULL;
else if (r_extern)
name = strings + GET_WORD (input_bfd,
syms[r_index].e_strx);
name = bfd_section_name (input_bfd, s);
}
if (! ((*finfo->info->callbacks->reloc_overflow)
- (finfo->info, name, howto->name,
- (bfd_vma) 0, input_bfd, input_section, r_addr)))
- return false;
+ (finfo->info, (h ? &h->root : NULL), name,
+ howto->name, (bfd_vma) 0, input_bfd,
+ input_section, r_addr)))
+ return FALSE;
}
break;
}
}
}
- return true;
+ return TRUE;
}
/* Relocate an a.out section using extended a.out relocs. */
-static boolean
+static bfd_boolean
aout_link_input_section_ext (finfo, input_bfd, input_section, relocs,
rel_size, contents)
struct aout_final_link_info *finfo;
bfd_size_type rel_size;
bfd_byte *contents;
{
- boolean (*check_dynamic_reloc) PARAMS ((struct bfd_link_info *,
- bfd *, asection *,
- struct aout_link_hash_entry *,
- PTR, bfd_byte *, boolean *,
- bfd_vma *));
+ bfd_boolean (*check_dynamic_reloc)
+ PARAMS ((struct bfd_link_info *, bfd *, asection *,
+ struct aout_link_hash_entry *, PTR, bfd_byte *, bfd_boolean *,
+ bfd_vma *));
bfd *output_bfd;
- boolean relocateable;
+ bfd_boolean relocatable;
struct external_nlist *syms;
char *strings;
struct aout_link_hash_entry **sym_hashes;
BFD_ASSERT (input_bfd->xvec->header_byteorder
== output_bfd->xvec->header_byteorder);
- relocateable = finfo->info->relocateable;
+ relocatable = finfo->info->relocatable;
syms = obj_aout_external_syms (input_bfd);
strings = obj_aout_external_strings (input_bfd);
sym_hashes = obj_aout_sym_hashes (input_bfd);
if (bfd_header_big_endian (input_bfd))
{
- r_index = ((rel->r_index[0] << 16)
- | (rel->r_index[1] << 8)
+ r_index = (((unsigned int) rel->r_index[0] << 16)
+ | ((unsigned int) rel->r_index[1] << 8)
| rel->r_index[2]);
r_extern = (0 != (rel->r_type[0] & RELOC_EXT_BITS_EXTERN_BIG));
r_type = ((rel->r_type[0] & RELOC_EXT_BITS_TYPE_BIG)
}
else
{
- r_index = ((rel->r_index[2] << 16)
- | (rel->r_index[1] << 8)
+ r_index = (((unsigned int) rel->r_index[2] << 16)
+ | ((unsigned int) rel->r_index[1] << 8)
| rel->r_index[0]);
r_extern = (0 != (rel->r_type[0] & RELOC_EXT_BITS_EXTERN_LITTLE));
r_type = ((rel->r_type[0] & RELOC_EXT_BITS_TYPE_LITTLE)
BFD_ASSERT (r_type < TABLE_SIZE (howto_table_ext));
- if (relocateable)
+ if (relocatable)
{
- /* We are generating a relocateable output file, and must
+ /* We are generating a relocatable output file, and must
modify the reloc accordingly. */
if (r_extern
- || r_type == RELOC_BASE10
- || r_type == RELOC_BASE13
- || r_type == RELOC_BASE22)
+ || r_type == (unsigned int) RELOC_BASE10
+ || r_type == (unsigned int) RELOC_BASE13
+ || r_type == (unsigned int) RELOC_BASE22)
{
/* If we know the symbol this relocation is against,
convert it into a relocation against a section. This
is what the native linker does. */
- if (r_type == RELOC_BASE10
- || r_type == RELOC_BASE13
- || r_type == RELOC_BASE22)
+ if (r_type == (unsigned int) RELOC_BASE10
+ || r_type == (unsigned int) RELOC_BASE13
+ || r_type == (unsigned int) RELOC_BASE22)
h = NULL;
else
h = sym_hashes[r_index];
if (h->indx < 0)
{
h->indx = -2;
- h->written = false;
+ h->written = FALSE;
if (! aout_link_write_other_symbol (h,
(PTR) finfo))
- return false;
+ return FALSE;
}
r_index = h->indx;
}
if (! ((*finfo->info->callbacks->unattached_reloc)
(finfo->info, name, input_bfd, input_section,
r_addr)))
- return false;
+ return FALSE;
r_index = 0;
}
}
}
else
{
- boolean hundef;
+ bfd_boolean hundef;
bfd_reloc_status_type r;
/* We are generating an executable, and must do a full
relocation. */
- hundef = false;
+ hundef = FALSE;
if (r_extern)
{
relocation = 0;
else
{
- hundef = true;
+ hundef = TRUE;
relocation = 0;
}
}
- else if (r_type == RELOC_BASE10
- || r_type == RELOC_BASE13
- || r_type == RELOC_BASE22)
+ else if (r_type == (unsigned int) RELOC_BASE10
+ || r_type == (unsigned int) RELOC_BASE13
+ || r_type == (unsigned int) RELOC_BASE22)
{
struct external_nlist *sym;
int type;
if (check_dynamic_reloc != NULL)
{
- boolean skip;
+ bfd_boolean skip;
if (! ((*check_dynamic_reloc)
(finfo->info, input_bfd, input_section, h,
(PTR) rel, contents, &skip, &relocation)))
- return false;
+ return FALSE;
if (skip)
continue;
}
to skip this reloc. */
if (hundef
&& ! finfo->info->shared
- && r_type != RELOC_BASE10
- && r_type != RELOC_BASE13
- && r_type != RELOC_BASE22)
+ && r_type != (unsigned int) RELOC_BASE10
+ && r_type != (unsigned int) RELOC_BASE13
+ && r_type != (unsigned int) RELOC_BASE22)
{
const char *name;
name = strings + GET_WORD (input_bfd, syms[r_index].e_strx);
if (! ((*finfo->info->callbacks->undefined_symbol)
(finfo->info, name, input_bfd, input_section,
- r_addr, true)))
- return false;
+ r_addr, TRUE)))
+ return FALSE;
}
- if (r_type != RELOC_SPARC_REV32)
+ if (r_type != (unsigned int) RELOC_SPARC_REV32)
r = MY_final_link_relocate (howto_table_ext + r_type,
input_bfd, input_section,
contents, r_addr, relocation,
const char *name;
if (h != NULL)
- name = h->root.root.string;
+ name = NULL;
else if (r_extern
- || r_type == RELOC_BASE10
- || r_type == RELOC_BASE13
- || r_type == RELOC_BASE22)
+ || r_type == (unsigned int) RELOC_BASE10
+ || r_type == (unsigned int) RELOC_BASE13
+ || r_type == (unsigned int) RELOC_BASE22)
name = strings + GET_WORD (input_bfd,
syms[r_index].e_strx);
else
name = bfd_section_name (input_bfd, s);
}
if (! ((*finfo->info->callbacks->reloc_overflow)
- (finfo->info, name, howto_table_ext[r_type].name,
+ (finfo->info, (h ? &h->root : NULL), name,
+ howto_table_ext[r_type].name,
r_addend, input_bfd, input_section, r_addr)))
- return false;
+ return FALSE;
}
break;
}
}
}
- return true;
+ return TRUE;
}
/* Handle a link order which is supposed to generate a reloc. */
-static boolean
+static bfd_boolean
aout_link_reloc_link_order (finfo, o, p)
struct aout_final_link_info *finfo;
asection *o;
r_extern = 1;
h = ((struct aout_link_hash_entry *)
bfd_wrapped_link_hash_lookup (finfo->output_bfd, finfo->info,
- pr->u.name, false, false, true));
+ pr->u.name, FALSE, FALSE, TRUE));
if (h != (struct aout_link_hash_entry *) NULL
&& h->indx >= 0)
r_index = h->indx;
here. I don't think that will ever matter for a global
symbol. */
h->indx = -2;
- h->written = false;
+ h->written = FALSE;
if (! aout_link_write_other_symbol (h, (PTR) finfo))
- return false;
+ return FALSE;
r_index = h->indx;
}
else
if (! ((*finfo->info->callbacks->unattached_reloc)
(finfo->info, pr->u.name, (bfd *) NULL,
(asection *) NULL, (bfd_vma) 0)))
- return false;
+ return FALSE;
r_index = 0;
}
}
if (howto == 0)
{
bfd_set_error (bfd_error_bad_value);
- return false;
+ return FALSE;
}
if (o == obj_textsec (finfo->output_bfd))
int r_relative;
int r_length;
- r_pcrel = howto->pc_relative;
+ r_pcrel = (int) howto->pc_relative;
r_baserel = (howto->type & 8) != 0;
r_jmptable = (howto->type & 16) != 0;
r_relative = (howto->type & 32) != 0;
bfd_size_type size;
bfd_reloc_status_type r;
bfd_byte *buf;
- boolean ok;
+ bfd_boolean ok;
size = bfd_get_reloc_size (howto);
buf = (bfd_byte *) bfd_zmalloc (size);
if (buf == (bfd_byte *) NULL)
- return false;
+ return FALSE;
r = MY_relocate_contents (howto, finfo->output_bfd,
(bfd_vma) pr->addend, buf);
switch (r)
abort ();
case bfd_reloc_overflow:
if (! ((*finfo->info->callbacks->reloc_overflow)
- (finfo->info,
+ (finfo->info, NULL,
(p->type == bfd_section_reloc_link_order
? bfd_section_name (finfo->output_bfd,
pr->u.section)
(asection *) NULL, (bfd_vma) 0)))
{
free (buf);
- return false;
+ return FALSE;
}
break;
}
(file_ptr) p->offset, size);
free (buf);
if (! ok)
- return false;
+ return FALSE;
}
}
else
amt = obj_reloc_entry_size (finfo->output_bfd);
if (bfd_seek (finfo->output_bfd, *reloff_ptr, SEEK_SET) != 0
|| bfd_bwrite (rel_ptr, amt, finfo->output_bfd) != amt)
- return false;
+ return FALSE;
*reloff_ptr += obj_reloc_entry_size (finfo->output_bfd);
|| (*reloff_ptr
<= obj_datasec (finfo->output_bfd)->rel_filepos)));
- return true;
+ return TRUE;
}