/* BFD back-end for PDP-11 a.out binaries.
- Copyright 2001 Free Software Foundation, Inc.
+ Copyright 2001, 2002 Free Software Foundation, Inc.
This file is part of BFD, the Binary File Descriptor library.
#define MY_entry_is_text_address 1
#define MY_write_object_contents MY(write_object_contents)
-static boolean MY(write_object_contents) PARAMS ((bfd *abfd));
+static bfd_boolean MY(write_object_contents) PARAMS ((bfd *abfd));
#define MY_text_includes_header 1
bfd_vma bfd_getp32 PARAMS ((const bfd_byte *));
#define RINDEX(x) (((x) & 0xfff0) >> 4)
-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 *));
reloc_howto_type howto_table_pdp11[] =
{
/* type rs size bsz pcrel bitpos ovrf sf name part_inpl readmask setmask pcdone */
-HOWTO( 0, 0, 1, 16, false, 0, complain_overflow_signed,0,"16", true, 0x0000ffff,0x0000ffff, false),
-HOWTO( 1, 0, 1, 16, true, 0, complain_overflow_signed,0,"DISP16", true, 0x0000ffff,0x0000ffff, false),
+HOWTO( 0, 0, 1, 16, FALSE, 0, complain_overflow_signed,0,"16", TRUE, 0x0000ffff,0x0000ffff, FALSE),
+HOWTO( 1, 0, 1, 16, TRUE, 0, complain_overflow_signed,0,"DISP16", TRUE, 0x0000ffff,0x0000ffff, FALSE),
};
#define TABLE_SIZE(TABLE) (sizeof(TABLE)/sizeof(TABLE[0]))
NAME(aout,swap_exec_header_out) (abfd, execp, &exec_bytes);
if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
- return false;
+ return FALSE;
if (bfd_bwrite ((PTR) &exec_bytes, (bfd_size_type) EXEC_BYTES_SIZE, abfd)
!= EXEC_BYTES_SIZE)
- return false;
+ return FALSE;
/* Now write out reloc info, followed by syms and strings */
&& bfd_get_symcount (abfd) != 0)
{
if (bfd_seek (abfd, (file_ptr) (N_SYMOFF(*execp)), SEEK_SET) != 0)
- return false;
+ return FALSE;
if (! NAME(aout,write_syms) (abfd))
- return false;
+ return FALSE;
}
if (obj_textsec (abfd)->reloc_count > 0 ||
obj_datasec (abfd)->reloc_count > 0)
{
if (bfd_seek (abfd, (file_ptr) (N_TRELOFF(*execp)), SEEK_SET) != 0)
- return false;
+ return FALSE;
if (!NAME(aout,squirt_out_relocs) (abfd, obj_textsec (abfd)))
- return false;
+ return FALSE;
if (bfd_seek (abfd, (file_ptr) (N_DRELOFF(*execp)), SEEK_SET) != 0)
- return false;
+ return FALSE;
if (!NAME(aout,squirt_out_relocs) (abfd, obj_datasec (abfd)))
- return false;
+ return FALSE;
}
- return true;
+ return TRUE;
}
/* Write an object file.
Section contents have already been written. We write the
file header, symbols, and relocation. */
-static boolean
+static bfd_boolean
MY(write_object_contents) (abfd)
bfd *abfd;
{
/* 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;
}
/*
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) arch_flags = M_386;
+ if (machine == 0
+ || machine == bfd_mach_i386_i386
+ || machine == bfd_mach_i386_i386_intel_syntax)
+ arch_flags = M_386;
break;
case bfd_arch_a29k:
case bfd_arch_pdp11:
/* TODO: arch_flags = M_PDP11; */
- *unknown = false;
+ *unknown = FALSE;
break;
case bfd_arch_vax:
- *unknown = false;
+ *unknown = FALSE;
break;
default:
}
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;
}
obj_reloc_entry_size (abfd) = RELOC_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_bsssec(abfd)->vma, obj_bsssec(abfd)->_raw_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;
{
obj_textsec(abfd)= newsect;
newsect->target_index = N_TEXT;
- return true;
+ return TRUE;
}
if (obj_datasec (abfd) == NULL
{
obj_datasec (abfd) = newsect;
newsect->target_index = N_DATA;
- return true;
+ return TRUE;
}
if (obj_bsssec (abfd) == NULL
{
obj_bsssec (abfd) = newsect;
newsect->target_index = N_BSS;
- return true;
+ return TRUE;
}
}
/* We allow more than three sections internally */
- return true;
+ return TRUE;
}
-boolean
+bfd_boolean
NAME(aout,set_section_contents) (abfd, section, location, offset, count)
bfd *abfd;
sec_ptr section;
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)
("%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;
+ 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
possible to free them. */
syms = (struct external_nlist *) bfd_malloc (count * EXTERNAL_NLIST_SIZE);
if (syms == (struct external_nlist *) NULL && count != 0)
- return false;
+ return FALSE;
if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0
|| (bfd_bread (syms, exec_hdr (abfd)->a_syms, abfd)
!= exec_hdr (abfd)->a_syms))
{
free (syms);
- return false;
+ return FALSE;
}
#endif
if (bfd_seek (abfd, obj_str_filepos (abfd), SEEK_SET) != 0
|| (bfd_bread ((PTR) string_chars, (bfd_size_type) BYTES_IN_LONG,
abfd) != BYTES_IN_LONG))
- return false;
+ return FALSE;
stringsize = H_GET_32 (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 + 4, stringsize - 4, abfd) != stringsize - 4)
{
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;
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
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_archive_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)
("%s: can not represent section `%s' in a.out object file format",
bfd_archive_filename (abfd), bfd_get_section_name (abfd, sec));
bfd_set_error (bfd_error_nonrepresentable_section);
- return false;
+ return FALSE;
}
/* Turn the symbol from section relative to absolute again */
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);
/* TODO: is 0 a safe value here? */
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;
{
/* 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;
H_PUT_32 (abfd, _bfd_stringtab_size (tab) + BYTES_IN_LONG, buffer);
if (bfd_bwrite ((PTR) buffer, (bfd_size_type) BYTES_IN_LONG, abfd)
!= BYTES_IN_LONG)
- 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++)
{
PUT_WORD (abfd, 0, nsp.e_unused);
- 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, nsp.e_strx);
_bfd_stringtab_free (strtab);
- return true;
+ return TRUE;
error_return:
_bfd_stringtab_free (strtab);
- return false;
+ return FALSE;
}
\f
/* Read and swap the relocs for a section. */
-boolean
+bfd_boolean
NAME(aout,slurp_reloc_table) (abfd, asect, symbols)
bfd *abfd;
sec_ptr asect;
arelent *cache_ptr;
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);
relocs = bfd_malloc (reloc_size);
if (relocs == NULL && reloc_size != 0)
- return false;
+ return FALSE;
if (bfd_bread (relocs, reloc_size, abfd) != reloc_size)
{
free (relocs);
- return false;
+ return FALSE;
}
count = reloc_size / each_size;
count = real_count;
}
- reloc_cache = (arelent *) bfd_malloc (count * sizeof (arelent));
+ reloc_cache = (arelent *) bfd_zmalloc (count * sizeof (arelent));
if (reloc_cache == NULL && count != 0)
- return false;
- memset (reloc_cache, 0, (size_t) count * sizeof (arelent));
+ 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;
relocation information, even if there is none. */
if ((count == 0 || section->orelocation == NULL) &&
<writing_executable>)
- return true;
+ return TRUE;
#endif
natsize = bfd_get_section_size_before_reloc (section);
native = (unsigned char *) bfd_zalloc (abfd, natsize);
if (!native)
- return false;
-
- memset ((PTR)native, 0, (size_t) natsize);
+ return FALSE;
generic = section->orelocation;
if (generic != NULL)
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 */
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;
wanted location.
*/
-boolean
+bfd_boolean
NAME(aout,find_nearest_line)
(abfd, section, symbols, offset, filename_ptr, functionname_ptr, line_ptr)
bfd *abfd;
buf = (char *) bfd_malloc ((bfd_size_type) filelen + funclen + 3);
adata (abfd).line_buf = buf;
if (buf == NULL)
- return false;
+ return FALSE;
}
if (main_file_name != NULL)
*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;
{
asection *o;
if (bfd_get_format (abfd) != bfd_object)
- 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;
/* 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);
continue;
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. */
seems a bit crazy to me, and I haven't implemented it.
However, it might be correct. */
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;
}
/* 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
bfd_alloc (abfd,
sym_count * sizeof (struct aout_link_hash_entry *)));
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
}
}
- 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 INLINE asection *aout_reloc_type_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 *));
-static boolean pdp11_aout_link_input_section
+static bfd_boolean pdp11_aout_link_input_section
PARAMS ((struct aout_final_link_info *finfo,
bfd *input_bfd,
asection *input_section,
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. */
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 (p = o->link_order_head; p != NULL; p = p->next)
{
if (p->type == bfd_indirect_link_order)
- p->u.indirect.section->linker_mark = true;
+ 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);
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
{
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;
}
}
symbol. */
copy = ! 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;
/* Copy this symbol into the list of symbols we are going to
write out. */
H_PUT_8 (output_bfd, type, outsym->e_type);
- 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 size;
if (bfd_seek (output_bfd, finfo->symoff, SEEK_SET) != 0)
- return false;
+ return FALSE;
size = outsym - finfo->output_syms;
size *= EXTERNAL_NLIST_SIZE;
if (bfd_bwrite ((PTR) finfo->output_syms, size, output_bfd) != size)
- return false;
+ return FALSE;
finfo->symoff += 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:
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;
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;
+ return TRUE;
}
H_PUT_8 (output_bfd, type, outsym.e_type);
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;
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 (! pdp11_aout_link_input_section (finfo, input_bfd, input_section,
(struct pdp11_aout_reloc_external *) relocs,
rel_size, finfo->contents))
- return false;
+ return FALSE;
/* Write out the section contents. */
if (! bfd_set_section_contents (finfo->output_bfd,
(PTR) finfo->contents,
(file_ptr) input_section->output_offset,
input_size))
- return false;
+ return FALSE;
/* If we are producing relocateable output, the relocs were
modified, and we now write them out. */
if (finfo->info->relocateable && 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. */
}
}
-static boolean
+static bfd_boolean
pdp11_aout_link_input_section (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 relocateable;
struct external_nlist *syms;
char *strings;
struct aout_link_hash_entry **sym_hashes;
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)
{
h = sym_hashes[r_index];
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,
if (! ((*finfo->info->callbacks->reloc_overflow)
(finfo->info, name, howto->name,
(bfd_vma) 0, 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))
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,
pr->addend, buf);
switch (r)
(asection *) NULL, (bfd_vma) 0)))
{
free (buf);
- return false;
+ return FALSE;
}
break;
}
size);
free (buf);
if (! ok)
- return false;
+ return FALSE;
}
rel_size = obj_reloc_entry_size (finfo->output_bfd);
if (bfd_seek (finfo->output_bfd, *reloff_ptr, SEEK_SET) != 0
|| bfd_bwrite (rel_ptr, rel_size, finfo->output_bfd) != rel_size)
- return false;
+ return FALSE;
*reloff_ptr += rel_size;
|| (*reloff_ptr
<= obj_datasec (finfo->output_bfd)->rel_filepos)));
- return true;
+ return TRUE;
}
/* end of modified aoutx.h */
projects / binutils-gdb.git / blobdiff