#define obstack_chunk_free free
static const char *startup_file;
static lang_statement_list_type input_file_chain;
-static boolean placed_commons = false;
+static bfd_boolean placed_commons = FALSE;
static lang_output_section_statement_type *default_common_section;
-static boolean map_option_f;
+static bfd_boolean map_option_f;
static bfd_vma print_dot;
static lang_input_statement_type *first_file;
static const char *current_target;
PARAMS ((void (*) (lang_statement_union_type *),
lang_statement_union_type *));
static lang_input_statement_type *new_afile
- PARAMS ((const char *, lang_input_file_enum_type, const char *, boolean));
-static lang_memory_region_type *lang_memory_default PARAMS ((asection *));
-static void lang_map_flags PARAMS ((flagword));
-static void init_os PARAMS ((lang_output_section_statement_type *));
-static void exp_init_os PARAMS ((etree_type *));
-static void section_already_linked PARAMS ((bfd *, asection *, PTR));
+ PARAMS ((const char *, lang_input_file_enum_type, const char *,
+ bfd_boolean));
+static lang_memory_region_type *lang_memory_default
+ PARAMS ((asection *));
+static void lang_map_flags
+ PARAMS ((flagword));
+static void init_os
+ PARAMS ((lang_output_section_statement_type *));
+static void exp_init_os
+ PARAMS ((etree_type *));
+static void section_already_linked
+ PARAMS ((bfd *, asection *, PTR));
static struct bfd_hash_entry *already_linked_newfunc
PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
-static void already_linked_table_init PARAMS ((void));
-static void already_linked_table_free PARAMS ((void));
-static boolean wildcardp PARAMS ((const char *));
+static void already_linked_table_init
+ PARAMS ((void));
+static void already_linked_table_free
+ PARAMS ((void));
+static bfd_boolean wildcardp
+ PARAMS ((const char *));
static lang_statement_union_type *wild_sort
PARAMS ((lang_wild_statement_type *, struct wildcard_list *,
lang_input_statement_type *, asection *));
static void output_section_callback
PARAMS ((lang_wild_statement_type *, struct wildcard_list *, asection *,
lang_input_statement_type *, PTR));
-static lang_input_statement_type *lookup_name PARAMS ((const char *));
-static boolean load_symbols
+static lang_input_statement_type *lookup_name
+ PARAMS ((const char *));
+static bfd_boolean load_symbols
PARAMS ((lang_input_statement_type *, lang_statement_list_type *));
static void wild
PARAMS ((lang_wild_statement_type *,
const char *, lang_output_section_statement_type *));
-static bfd *open_output PARAMS ((const char *));
-static void ldlang_open_output PARAMS ((lang_statement_union_type *));
-static void open_input_bfds PARAMS ((lang_statement_union_type *, boolean));
-static void lang_reasonable_defaults PARAMS ((void));
-static void insert_undefined PARAMS ((const char *));
-static void lang_place_undefineds PARAMS ((void));
+static bfd *open_output
+ PARAMS ((const char *));
+static void ldlang_open_output
+ PARAMS ((lang_statement_union_type *));
+static void open_input_bfds
+ PARAMS ((lang_statement_union_type *, bfd_boolean));
+static void lang_reasonable_defaults
+ PARAMS ((void));
+static void insert_undefined
+ PARAMS ((const char *));
+static void lang_place_undefineds
+ PARAMS ((void));
static void map_input_to_output_sections
PARAMS ((lang_statement_union_type *, const char *,
lang_output_section_statement_type *));
-static void strip_excluded_output_sections PARAMS ((void));
+static void strip_excluded_output_sections
+ PARAMS ((void));
static void print_output_section_statement
PARAMS ((lang_output_section_statement_type *));
static void print_assignment
PARAMS ((lang_assignment_statement_type *,
lang_output_section_statement_type *));
-static void print_input_statement PARAMS ((lang_input_statement_type *));
-static boolean print_one_symbol PARAMS ((struct bfd_link_hash_entry *, PTR));
-static void print_input_section PARAMS ((lang_input_section_type *));
-static void print_fill_statement PARAMS ((lang_fill_statement_type *));
-static void print_data_statement PARAMS ((lang_data_statement_type *));
-static void print_address_statement PARAMS ((lang_address_statement_type *));
-static void print_reloc_statement PARAMS ((lang_reloc_statement_type *));
-static void print_padding_statement PARAMS ((lang_padding_statement_type *));
+static void print_input_statement
+ PARAMS ((lang_input_statement_type *));
+static bfd_boolean print_one_symbol
+ PARAMS ((struct bfd_link_hash_entry *, PTR));
+static void print_input_section
+ PARAMS ((lang_input_section_type *));
+static void print_fill_statement
+ PARAMS ((lang_fill_statement_type *));
+static void print_data_statement
+ PARAMS ((lang_data_statement_type *));
+static void print_address_statement
+ PARAMS ((lang_address_statement_type *));
+static void print_reloc_statement
+ PARAMS ((lang_reloc_statement_type *));
+static void print_padding_statement
+ PARAMS ((lang_padding_statement_type *));
static void print_wild_statement
PARAMS ((lang_wild_statement_type *, lang_output_section_statement_type *));
static void print_group
PARAMS ((lang_statement_union_type *, lang_output_section_statement_type *));
static void print_statement_list
PARAMS ((lang_statement_union_type *, lang_output_section_statement_type *));
-static void print_statements PARAMS ((void));
+static void print_statements
+ PARAMS ((void));
static void insert_pad
PARAMS ((lang_statement_union_type **, fill_type *,
unsigned int, asection *, bfd_vma));
static bfd_vma size_input_section
PARAMS ((lang_statement_union_type **, lang_output_section_statement_type *,
fill_type *, bfd_vma));
-static void lang_finish PARAMS ((void));
-static void ignore_bfd_errors PARAMS ((const char *, ...));
-static void lang_check PARAMS ((void));
-static void lang_common PARAMS ((void));
-static boolean lang_one_common PARAMS ((struct bfd_link_hash_entry *, PTR));
-static void lang_place_orphans PARAMS ((void));
-static int topower PARAMS ((int));
-static void lang_set_startof PARAMS ((void));
+static void lang_finish
+ PARAMS ((void));
+static void ignore_bfd_errors
+ PARAMS ((const char *, ...));
+static void lang_check
+ PARAMS ((void));
+static void lang_common
+ PARAMS ((void));
+static bfd_boolean lang_one_common
+ PARAMS ((struct bfd_link_hash_entry *, PTR));
+static void lang_place_orphans
+ PARAMS ((void));
+static int topower
+ PARAMS ((int));
+static void lang_set_startof
+ PARAMS ((void));
static void gc_section_callback
PARAMS ((lang_wild_statement_type *, struct wildcard_list *, asection *,
lang_input_statement_type *, PTR));
-static void lang_get_regions PARAMS ((struct memory_region_struct **,
- struct memory_region_struct **,
- const char *, const char *, int));
-static void lang_record_phdrs PARAMS ((void));
-static void lang_gc_wild PARAMS ((lang_wild_statement_type *));
-static void lang_gc_sections_1 PARAMS ((lang_statement_union_type *));
-static void lang_gc_sections PARAMS ((void));
+static void lang_get_regions
+ PARAMS ((struct memory_region_struct **, struct memory_region_struct **,
+ const char *, const char *, int));
+static void lang_record_phdrs
+ PARAMS ((void));
+static void lang_gc_wild
+ PARAMS ((lang_wild_statement_type *));
+static void lang_gc_sections_1
+ PARAMS ((lang_statement_union_type *));
+static void lang_gc_sections
+ PARAMS ((void));
static int lang_vers_match_lang_c
PARAMS ((struct bfd_elf_version_expr *, const char *));
static int lang_vers_match_lang_cplusplus
PARAMS ((struct bfd_elf_version_expr *, const char *));
static int lang_vers_match_lang_java
PARAMS ((struct bfd_elf_version_expr *, const char *));
-static void lang_do_version_exports_section PARAMS ((void));
-static void lang_check_section_addresses PARAMS ((void));
+static void lang_do_version_exports_section
+ PARAMS ((void));
+static void lang_check_section_addresses
+ PARAMS ((void));
static void os_region_check
PARAMS ((lang_output_section_statement_type *,
struct memory_region_struct *, etree_type *, bfd_vma));
static bfd_vma lang_size_sections_1
PARAMS ((lang_statement_union_type *, lang_output_section_statement_type *,
- lang_statement_union_type **, fill_type *, bfd_vma, boolean *));
-
-typedef void (*callback_t) PARAMS ((lang_wild_statement_type *,
- struct wildcard_list *,
- asection *,
- lang_input_statement_type *,
- PTR));
+ lang_statement_union_type **, fill_type *, bfd_vma, bfd_boolean *));
+typedef void (*callback_t)
+ PARAMS ((lang_wild_statement_type *, struct wildcard_list *, asection *,
+ lang_input_statement_type *, PTR));
static void walk_wild
PARAMS ((lang_wild_statement_type *, callback_t, PTR));
static void walk_wild_section
static void walk_wild_file
PARAMS ((lang_wild_statement_type *, lang_input_statement_type *,
callback_t, PTR));
-
-static int get_target PARAMS ((const bfd_target *, PTR));
-static void stricpy PARAMS ((char *, char *));
-static void strcut PARAMS ((char *, char *));
-static int name_compare PARAMS ((char *, char *));
-static int closest_target_match PARAMS ((const bfd_target *, PTR));
-static char * get_first_input_target PARAMS ((void));
+static int get_target
+ PARAMS ((const bfd_target *, PTR));
+static void stricpy
+ PARAMS ((char *, char *));
+static void strcut
+ PARAMS ((char *, char *));
+static int name_compare
+ PARAMS ((char *, char *));
+static int closest_target_match
+ PARAMS ((const bfd_target *, PTR));
+static char * get_first_input_target
+ PARAMS ((void));
/* EXPORTS */
lang_output_section_statement_type *abs_output_section;
lang_statement_list_type file_chain = { NULL, NULL };
struct bfd_sym_chain entry_symbol = { NULL, NULL };
const char *entry_section = ".text";
-boolean entry_from_cmdline;
-boolean lang_has_input_file = false;
-boolean had_output_filename = false;
-boolean lang_float_flag = false;
-boolean delete_output_file_on_failure = false;
+bfd_boolean entry_from_cmdline;
+bfd_boolean lang_has_input_file = FALSE;
+bfd_boolean had_output_filename = FALSE;
+bfd_boolean lang_float_flag = FALSE;
+bfd_boolean delete_output_file_on_failure = FALSE;
struct lang_nocrossrefs *nocrossref_list;
struct unique_sections *unique_section_list;
return obstack_alloc (&stat_obstack, size);
}
-boolean
+bfd_boolean
unique_section_p (secnam)
const char *secnam;
{
? fnmatch (unam->name, secnam, 0) == 0
: strcmp (unam->name, secnam) == 0)
{
- return true;
+ return TRUE;
}
- return false;
+ return FALSE;
}
/* Generic traversal routines for finding matching sections. */
while (sec != NULL)
{
- boolean skip = false;
+ bfd_boolean skip = FALSE;
struct name_list *list_tmp;
/* Don't process sections from files which were
const char *name;
lang_input_file_enum_type file_type;
const char *target;
- boolean add_to_list;
+ bfd_boolean add_to_list;
{
lang_input_statement_type *p;
p->header.next = NULL;
}
- lang_has_input_file = true;
+ lang_has_input_file = TRUE;
p->target = target;
switch (file_type)
{
case lang_input_file_is_symbols_only_enum:
p->filename = name;
- p->is_archive = false;
- p->real = true;
+ p->is_archive = FALSE;
+ p->real = TRUE;
p->local_sym_name = name;
- p->just_syms_flag = true;
- p->search_dirs_flag = false;
+ p->just_syms_flag = TRUE;
+ p->search_dirs_flag = FALSE;
break;
case lang_input_file_is_fake_enum:
p->filename = name;
- p->is_archive = false;
- p->real = false;
+ p->is_archive = FALSE;
+ p->real = FALSE;
p->local_sym_name = name;
- p->just_syms_flag = false;
- p->search_dirs_flag = false;
+ p->just_syms_flag = FALSE;
+ p->search_dirs_flag = FALSE;
break;
case lang_input_file_is_l_enum:
- p->is_archive = true;
+ p->is_archive = TRUE;
p->filename = name;
- p->real = true;
+ p->real = TRUE;
p->local_sym_name = concat ("-l", name, (const char *) NULL);
- p->just_syms_flag = false;
- p->search_dirs_flag = true;
+ p->just_syms_flag = FALSE;
+ p->search_dirs_flag = TRUE;
break;
case lang_input_file_is_marker_enum:
p->filename = name;
- p->is_archive = false;
- p->real = false;
+ p->is_archive = FALSE;
+ p->real = FALSE;
p->local_sym_name = name;
- p->just_syms_flag = false;
- p->search_dirs_flag = true;
+ p->just_syms_flag = FALSE;
+ p->search_dirs_flag = TRUE;
break;
case lang_input_file_is_search_file_enum:
p->filename = name;
- p->is_archive = false;
- p->real = true;
+ p->is_archive = FALSE;
+ p->real = TRUE;
p->local_sym_name = name;
- p->just_syms_flag = false;
- p->search_dirs_flag = true;
+ p->just_syms_flag = FALSE;
+ p->search_dirs_flag = TRUE;
break;
case lang_input_file_is_file_enum:
p->filename = name;
- p->is_archive = false;
- p->real = true;
+ p->is_archive = FALSE;
+ p->real = TRUE;
p->local_sym_name = name;
- p->just_syms_flag = false;
- p->search_dirs_flag = false;
+ p->just_syms_flag = FALSE;
+ p->search_dirs_flag = FALSE;
break;
default:
FAIL ();
p->symbol_count = 0;
p->dynamic = config.dynamic_link;
p->whole_archive = whole_archive;
- p->loaded = false;
+ p->loaded = FALSE;
lang_statement_append (&input_file_chain,
(lang_statement_union_type *) p,
&p->next_real_file);
lang_input_file_enum_type file_type;
const char *target;
{
- lang_has_input_file = true;
- return new_afile (name, file_type, target, true);
+ lang_has_input_file = TRUE;
+ return new_afile (name, file_type, target, TRUE);
}
/* Build enough state so that the parser can build its tree. */
new->not_flags = 0;
new->length = ~(bfd_size_type) 0;
new->current = 0;
- new->had_full_message = false;
+ new->had_full_message = FALSE;
return new;
}
lookup->next = (lang_statement_union_type *) NULL;
lookup->bfd_section = (asection *) NULL;
- lookup->processed = false;
+ lookup->processed = FALSE;
lookup->sectype = normal_section;
lookup->addr_tree = (etree_type *) NULL;
lang_list_init (&lookup->children);
already_linked_list =
((struct already_linked_hash_entry *)
- bfd_hash_lookup (&already_linked_table, name, true, false));
+ bfd_hash_lookup (&already_linked_table, name, TRUE, FALSE));
for (l = already_linked_list->entry; l != NULL; l = l->next)
{
explicit actions, like foo.o(.text), bar.o(.text) and
foo.o(.text, .data). */
-/* Return true if the PATTERN argument is a wildcard pattern.
+/* Return TRUE if the PATTERN argument is a wildcard pattern.
Although backslashes are treated specially if a pattern contains
wildcards, we do not consider the mere presence of a backslash to
be enough to cause the pattern to be treated as a wildcard.
That lets us handle DOS filenames more naturally. */
-static boolean
+static bfd_boolean
wildcardp (pattern)
const char *pattern;
{
if (*s == '?'
|| *s == '*'
|| *s == '[')
- return true;
- return false;
+ return TRUE;
+ return FALSE;
}
/* Add SECTION to the output section OUTPUT. Do this by creating a
lang_input_statement_type *file;
{
flagword flags;
- boolean discard;
+ bfd_boolean discard;
flags = bfd_get_section_flags (section->owner, section);
- discard = false;
+ discard = FALSE;
/* Discard sections marked with SEC_EXCLUDE if we are doing a final
link. Discard debugging sections marked with SEC_EXCLUDE on a
relocatable link too. */
if ((flags & SEC_EXCLUDE) != 0
&& ((flags & SEC_DEBUGGING) != 0 || !link_info.relocateable))
- discard = true;
+ discard = TRUE;
/* Discard input sections which are assigned to a section named
DISCARD_SECTION_NAME. */
if (strcmp (output->name, DISCARD_SECTION_NAME) == 0)
- discard = true;
+ discard = TRUE;
/* Discard debugging sections if we are stripping debugging
information. */
if ((link_info.strip == strip_debugger || link_info.strip == strip_all)
&& (flags & SEC_DEBUGGING) != 0)
- discard = true;
+ discard = TRUE;
if (discard)
{
if (section->output_section == NULL)
{
- boolean first;
+ bfd_boolean first;
lang_input_section_type *new;
flagword flags;
if (wild->filenames_sorted)
{
const char *fn, *ln;
- boolean fa, la;
+ bfd_boolean fa, la;
int i;
/* The PE support for the .idata section as generated by
&& bfd_my_archive (file->the_bfd) != NULL)
{
fn = bfd_get_filename (bfd_my_archive (file->the_bfd));
- fa = true;
+ fa = TRUE;
}
else
{
fn = file->filename;
- fa = false;
+ fa = FALSE;
}
if (ls->ifile->the_bfd != NULL
&& bfd_my_archive (ls->ifile->the_bfd) != NULL)
{
ln = bfd_get_filename (bfd_my_archive (ls->ifile->the_bfd));
- la = true;
+ la = TRUE;
}
else
{
ln = ls->ifile->filename;
- la = false;
+ la = FALSE;
}
i = strcmp (fn, ln);
if (search == (lang_input_statement_type *) NULL)
search = new_afile (name, lang_input_file_is_file_enum, default_target,
- false);
+ FALSE);
/* If we have already added this file, or this file is not real
(FIXME: can that ever actually happen?) or the name is NULL
/* Get the symbols for an input file. */
-static boolean
+static bfd_boolean
load_symbols (entry, place)
lang_input_statement_type *entry;
lang_statement_list_type *place;
char **matching;
if (entry->loaded)
- return true;
+ return TRUE;
ldfile_open_file (entry);
{
bfd_error_type err;
lang_statement_list_type *hold;
- boolean bad_load = true;
+ bfd_boolean bad_load = TRUE;
err = bfd_get_error ();
/* See if the emulation has some special knowledge. */
if (ldemul_unrecognized_file (entry))
- return true;
+ return TRUE;
if (err == bfd_error_file_ambiguously_recognized)
{
|| place == NULL)
einfo (_("%F%B: file not recognized: %E\n"), entry->the_bfd);
else
- bad_load = false;
+ bad_load = FALSE;
bfd_close (entry->the_bfd);
entry->the_bfd = NULL;
hold = stat_ptr;
stat_ptr = place;
- ldfile_assumed_script = true;
+ ldfile_assumed_script = TRUE;
parser_input = input_script;
yyparse ();
- ldfile_assumed_script = false;
+ ldfile_assumed_script = FALSE;
stat_ptr = hold;
}
if (ldemul_recognized_file (entry))
- return true;
+ return TRUE;
/* We don't call ldlang_add_file for an archive. Instead, the
add_symbols entry point will call ldlang_add_file, via the
if (entry->whole_archive)
{
bfd *member = NULL;
- boolean loaded = true;
+ bfd_boolean loaded = TRUE;
for (;;)
{
{
einfo (_("%F%B: member %B in archive is not an object\n"),
entry->the_bfd, member);
- loaded = false;
+ loaded = FALSE;
}
if (! ((*link_info.callbacks->add_archive_element)
if (! bfd_link_add_symbols (member, &link_info))
{
einfo (_("%F%B: could not read symbols: %E\n"), member);
- loaded = false;
+ loaded = FALSE;
}
}
}
if (bfd_link_add_symbols (entry->the_bfd, &link_info))
- entry->loaded = true;
+ entry->loaded = TRUE;
else
einfo (_("%F%B: could not read symbols: %E\n"), entry->the_bfd);
}
}
-/* Return true iff target is the sought target. */
+/* Return TRUE iff target is the sought target. */
static int
get_target (target, data)
einfo (_("%P%F: cannot open output file %s: %E\n"), name);
}
- delete_output_file_on_failure = true;
+ delete_output_file_on_failure = TRUE;
#if 0
output->flags |= D_PAGED;
static void
open_input_bfds (s, force)
lang_statement_union_type *s;
- boolean force;
+ bfd_boolean force;
{
for (; s != (lang_statement_union_type *) NULL; s = s->header.next)
{
do
{
undefs = link_info.hash->undefs_tail;
- open_input_bfds (s->group_statement.children.head, true);
+ open_input_bfds (s->group_statement.children.head, TRUE);
}
while (undefs != link_info.hash->undefs_tail);
}
&& s->input_statement.loaded
&& bfd_check_format (s->input_statement.the_bfd,
bfd_archive))
- s->input_statement.loaded = false;
+ s->input_statement.loaded = FALSE;
lang_list_init (&add);
if (! load_symbols (&s->input_statement, &add))
- config.make_executable = false;
+ config.make_executable = FALSE;
if (add.head != NULL)
{
{
struct bfd_link_hash_entry *h;
- h = bfd_link_hash_lookup (link_info.hash, name, true, false, true);
+ h = bfd_link_hash_lookup (link_info.hash, name, TRUE, FALSE, TRUE);
if (h == (struct bfd_link_hash_entry *) NULL)
einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
if (h->type == bfd_link_hash_new)
/* Print all symbols defined in a particular section. This is called
via bfd_link_hash_traverse. */
-static boolean
+static bfd_boolean
print_one_symbol (hash_entry, ptr)
struct bfd_link_hash_entry *hash_entry;
PTR ptr;
minfo (" %T\n", hash_entry->root.string);
}
- return true;
+ return TRUE;
}
/* Print information about an input section to the map file. */
lang_statement_union_type **prev;
fill_type *fill;
bfd_vma dot;
- boolean *relax;
+ bfd_boolean *relax;
{
unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
ldfile_output_machine);
(after - os->bfd_section->vma) * opb;
dot = os->bfd_section->vma + os->bfd_section->_raw_size / opb;
- os->processed = true;
+ os->processed = TRUE;
if (os->update_dot_tree != 0)
exp_fold_tree (os->update_dot_tree, abs_output_section,
}
else
{
- boolean again;
+ bfd_boolean again;
if (! bfd_relax_section (i->owner, i, &link_info, &again))
einfo (_("%P%F: can't relax section: %E\n"));
if (again)
- *relax = true;
+ *relax = TRUE;
}
dot = size_input_section (prev, output_section_statement,
output_section_statement->fill, dot);
lang_statement_union_type **prev;
fill_type *fill;
bfd_vma dot;
- boolean *relax;
+ bfd_boolean *relax;
{
bfd_vma result;
buf = xmalloc (10 + strlen (secname));
sprintf (buf, ".startof.%s", secname);
- h = bfd_link_hash_lookup (link_info.hash, buf, false, false, true);
+ h = bfd_link_hash_lookup (link_info.hash, buf, FALSE, FALSE, TRUE);
if (h != NULL && h->type == bfd_link_hash_undefined)
{
h->type = bfd_link_hash_defined;
}
sprintf (buf, ".sizeof.%s", secname);
- h = bfd_link_hash_lookup (link_info.hash, buf, false, false, true);
+ h = bfd_link_hash_lookup (link_info.hash, buf, FALSE, FALSE, TRUE);
if (h != NULL && h->type == bfd_link_hash_undefined)
{
unsigned opb;
lang_finish ()
{
struct bfd_link_hash_entry *h;
- boolean warn;
+ bfd_boolean warn;
if (link_info.relocateable || link_info.shared)
- warn = false;
+ warn = FALSE;
else
- warn = true;
+ warn = TRUE;
if (entry_symbol.name == (const char *) NULL)
{
/* No entry has been specified. Look for start, but don't warn
if we don't find it. */
entry_symbol.name = "start";
- warn = false;
+ warn = FALSE;
}
h = bfd_link_hash_lookup (link_info.hash, entry_symbol.name,
- false, false, true);
+ FALSE, FALSE, TRUE);
if (h != (struct bfd_link_hash_entry *) NULL
&& (h->type == bfd_link_hash_defined
|| h->type == bfd_link_hash_defweak)
/* Place one common symbol in the correct section. */
-static boolean
+static bfd_boolean
lang_one_common (h, info)
struct bfd_link_hash_entry *h;
PTR info;
ldfile_output_machine);
if (h->type != bfd_link_hash_common)
- return true;
+ return TRUE;
size = h->u.c.size;
power_of_two = h->u.c.p->alignment_power;
if (config.sort_common
&& power_of_two < (unsigned int) *(int *) info)
- return true;
+ return TRUE;
section = h->u.c.p->section;
if (config.map_file != NULL)
{
- static boolean header_printed;
+ static bfd_boolean header_printed;
int len;
char *name;
char buf[50];
{
minfo (_("\nAllocating common symbols\n"));
minfo (_("Common symbol size file\n\n"));
- header_printed = true;
+ header_printed = TRUE;
}
name = demangle (h->root.string);
minfo ("%B\n", section->owner);
}
- return true;
+ return TRUE;
}
/* Run through the input files and ensure that every input section has
if (!had_output_filename || !from_script)
{
output_filename = name;
- had_output_filename = true;
+ had_output_filename = TRUE;
}
}
for (ulist = link_info.gc_sym_list; ulist; ulist = ulist->next)
{
h = bfd_link_hash_lookup (link_info.hash, ulist->name,
- false, false, false);
+ FALSE, FALSE, FALSE);
if (h != (struct bfd_link_hash_entry *) NULL
&& (h->type == bfd_link_hash_defined
/* Create a bfd for each input file. */
current_target = default_target;
- open_input_bfds (statement_list.head, false);
+ open_input_bfds (statement_list.head, FALSE);
link_info.gc_sym_list = &entry_symbol;
if (entry_symbol.name == NULL)
if (command_line.relax)
{
/* Keep relaxing until bfd_relax_section gives up. */
- boolean relax_again;
+ bfd_boolean relax_again;
do
{
lang_reset_memory_regions ();
- relax_again = false;
+ relax_again = FALSE;
/* Note: pe-dll.c does something like this also. If you find
you need to change this code, you probably need to change
lang_add_wild (filespec, section_list, keep_sections)
struct wildcard_spec *filespec;
struct wildcard_list *section_list;
- boolean keep_sections;
+ bfd_boolean keep_sections;
{
struct wildcard_list *curr, *next;
lang_wild_statement_type *new;
section_list = curr, curr = next)
{
if (curr->spec.name != NULL && strcmp (curr->spec.name, "COMMON") == 0)
- placed_commons = true;
+ placed_commons = TRUE;
next = curr->next;
curr->next = section_list;
if (strcmp (filespec->name, "*") == 0)
filespec->name = NULL;
else if (! wildcardp (filespec->name))
- lang_has_input_file = true;
+ lang_has_input_file = TRUE;
}
new = new_stat (lang_wild_statement, stat_ptr);
new->filename = NULL;
- new->filenames_sorted = false;
+ new->filenames_sorted = FALSE;
if (filespec != NULL)
{
new->filename = filespec->name;
void
lang_add_entry (name, cmdline)
const char *name;
- boolean cmdline;
+ bfd_boolean cmdline;
{
if (entry_symbol.name == NULL
|| cmdline
switch (*name)
{
case 'F':
- map_option_f = true;
+ map_option_f = TRUE;
break;
}
name++;
}
first_file->filename = name;
first_file->local_sym_name = name;
- first_file->real = true;
+ first_file->real = TRUE;
startup_file = name;
}
void
lang_float (maybe)
- boolean maybe;
+ bfd_boolean maybe;
{
lang_float_flag = maybe;
}
MEMSPEC is the name of the run-time region, or "*default*" if the
statement didn't specify one. LMA_MEMSPEC is the name of the
load-time region, or null if the statement didn't specify one.
- HAVE_LMA_P is true if the statement had an explicit load address.
+ HAVE_LMA_P is TRUE if the statement had an explicit load address.
It is an error to specify both a load region and a load address. */
{
struct bfd_link_hash_entry *h;
- h = bfd_link_hash_lookup (link_info.hash, name, true, true, true);
+ h = bfd_link_hash_lookup (link_info.hash, name, TRUE, TRUE, TRUE);
if (h == (struct bfd_link_hash_entry *) NULL)
einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
{
struct bfd_link_hash_entry *h;
- h = bfd_link_hash_lookup (link_info.hash, name, true, true, true);
+ h = bfd_link_hash_lookup (link_info.hash, name, TRUE, TRUE, TRUE);
if (h == (struct bfd_link_hash_entry *) NULL)
einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
lang_new_phdr (name, type, filehdr, phdrs, at, flags)
const char *name;
etree_type *type;
- boolean filehdr;
- boolean phdrs;
+ bfd_boolean filehdr;
+ bfd_boolean phdrs;
etree_type *at;
etree_type *flags;
{
}
secs[c] = os->bfd_section;
++c;
- pl->used = true;
+ pl->used = TRUE;
}
}
}
nocrossref_list = n;
/* Set notice_all so that we get informed about all symbols. */
- link_info.notice_all = true;
+ link_info.notice_all = TRUE;
}
\f
/* Overlay handling. We handle overlays with some static variables. */
if (!alt_sym)
{
/* cplus_demangle (also) returns NULL when it is not a C++ symbol.
- Should we early out false in this case? */
+ Should we early out FALSE in this case? */
result = fnmatch (expr->pattern, sym, 0) == 0;
}
else
if (!alt_sym)
{
/* cplus_demangle (also) returns NULL when it is not a Java symbol.
- Should we early out false in this case? */
+ Should we early out FALSE in this case? */
result = fnmatch (expr->pattern, sym, 0) == 0;
}
else
projects / deliverable / binutils-gdb.git / blobdiff