X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=bfd%2Fmmo.c;h=2ee386662a425cc2d071e6d453c2e0ecddd7985c;hb=0a0ff9d931ea7b2f0bc3c7c9ef6029f3d08e5a90;hp=6c356fa57b4843b746bbc5bc66acead920a4c5ba;hpb=68d206766637a041bbbeb89c8a1bfdd76317e192;p=binutils-gdb.git diff --git a/bfd/mmo.c b/bfd/mmo.c index 6c356fa57b4..2ee386662a4 100644 --- a/bfd/mmo.c +++ b/bfd/mmo.c @@ -1,5 +1,5 @@ /* BFD back-end for mmo objects (MMIX-specific object-format). - Copyright (C) 2001-2018 Free Software Foundation, Inc. + Copyright (C) 2001-2021 Free Software Foundation, Inc. Written by Hans-Peter Nilsson (hp@bitrange.com). Infrastructure and other bits originally copied from srec.c and binary.c. @@ -207,7 +207,7 @@ EXAMPLE #include "elf/mmix.h" #include "opcode/mmix.h" -#define LOP 0x98 +#define LOP 0x98u #define LOP_QUOTE 0 #define LOP_LOC 1 #define LOP_SKIP 2 @@ -307,7 +307,7 @@ struct mmo_data_struct /* When we're reading bytes recursively, check this occasionally. Also holds write errors. */ - bfd_boolean have_error; + bool have_error; /* Max symbol length that may appear in the lop_stab table. Note that this table might just hold a subset of symbols for not-really large @@ -334,10 +334,10 @@ struct mmo_data_struct /* Whether we've calculated symbol consistency requirement yet. We do this when-needed, which must be at some time after all section contents is known. */ - bfd_boolean symbol_consistency_override_calculated; + bool symbol_consistency_override_calculated; /* Whether to consistency-check symbol values, in particular "Main". */ - bfd_boolean ignore_symbol_consistency; + bool ignore_symbol_consistency; }; typedef struct mmo_data_struct tdata_type; @@ -358,7 +358,7 @@ struct mmo_section_data_struct struct mmo_write_sec_info { asection *reg_section; - bfd_boolean retval; + bool retval; }; /* Used when trying to find a section corresponding to addr. */ @@ -368,7 +368,7 @@ struct mmo_find_sec_info bfd_vma addr; }; -static bfd_boolean mmo_bfd_copy_private_bfd_data (bfd *, bfd *); +static bool mmo_bfd_copy_private_bfd_data (bfd *, bfd *); static void mmo_write_section_unless_reg_contents (bfd *, asection *, void *); static void mmo_find_sec_w_addr (bfd *, asection *, void *); static void mmo_find_sec_w_addr_grow (bfd *, asection *, void *); @@ -377,76 +377,80 @@ static void mmo_get_symbol_info (bfd *, asymbol *, symbol_info *); static void mmo_print_symbol (bfd *, void *, asymbol *, bfd_print_symbol_type); static void mmo_init (void); -static bfd_boolean mmo_mkobject (bfd *); -static bfd_boolean mmo_scan (bfd *); +static bool mmo_mkobject (bfd *); +static bool mmo_scan (bfd *); static asection *mmo_decide_section (bfd *, bfd_vma); static asection *mmo_get_generic_spec_data_section (bfd *, int); static asection *mmo_get_spec_section (bfd *, int); -static INLINE bfd_byte *mmo_get_loc (asection *, bfd_vma, int); -static void mmo_xore_64 (asection *, bfd_vma vma, bfd_vma value); -static void mmo_xore_32 (asection *, bfd_vma vma, unsigned int); -static void mmo_xore_16 (asection *, bfd_vma vma, unsigned int); -static const bfd_target *mmo_object_p (bfd *); +static bfd_byte *mmo_get_loc (asection *, bfd_vma, int); +static bfd_cleanup mmo_object_p (bfd *); static void mmo_map_set_sizes (bfd *, asection *, void *); -static bfd_boolean mmo_get_symbols (bfd *); -static bfd_boolean mmo_create_symbol (bfd *, const char *, bfd_vma, - enum mmo_sym_type, unsigned int); -static bfd_boolean mmo_get_section_contents (bfd *, asection *, void *, - file_ptr, bfd_size_type); +static bool mmo_get_symbols (bfd *); +static bool mmo_create_symbol (bfd *, const char *, bfd_vma, + enum mmo_sym_type, unsigned int); +static bool mmo_get_section_contents (bfd *, asection *, void *, + file_ptr, bfd_size_type); static long mmo_get_symtab_upper_bound (bfd *); static long mmo_canonicalize_symtab (bfd *, asymbol **); static void mmo_get_symbol_info (bfd *, asymbol *, symbol_info *); static void mmo_print_symbol (bfd *, void *, asymbol *, bfd_print_symbol_type); -static bfd_boolean mmo_set_section_contents (bfd *, sec_ptr, const void *, - file_ptr, bfd_size_type); +static bool mmo_set_section_contents (bfd *, sec_ptr, const void *, + file_ptr, bfd_size_type); static int mmo_sizeof_headers (bfd *, struct bfd_link_info *); -static bfd_boolean mmo_internal_write_header (bfd *); -static bfd_boolean mmo_internal_write_post (bfd *, int, asection *); -static bfd_boolean mmo_internal_add_3_sym (bfd *, struct mmo_symbol_trie *, +static bool mmo_internal_write_header (bfd *); +static bool mmo_internal_write_post (bfd *, int, asection *); +static bool mmo_internal_add_3_sym (bfd *, struct mmo_symbol_trie *, const struct mmo_symbol *); static unsigned int mmo_internal_3_length (bfd *, struct mmo_symbol_trie *); static void mmo_internal_3_dump (bfd *, struct mmo_symbol_trie *); static void mmo_beb128_out (bfd *, int, int); -static bfd_boolean mmo_internal_write_section (bfd *, asection *); +static bool mmo_internal_write_section (bfd *, asection *); static void mmo_write_tetra (bfd *, unsigned int); static void mmo_write_tetra_raw (bfd *, unsigned int); static void mmo_write_octa (bfd *, bfd_vma); static void mmo_write_octa_raw (bfd *, bfd_vma); -static bfd_boolean mmo_write_chunk (bfd *, const bfd_byte *, unsigned int); -static bfd_boolean mmo_flush_chunk (bfd *); -static bfd_boolean mmo_write_loc_chunk (bfd *, bfd_vma, const bfd_byte *, - unsigned int, bfd_vma *); -static bfd_boolean mmo_write_chunk_list (bfd *, mmo_data_list_type *); -static bfd_boolean mmo_write_loc_chunk_list (bfd *, mmo_data_list_type *); -static bfd_boolean mmo_write_symbols_and_terminator (bfd *); +static bool mmo_write_chunk (bfd *, const bfd_byte *, unsigned int); +static bool mmo_flush_chunk (bfd *); +static bool mmo_write_loc_chunk (bfd *, bfd_vma, const bfd_byte *, + unsigned int, bfd_vma *); +static bool mmo_write_chunk_list (bfd *, mmo_data_list_type *); +static bool mmo_write_loc_chunk_list (bfd *, mmo_data_list_type *); +static bool mmo_write_symbols_and_terminator (bfd *); static flagword mmo_sec_flags_from_bfd_flags (flagword); static flagword bfd_sec_flags_from_mmo_flags (flagword); static bfd_byte mmo_get_byte (bfd *); static void mmo_write_byte (bfd *, bfd_byte); -static bfd_boolean mmo_new_section_hook (bfd *, asection *); +static bool mmo_new_section_hook (bfd *, asection *); static int mmo_sort_mmo_symbols (const void *, const void *); -static bfd_boolean mmo_write_object_contents (bfd *); -static bfd_boolean mmo_write_section_description (bfd *, asection *); -static bfd_boolean mmo_has_leading_or_trailing_zero_tetra_p (bfd *, - asection *); - -/* Global "const" variables initialized once. Must not depend on - particular input or caller; put such things into the bfd or elsewhere. - Look ma, no static per-invocation data! */ - -static -char valid_mmo_symbol_character_set[/* A-Z a-z (we assume consecutive - codes; sorry EBCDIC:ers!). */ - + 'Z' - 'A' + 1 + 'z' - 'a' + 1 - /* Digits. */ - + 10 - /* ':' and '_'. */ - + 1 + 1 - /* Codes higher than 126. */ - + 256 - 126 - /* Ending zero. */ - + 1]; +static bool mmo_write_object_contents (bfd *); +static bool mmo_write_section_description (bfd *, asection *); +static bool mmo_has_leading_or_trailing_zero_tetra_p (bfd *, asection *); + +static const char +valid_mmo_symbol_character_set[] = +{ + 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', + 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', + 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', + 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', + '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', + ':', '_', 126, 127, 128, 129, + 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, + 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, + 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, + 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, + 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, + 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, + 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, + 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, + 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, + 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, + 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, + 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, + 250, 251, 252, 253, 254, 255, + 0 +}; /* Get section SECNAME or create one if it doesn't exist. When creating @@ -465,7 +469,7 @@ mmo_make_section (bfd *abfd, const char *secname) { _bfd_error_handler /* xgettext:c-format */ - (_("%B: No core to allocate section name %s\n"), + (_("%pB: no core to allocate section name %s"), abfd, secname); bfd_set_error (bfd_error_system_call); return NULL; @@ -483,27 +487,16 @@ mmo_make_section (bfd *abfd, const char *secname) static void mmo_init (void) { - static bfd_boolean inited = FALSE; - int i = 0; - int j = 0; - static const char letters[] - = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789:_"; + static bool inited = false; if (inited) return; - inited = TRUE; - - /* Fill in the set of valid symbol characters. */ - strcpy (valid_mmo_symbol_character_set, letters); - i = strlen (letters); - - for (j = 126; j < 256; j++) - valid_mmo_symbol_character_set[i++] = j; + inited = true; } /* Check whether an existing file is an mmo file. */ -static const bfd_target * +static bfd_cleanup mmo_object_p (bfd *abfd) { struct stat statbuf; @@ -541,7 +534,7 @@ mmo_object_p (bfd *abfd) { _bfd_error_handler /* xgettext:c-format */ - (_("%B: No core to allocate a symbol %d bytes long\n"), + (_("%pB: no core to allocate a symbol %d bytes long"), abfd, abfd->tdata.mmo_data->max_symbol_length); goto bad_final; } @@ -559,7 +552,7 @@ mmo_object_p (bfd *abfd) if (! bfd_default_set_arch_mach (abfd, bfd_arch_mmix, 0)) goto bad_format_free; - return abfd->xvec; + return _bfd_no_cleanup; bad_format_free: free (abfd->tdata.mmo_data->lop_stab_symbol); @@ -571,7 +564,7 @@ mmo_object_p (bfd *abfd) /* Set up the mmo tdata information. */ -static bfd_boolean +static bool mmo_mkobject (bfd *abfd) { mmo_init (); @@ -582,9 +575,9 @@ mmo_mkobject (bfd *abfd) /* All fields are zero-initialized, so we don't have to explicitly initialize most. */ - tdata_type *tdata = (tdata_type *) bfd_zmalloc (sizeof (tdata_type)); + tdata_type *tdata = (tdata_type *) bfd_zalloc (abfd, sizeof (tdata_type)); if (tdata == NULL) - return FALSE; + return false; created = time (NULL); bfd_put_32 (abfd, created, tdata->created); @@ -592,14 +585,14 @@ mmo_mkobject (bfd *abfd) abfd->tdata.mmo_data = tdata; } - return TRUE; + return true; } -static bfd_boolean +static bool mmo_section_has_contents (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *p ATTRIBUTE_UNUSED) { /* The point is to match what --extract-symbols does (well, negated). */ - return bfd_get_section_size (sec) != 0; + return bfd_section_size (sec) != 0; } /* Find out whether we should omit symbol consistency checks for this @@ -609,7 +602,7 @@ mmo_section_has_contents (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *p ATT known. However, calculating symbol consistency at the time the private BFD data is initialized is too late for some uses. */ -static bfd_boolean +static bool mmo_ignore_symbol_consistency (bfd *abfd) { if (!abfd->tdata.mmo_data->symbol_consistency_override_calculated) @@ -617,25 +610,25 @@ mmo_ignore_symbol_consistency (bfd *abfd) abfd->tdata.mmo_data->ignore_symbol_consistency = bfd_sections_find_if (abfd, mmo_section_has_contents, NULL) == NULL; - abfd->tdata.mmo_data->symbol_consistency_override_calculated = TRUE; + abfd->tdata.mmo_data->symbol_consistency_override_calculated = true; } return abfd->tdata.mmo_data->ignore_symbol_consistency; } -static bfd_boolean +static bool mmo_bfd_copy_private_bfd_data (bfd *ibfd, bfd *obfd) { if (bfd_get_flavour (ibfd) != bfd_target_mmo_flavour || bfd_get_flavour (obfd) != bfd_target_mmo_flavour) - return TRUE; + return true; /* Copy the time the copied-from file was created. If people want the time the file was last *modified*, they have that in the normal file information. */ memcpy (obfd->tdata.mmo_data->created, ibfd->tdata.mmo_data->created, sizeof (obfd->tdata.mmo_data->created)); - return TRUE; + return true; } /* Helper functions for mmo_decide_section, used through @@ -645,10 +638,10 @@ static void mmo_find_sec_w_addr (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *p) { struct mmo_find_sec_info *infop = (struct mmo_find_sec_info *) p; - bfd_vma vma = bfd_get_section_vma (abfd, sec); + bfd_vma vma = bfd_section_vma (sec); /* Ignore sections that aren't loaded. */ - if ((bfd_get_section_flags (abfd, sec) & (SEC_LOAD | SEC_ALLOC)) + if ((bfd_section_flags (sec) & (SEC_LOAD | SEC_ALLOC)) != (SEC_LOAD | SEC_ALLOC)) return; @@ -660,10 +653,10 @@ static void mmo_find_sec_w_addr_grow (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void *p) { struct mmo_find_sec_info *infop = (struct mmo_find_sec_info *) p; - bfd_vma vma = bfd_get_section_vma (abfd, sec); + bfd_vma vma = bfd_section_vma (sec); /* Ignore sections that aren't loaded. */ - if ((bfd_get_section_flags (abfd, sec) & (SEC_LOAD | SEC_ALLOC)) + if ((bfd_section_flags (sec) & (SEC_LOAD | SEC_ALLOC)) != (SEC_LOAD | SEC_ALLOC)) return; @@ -703,12 +696,11 @@ mmo_decide_section (bfd *abfd, bfd_vma vma) if (sec == NULL) return NULL; - if (! sec->user_set_vma && ! bfd_set_section_vma (abfd, sec, vma)) + if (!sec->user_set_vma && !bfd_set_section_vma (sec, vma)) return NULL; - if (! bfd_set_section_flags (abfd, sec, - bfd_get_section_flags (abfd, sec) - | SEC_CODE | SEC_LOAD | SEC_ALLOC)) + if (!bfd_set_section_flags (sec, (bfd_section_flags (sec) + | SEC_CODE | SEC_LOAD | SEC_ALLOC))) return NULL; } else if ((vma >> 56) == 0x20) @@ -718,12 +710,11 @@ mmo_decide_section (bfd *abfd, bfd_vma vma) if (sec == NULL) return NULL; - if (! sec->user_set_vma && ! bfd_set_section_vma (abfd, sec, vma)) + if (!sec->user_set_vma && !bfd_set_section_vma (sec, vma)) return NULL; - if (! bfd_set_section_flags (abfd, sec, - bfd_get_section_flags (abfd, sec) - | SEC_LOAD | SEC_ALLOC)) + if (!bfd_set_section_flags (sec, (bfd_section_flags (sec) + | SEC_LOAD | SEC_ALLOC))) return NULL; } @@ -736,55 +727,66 @@ mmo_decide_section (bfd *abfd, bfd_vma vma) sprintf (sec_name, ".MMIX.sec.%d", abfd->tdata.mmo_data->sec_no++); sec = mmo_make_section (abfd, sec_name); - if (! sec->user_set_vma && ! bfd_set_section_vma (abfd, sec, vma)) + if (!sec->user_set_vma && !bfd_set_section_vma (sec, vma)) return NULL; - if (! bfd_set_section_flags (abfd, sec, - bfd_get_section_flags (abfd, sec) - | SEC_LOAD | SEC_ALLOC)) + if (!bfd_set_section_flags (sec, (bfd_section_flags (sec) + | SEC_LOAD | SEC_ALLOC))) return NULL; return sec; } /* Xor in a 64-bit value VALUE at VMA. */ -static INLINE void +static inline bfd_byte * mmo_xore_64 (asection *sec, bfd_vma vma, bfd_vma value) { bfd_byte *loc = mmo_get_loc (sec, vma, 8); - bfd_vma prev = bfd_get_64 (sec->owner, loc); + if (loc) + { + bfd_vma prev = bfd_get_64 (sec->owner, loc); - value ^= prev; - bfd_put_64 (sec->owner, value, loc); + value ^= prev; + bfd_put_64 (sec->owner, value, loc); + } + return loc; } /* Xor in a 32-bit value VALUE at VMA. */ -static INLINE void +static inline bfd_byte * mmo_xore_32 (asection *sec, bfd_vma vma, unsigned int value) { bfd_byte *loc = mmo_get_loc (sec, vma, 4); - unsigned int prev = bfd_get_32 (sec->owner, loc); + if (loc) + { + unsigned int prev = bfd_get_32 (sec->owner, loc); - value ^= prev; - bfd_put_32 (sec->owner, value, loc); + value ^= prev; + bfd_put_32 (sec->owner, value, loc); + } + return loc; } /* Xor in a 16-bit value VALUE at VMA. */ -static INLINE void +static inline bfd_byte * mmo_xore_16 (asection *sec, bfd_vma vma, unsigned int value) { bfd_byte *loc = mmo_get_loc (sec, vma, 2); - unsigned int prev = bfd_get_16 (sec->owner, loc); + if (loc) + { + unsigned int prev = bfd_get_16 (sec->owner, loc); - value ^= prev; - bfd_put_16 (sec->owner, value, loc); + value ^= prev; + bfd_put_16 (sec->owner, value, loc); + } + return loc; } /* Write a 32-bit word to output file, no lop_quote generated. */ -static INLINE void +static inline void mmo_write_tetra_raw (bfd *abfd, unsigned int value) { bfd_byte buf[4]; @@ -792,12 +794,12 @@ mmo_write_tetra_raw (bfd *abfd, unsigned int value) bfd_put_32 (abfd, value, buf); if (bfd_bwrite (buf, 4, abfd) != 4) - abfd->tdata.mmo_data->have_error = TRUE; + abfd->tdata.mmo_data->have_error = true; } /* Write a 32-bit word to output file; lop_quote if necessary. */ -static INLINE void +static inline void mmo_write_tetra (bfd *abfd, unsigned int value) { if (((value >> 24) & 0xff) == LOP) @@ -808,7 +810,7 @@ mmo_write_tetra (bfd *abfd, unsigned int value) /* Write a 64-bit word to output file, perhaps with lop_quoting. */ -static INLINE void +static inline void mmo_write_octa (bfd *abfd, bfd_vma value) { mmo_write_tetra (abfd, (unsigned int) (value >> 32)); @@ -817,7 +819,7 @@ mmo_write_octa (bfd *abfd, bfd_vma value) /* Write a 64-bit word to output file, without lop_quoting. */ -static INLINE void +static inline void mmo_write_octa_raw (bfd *abfd, bfd_vma value) { mmo_write_tetra_raw (abfd, (unsigned int) (value >> 32)); @@ -827,10 +829,10 @@ mmo_write_octa_raw (bfd *abfd, bfd_vma value) /* Write quoted contents. Intended to be called multiple times in sequence, followed by a call to mmo_flush_chunk. */ -static INLINE bfd_boolean +static inline bool mmo_write_chunk (bfd *abfd, const bfd_byte *loc, unsigned int len) { - bfd_boolean retval = TRUE; + bool retval = true; struct mmo_data_struct *mmop = abfd->tdata.mmo_data; /* Fill up a tetra from bytes remaining from a previous chunk. */ @@ -872,14 +874,14 @@ mmo_write_chunk (bfd *abfd, const bfd_byte *loc, unsigned int len) } if (! retval) - mmop->have_error = TRUE; + mmop->have_error = true; return retval; } /* Flush remaining bytes, from a previous mmo_write_chunk, zero-padded to 4 bytes. */ -static INLINE bfd_boolean +static inline bool mmo_flush_chunk (bfd *abfd) { if (abfd->tdata.mmo_data->byte_no != 0) @@ -896,12 +898,12 @@ mmo_flush_chunk (bfd *abfd) /* Same, but from a list. */ -static INLINE bfd_boolean +static inline bool mmo_write_chunk_list (bfd *abfd, mmo_data_list_type *datap) { for (; datap != NULL; datap = datap->next) if (! mmo_write_chunk (abfd, datap->data, datap->size)) - return FALSE; + return false; return mmo_flush_chunk (abfd); } @@ -910,7 +912,7 @@ mmo_write_chunk_list (bfd *abfd, mmo_data_list_type *datap) mmo_flush_chunk after calling this function. The location is only output if different than *LAST_VMAP, which is updated after this call. */ -static bfd_boolean +static bool mmo_write_loc_chunk (bfd *abfd, bfd_vma vma, const bfd_byte *loc, unsigned int len, bfd_vma *last_vmap) { @@ -955,11 +957,11 @@ mmo_write_loc_chunk (bfd *abfd, bfd_vma vma, const bfd_byte *loc, { _bfd_error_handler /* xgettext:c-format */ - (_("%B: attempt to emit contents at non-multiple-of-4" - " address %#Lx"), - abfd, vma); + (_("%pB: attempt to emit contents at non-multiple-of-4" + " address %#" PRIx64 ""), + abfd, (uint64_t) vma); bfd_set_error (bfd_error_bad_value); - return FALSE; + return false; } /* We always write the location as 64 bits; no use saving bytes @@ -977,7 +979,7 @@ mmo_write_loc_chunk (bfd *abfd, bfd_vma vma, const bfd_byte *loc, /* Same, but from a list. */ -static INLINE bfd_boolean +static inline bool mmo_write_loc_chunk_list (bfd *abfd, mmo_data_list_type *datap) { /* Get an address different than the address of the first chunk. */ @@ -986,7 +988,7 @@ mmo_write_loc_chunk_list (bfd *abfd, mmo_data_list_type *datap) for (; datap != NULL; datap = datap->next) if (! mmo_write_loc_chunk (abfd, datap->where, datap->data, datap->size, &last_vma)) - return FALSE; + return false; return mmo_flush_chunk (abfd); } @@ -1139,14 +1141,13 @@ mmo_get_spec_section (bfd *abfd, int spec_data_number) /* Add in the section flags we found to those bfd entered during this process and set the contents. */ - if (! bfd_set_section_flags (abfd, sec, - bfd_sec_flags_from_mmo_flags (flags) - | bfd_get_section_flags (abfd, sec) - | (section_length != 0 ? SEC_HAS_CONTENTS : 0)) - || ! bfd_set_section_size (abfd, sec, sec->size + section_length) + if (!bfd_set_section_flags (sec, + (bfd_sec_flags_from_mmo_flags (flags) + | bfd_section_flags (sec) + | (section_length != 0 ? SEC_HAS_CONTENTS : 0))) + || !bfd_set_section_size (sec, sec->size + section_length) /* Set VMA only for the first occurrence. */ - || (! sec->user_set_vma - && ! bfd_set_section_vma (abfd, sec, section_vma))) + || (!sec->user_set_vma && !bfd_set_section_vma (sec, section_vma))) { /* If we get an error for any of the calls above, signal more than just a format error for the spec section. */ @@ -1184,7 +1185,7 @@ mmo_get_byte (bfd *abfd) if (! abfd->tdata.mmo_data->have_error && bfd_bread (abfd->tdata.mmo_data->buf, 4, abfd) != 4) { - abfd->tdata.mmo_data->have_error = TRUE; + abfd->tdata.mmo_data->have_error = true; /* A value somewhat safe against tripping on some inconsistency when mopping up after this error. */ @@ -1208,13 +1209,13 @@ mmo_write_byte (bfd *abfd, bfd_byte value) { if (! abfd->tdata.mmo_data->have_error && bfd_bwrite (abfd->tdata.mmo_data->buf, 4, abfd) != 4) - abfd->tdata.mmo_data->have_error = TRUE; + abfd->tdata.mmo_data->have_error = true; } } /* Create a symbol. */ -static bfd_boolean +static bool mmo_create_symbol (bfd *abfd, const char *symname, bfd_vma addr, enum mmo_sym_type sym_type, unsigned int serno) { @@ -1222,11 +1223,11 @@ mmo_create_symbol (bfd *abfd, const char *symname, bfd_vma addr, enum n = (struct mmo_symbol *) bfd_alloc (abfd, sizeof (struct mmo_symbol)); if (n == NULL) - return FALSE; + return false; n->name = bfd_alloc (abfd, strlen (symname) + 1); if (n->name == NULL) - return FALSE; + return false; strcpy (n->name, symname); @@ -1252,19 +1253,19 @@ mmo_create_symbol (bfd *abfd, const char *symname, bfd_vma addr, enum && !mmo_ignore_symbol_consistency (abfd)) { _bfd_error_handler - (_("%B: invalid mmo file: initialization value for $255" + (_("%pB: invalid mmo file: initialization value for $255" " is not `Main'\n"), abfd); bfd_set_error (bfd_error_bad_value); - return FALSE; + return false; } - return TRUE; + return true; } /* Read in symbols. */ -static bfd_boolean +static bool mmo_get_symbols (bfd *abfd) { /* @@ -1370,7 +1371,7 @@ SUBSECTION /* Check first if we have a bad hair day. */ if (abfd->tdata.mmo_data->have_error) - return FALSE; + return false; if (m & MMO3_LEFT) /* Traverse left trie. */ @@ -1399,12 +1400,12 @@ SUBSECTION _bfd_error_handler /* xgettext:c-format */ - (_("%B: unsupported wide character sequence" + (_("%pB: unsupported wide character sequence" " 0x%02X 0x%02X after symbol name starting with `%s'\n"), abfd, c, c2, abfd->tdata.mmo_data->lop_stab_symbol); bfd_set_error (bfd_error_bad_value); - abfd->tdata.mmo_data->have_error = TRUE; - return FALSE; + abfd->tdata.mmo_data->have_error = true; + return false; } else c = c2; @@ -1458,7 +1459,7 @@ SUBSECTION abfd->tdata.mmo_data->lop_stab_symbol + 1, addr, sym_type, serno)) - abfd->tdata.mmo_data->have_error = TRUE; + abfd->tdata.mmo_data->have_error = true; } if (m & MMO3_MIDDLE) @@ -1480,7 +1481,7 @@ SUBSECTION If there's new contents, allocate to the next multiple of MMO_SEC_CONTENTS_CHUNK_SIZE. */ -static INLINE bfd_byte * +static bfd_byte * mmo_get_loc (asection *sec, bfd_vma vma, int size) { bfd_size_type allocated_size; @@ -1564,9 +1565,8 @@ mmo_get_loc (asection *sec, bfd_vma vma, int size) /* We get here for the first time (at other times too) for this section. Say we have contents. */ - if (! bfd_set_section_flags (sec->owner, sec, - bfd_get_section_flags (sec->owner, sec) - | SEC_HAS_CONTENTS)) + if (!bfd_set_section_flags (sec, (bfd_section_flags (sec) + | SEC_HAS_CONTENTS))) return NULL; } } @@ -1589,14 +1589,14 @@ mmo_map_set_sizes (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, /* Read the mmo file and turn it into sections. */ -static bfd_boolean +static bool mmo_scan (bfd *abfd) { unsigned int i; unsigned int lineno = 1; - bfd_boolean error = FALSE; + bool error = false; bfd_vma vma = 0; - asection *sec = bfd_make_section_old_way (abfd, MMO_TEXT_SECTION_NAME); + asection *sec = NULL; asection *non_spec_sec = NULL; bfd_vma non_spec_vma = 0; bfd_size_type nbytes_read = 0; @@ -1633,7 +1633,7 @@ mmo_scan (bfd *abfd) default: _bfd_error_handler /* xgettext:c-format */ - (_("%B: invalid mmo file: unsupported lopcode `%d'\n"), + (_("%pB: invalid mmo file: unsupported lopcode `%d'\n"), abfd, buf[1]); bfd_set_error (bfd_error_bad_value); goto error_return; @@ -1644,7 +1644,7 @@ mmo_scan (bfd *abfd) { _bfd_error_handler /* xgettext:c-format */ - (_("%B: invalid mmo file: expected YZ = 1" + (_("%pB: invalid mmo file: expected YZ = 1" " got YZ = %d for lop_quote\n"), abfd, y*256+z); bfd_set_error (bfd_error_bad_value); @@ -1654,7 +1654,13 @@ mmo_scan (bfd *abfd) goto error_return; vma &= ~3; - mmo_xore_32 (sec, vma, bfd_get_32 (abfd, buf)); + if (sec == NULL) + sec = bfd_make_section_old_way (abfd, MMO_TEXT_SECTION_NAME); + if (!mmo_xore_32 (sec, vma, bfd_get_32 (abfd, buf))) + { + bfd_set_error (bfd_error_bad_value); + goto error_return; + } vma += 4; lineno++; break; @@ -1682,7 +1688,7 @@ mmo_scan (bfd *abfd) { _bfd_error_handler /* xgettext:c-format */ - (_("%B: invalid mmo file: expected z = 1 or z = 2," + (_("%pB: invalid mmo file: expected z = 1 or z = 2," " got z = %d for lop_loc\n"), abfd, z); bfd_set_error (bfd_error_bad_value); @@ -1733,7 +1739,7 @@ mmo_scan (bfd *abfd) { _bfd_error_handler /* xgettext:c-format */ - (_("%B: invalid mmo file: expected z = 1 or z = 2," + (_("%pB: invalid mmo file: expected z = 1 or z = 2," " got z = %d for lop_fixo\n"), abfd, z); bfd_set_error (bfd_error_bad_value); @@ -1745,7 +1751,11 @@ mmo_scan (bfd *abfd) fixosec = mmo_decide_section (abfd, p); if (fixosec == NULL) goto error_return; - mmo_xore_64 (fixosec, p, vma); + if (!mmo_xore_64 (fixosec, p, vma)) + { + bfd_set_error (bfd_error_bad_value); + goto error_return; + } } break; @@ -1757,7 +1767,11 @@ mmo_scan (bfd *abfd) asection *fixrsec = mmo_decide_section (abfd, p); if (fixrsec == NULL) goto error_return; - mmo_xore_16 (fixrsec, p, yz); + if (!mmo_xore_16 (fixrsec, p, yz)) + { + bfd_set_error (bfd_error_bad_value); + goto error_return; + } } break; @@ -1774,7 +1788,7 @@ mmo_scan (bfd *abfd) { _bfd_error_handler /* xgettext:c-format */ - (_("%B: invalid mmo file: expected y = 0," + (_("%pB: invalid mmo file: expected y = 0," " got y = %d for lop_fixrx\n"), abfd, y); bfd_set_error (bfd_error_bad_value); @@ -1785,7 +1799,7 @@ mmo_scan (bfd *abfd) { _bfd_error_handler /* xgettext:c-format */ - (_("%B: invalid mmo file: expected z = 16 or z = 24," + (_("%pB: invalid mmo file: expected z = 16 or z = 24," " got z = %d for lop_fixrx\n"), abfd, z); bfd_set_error (bfd_error_bad_value); @@ -1810,7 +1824,7 @@ mmo_scan (bfd *abfd) { _bfd_error_handler /* xgettext:c-format */ - (_("%B: invalid mmo file: leading byte of operand word" + (_("%pB: invalid mmo file: leading byte of operand word" " must be 0 or 1, got %d for lop_fixrx\n"), abfd, buf[0]); bfd_set_error (bfd_error_bad_value); @@ -1820,7 +1834,11 @@ mmo_scan (bfd *abfd) fixrsec = mmo_decide_section (abfd, vma); if (fixrsec == NULL) goto error_return; - mmo_xore_32 (fixrsec, p, delta); + if (!mmo_xore_32 (fixrsec, p, delta)) + { + bfd_set_error (bfd_error_bad_value); + goto error_return; + } } break; @@ -1835,7 +1853,7 @@ mmo_scan (bfd *abfd) { _bfd_error_handler /* xgettext:c-format */ - (_("%B: cannot allocate file name for file number %d," + (_("%pB: cannot allocate file name for file number %d," " %d bytes\n"), abfd, y, z * 4 + 1); bfd_set_error (bfd_error_system_call); @@ -1857,7 +1875,7 @@ mmo_scan (bfd *abfd) { _bfd_error_handler /* xgettext:c-format */ - (_("%B: invalid mmo file: file number %d `%s'," + (_("%pB: invalid mmo file: file number %d `%s'," " was already entered as `%s'\n"), abfd, y, fname, file_names[y]); bfd_set_error (bfd_error_bad_value); @@ -1871,7 +1889,7 @@ mmo_scan (bfd *abfd) { _bfd_error_handler /* xgettext:c-format */ - (_("%B: invalid mmo file: file name for number %d" + (_("%pB: invalid mmo file: file name for number %d" " was not specified before use\n"), abfd, y); bfd_set_error (bfd_error_bad_value); @@ -1944,6 +1962,11 @@ mmo_scan (bfd *abfd) rsec->flags |= SEC_LINKER_CREATED; rsec->vma = z * 8; loc = mmo_get_loc (rsec, z * 8, (255 - z) * 8); + if (!loc) + { + bfd_set_error (bfd_error_bad_value); + goto error_return; + } bfd_put_64 (abfd, first_octa, loc); for (i = z + 1; i < 255; i++) @@ -1978,7 +2001,7 @@ mmo_scan (bfd *abfd) { _bfd_error_handler /* xgettext:c-format */ - (_("%B: invalid mmo file: fields y and z of lop_stab" + (_("%pB: invalid mmo file: fields y and z of lop_stab" " non-zero, y: %d, z: %d\n"), abfd, y, z); bfd_set_error (bfd_error_bad_value); @@ -2015,7 +2038,7 @@ mmo_scan (bfd *abfd) { _bfd_error_handler /* xgettext:c-format */ - (_("%B: invalid mmo file: lop_end not last item in" + (_("%pB: invalid mmo file: lop_end not last item in" " file\n"), abfd); bfd_set_error (bfd_error_bad_value); @@ -2029,7 +2052,7 @@ mmo_scan (bfd *abfd) { _bfd_error_handler /* xgettext:c-format */ - (_("%B: invalid mmo file: YZ of lop_end (%ld)" + (_("%pB: invalid mmo file: YZ of lop_end (%ld)" " not equal to the number of tetras to the preceding" " lop_stab (%ld)\n"), abfd, (long) (y * 256 + z), @@ -2046,7 +2069,13 @@ mmo_scan (bfd *abfd) else { /* This wasn't a lopcode, so store it in the current section. */ - mmo_xore_32 (sec, vma & ~3, bfd_get_32 (abfd, buf)); + if (sec == NULL) + sec = bfd_make_section_old_way (abfd, MMO_TEXT_SECTION_NAME); + if (!mmo_xore_32 (sec, vma & ~3, bfd_get_32 (abfd, buf))) + { + bfd_set_error (bfd_error_bad_value); + goto error_return; + } vma += 4; vma &= ~3; lineno++; @@ -2065,7 +2094,7 @@ mmo_scan (bfd *abfd) bfd_set_error (bfd_error_bad_value); error_return: - error = TRUE; + error = true; done: /* Mark the .text and .data section with their normal attribute if they contain anything. This is not redundant wrt. mmo_decide_section, @@ -2073,31 +2102,28 @@ mmo_scan (bfd *abfd) section flags must be set then. */ sec = bfd_get_section_by_name (abfd, MMO_TEXT_SECTION_NAME); if (sec != NULL - && (bfd_get_section_flags (abfd, sec) & SEC_HAS_CONTENTS) - && ! bfd_set_section_flags (abfd, sec, - bfd_get_section_flags (abfd, sec) - | SEC_ALLOC | SEC_LOAD | SEC_CODE)) - error = TRUE; + && (bfd_section_flags (sec) & SEC_HAS_CONTENTS) + && !bfd_set_section_flags (sec, (bfd_section_flags (sec) + | SEC_ALLOC | SEC_LOAD | SEC_CODE))) + error = true; sec = bfd_get_section_by_name (abfd, MMO_DATA_SECTION_NAME); if (sec != NULL - && (bfd_get_section_flags (abfd, sec) & SEC_HAS_CONTENTS) - && ! bfd_set_section_flags (abfd, sec, - bfd_get_section_flags (abfd, sec) - | SEC_ALLOC | SEC_LOAD)) - error = TRUE; + && (bfd_section_flags (sec) & SEC_HAS_CONTENTS) + && !bfd_set_section_flags (sec, (bfd_section_flags (sec) + | SEC_ALLOC | SEC_LOAD | SEC_DATA))) + error = true; /* Free whatever resources we took. */ for (i = 0; i < sizeof (file_names) / sizeof (file_names[0]); i++) - if (file_names[i]) - free (file_names[i]); + free (file_names[i]); return ! error; } /* A hook to set up object file dependent section information. For mmo, we point out the shape of allocated section contents. */ -static bfd_boolean +static bool mmo_new_section_hook (bfd *abfd, asection *newsect) { if (!newsect->used_by_bfd) @@ -2107,7 +2133,7 @@ mmo_new_section_hook (bfd *abfd, asection *newsect) newsect->used_by_bfd = bfd_zalloc (abfd, sizeof (struct mmo_section_data_struct)); if (!newsect->used_by_bfd) - return FALSE; + return false; } /* Always align to at least 32-bit words. */ @@ -2118,7 +2144,7 @@ mmo_new_section_hook (bfd *abfd, asection *newsect) /* We already have section contents loaded for sections that have contents. */ -static bfd_boolean +static bool mmo_get_section_contents (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, void * location, @@ -2141,7 +2167,7 @@ mmo_get_section_contents (bfd *abfd ATTRIBUTE_UNUSED, while (loc == NULL && (chunk_size /= 2) != 0); if (chunk_size == 0) - return FALSE; + return false; memcpy (location, loc, chunk_size); @@ -2149,7 +2175,7 @@ mmo_get_section_contents (bfd *abfd ATTRIBUTE_UNUSED, bytes_to_do -= chunk_size; offset += chunk_size; } - return TRUE; + return true; } /* Return the amount of memory needed to read the symbol table. */ @@ -2329,19 +2355,19 @@ mmo_sizeof_headers (bfd *abfd ATTRIBUTE_UNUSED, /* Write the (section-neutral) file preamble. */ -static bfd_boolean +static bool mmo_internal_write_header (bfd *abfd) { const char lop_pre_bfd[] = { LOP, LOP_PRE, 1, 1}; if (bfd_bwrite (lop_pre_bfd, 4, abfd) != 4) - return FALSE; + return false; /* Copy creation time of original file. */ if (bfd_bwrite (abfd->tdata.mmo_data->created, 4, abfd) != 4) - return FALSE; + return false; - return TRUE; + return true; } /* Write the LOP_POST record, with global register initializations. @@ -2349,7 +2375,7 @@ mmo_internal_write_header (bfd *abfd) registers at DATA. The Z = 255 field is filled in with the start-address. */ -static bfd_boolean +static bool mmo_internal_write_post (bfd *abfd, int z, asection *sec) { int i; @@ -2361,7 +2387,7 @@ mmo_internal_write_post (bfd *abfd, int z, asection *sec) bfd_byte *data = mmo_get_loc (sec, i * 8, 8); if (bfd_bwrite (data, 8, abfd) != 8) - return FALSE; + return false; } /* For Z == $255, we always emit the start location; supposedly Main, @@ -2432,25 +2458,25 @@ bfd_sec_flags_from_mmo_flags (flagword flags) /* Return TRUE iff the leading or trailing tetrabyte in SEC is defined and is 0. */ -static bfd_boolean +static bool mmo_has_leading_or_trailing_zero_tetra_p (bfd *abfd, asection *sec) { - bfd_vma secaddr = bfd_get_section_vma (abfd, sec); + bfd_vma secaddr = bfd_section_vma (sec); if (sec->size < 4) - return FALSE; + return false; if (bfd_get_32 (abfd, mmo_get_loc (sec, secaddr, 4)) == 0 && bfd_get_32 (abfd, mmo_get_loc (sec, secaddr + sec->size - 4, 4)) == 0) - return TRUE; + return true; - return FALSE; + return false; } /* Write a section. */ -static bfd_boolean +static bool mmo_internal_write_section (bfd *abfd, asection *sec) { /* We do it differently depending on what section this is: @@ -2467,7 +2493,7 @@ mmo_internal_write_section (bfd *abfd, asection *sec) if (strcmp (sec->name, MMO_TEXT_SECTION_NAME) == 0) { - bfd_vma secaddr = bfd_get_section_vma (abfd, sec); + bfd_vma secaddr = bfd_section_vma (sec); /* Because leading and trailing zeros are omitted in output, we need to specify the section boundaries so they're correct when the file @@ -2480,7 +2506,7 @@ mmo_internal_write_section (bfd *abfd, asection *sec) || mmo_has_leading_or_trailing_zero_tetra_p (abfd, sec))) { if (!mmo_write_section_description (abfd, sec)) - return FALSE; + return false; } /* FIXME: Output source file name and line number. */ @@ -2488,7 +2514,7 @@ mmo_internal_write_section (bfd *abfd, asection *sec) } else if (strcmp (sec->name, MMO_DATA_SECTION_NAME) == 0) { - bfd_vma secaddr = bfd_get_section_vma (abfd, sec); + bfd_vma secaddr = bfd_section_vma (sec); /* Same goes as for MMO_TEXT_SECTION_NAME above. */ if (sec->size != 0 @@ -2499,7 +2525,7 @@ mmo_internal_write_section (bfd *abfd, asection *sec) || mmo_has_leading_or_trailing_zero_tetra_p (abfd, sec))) { if (!mmo_write_section_description (abfd, sec)) - return FALSE; + return false; } return mmo_write_loc_chunk_list (abfd, mmo_section_data (sec)->head); @@ -2510,9 +2536,9 @@ mmo_internal_write_section (bfd *abfd, asection *sec) /* This would normally be an abort call since this can't happen, but we don't do that. */ bfd_set_error (bfd_error_bad_value); - return FALSE; + return false; } - else if (CONST_STRNEQ (sec->name, MMIX_OTHER_SPEC_SECTION_PREFIX)) + else if (startswith (sec->name, MMIX_OTHER_SPEC_SECTION_PREFIX)) { int n = atoi (sec->name + strlen (MMIX_OTHER_SPEC_SECTION_PREFIX)); @@ -2522,15 +2548,15 @@ mmo_internal_write_section (bfd *abfd, asection *sec) } /* Ignore sections that are just allocated or empty; we write out _contents_ here. */ - else if ((bfd_get_section_flags (abfd, sec) & SEC_HAS_CONTENTS) != 0 + else if ((bfd_section_flags (sec) & SEC_HAS_CONTENTS) != 0 && sec->size != 0) { if (!mmo_write_section_description (abfd, sec)) - return FALSE; + return false; /* Writing a LOP_LOC ends the LOP_SPEC data, and makes data actually loaded. */ - if (bfd_get_section_flags (abfd, sec) & SEC_LOAD) + if (bfd_section_flags (sec) & SEC_LOAD) return (! abfd->tdata.mmo_data->have_error && mmo_write_loc_chunk_list (abfd, mmo_section_data (sec)->head)); @@ -2539,12 +2565,12 @@ mmo_internal_write_section (bfd *abfd, asection *sec) } /* Some section without contents. */ - return TRUE; + return true; } /* Write the description of a section, extended-mmo-style. */ -static bfd_boolean +static bool mmo_write_section_description (bfd *abfd, asection *sec) { /* Keep the following document-comment formatted the way it is. */ @@ -2649,16 +2675,15 @@ EXAMPLE for all alien sections; perhaps mmo.em should clear that flag. Might be related to weak references. */ mmo_write_tetra (abfd, - mmo_sec_flags_from_bfd_flags - (bfd_get_section_flags (abfd, sec))); + mmo_sec_flags_from_bfd_flags (bfd_section_flags (sec))); mmo_write_octa (abfd, sec->size); - mmo_write_octa (abfd, bfd_get_section_vma (abfd, sec)); - return TRUE; + mmo_write_octa (abfd, bfd_section_vma (sec)); + return true; } /* We save up all data before output. */ -static bfd_boolean +static bool mmo_set_section_contents (bfd *abfd ATTRIBUTE_UNUSED, sec_ptr sec, const void *location, file_ptr offset, bfd_size_type bytes_to_do) @@ -2678,7 +2703,7 @@ mmo_set_section_contents (bfd *abfd ATTRIBUTE_UNUSED, sec_ptr sec, while (loc == NULL && (chunk_size /= 2) != 0); if (chunk_size == 0) - return FALSE; + return false; memcpy (loc, location, chunk_size); @@ -2686,12 +2711,12 @@ mmo_set_section_contents (bfd *abfd ATTRIBUTE_UNUSED, sec_ptr sec, bytes_to_do -= chunk_size; offset += chunk_size; } - return TRUE; + return true; } /* Add a symbol to a trie-tree. */ -static bfd_boolean +static bool mmo_internal_add_3_sym (bfd *abfd, struct mmo_symbol_trie *rootp, const struct mmo_symbol *symp) { @@ -2740,14 +2765,14 @@ mmo_internal_add_3_sym (bfd *abfd, struct mmo_symbol_trie *rootp, { _bfd_error_handler /* xgettext:c-format */ - (_("%B: invalid symbol table: duplicate symbol `%s'\n"), + (_("%pB: invalid symbol table: duplicate symbol `%s'\n"), abfd, trie->sym.name); bfd_set_error (bfd_error_bad_value); - return FALSE; + return false; } memcpy (&trie->sym, symp, sizeof *symp); - return TRUE; + return true; } /* Find out the length of the serialized version of a trie in bytes. */ @@ -2915,7 +2940,7 @@ mmo_internal_3_dump (bfd *abfd, struct mmo_symbol_trie *trie) /* Write symbols in mmo format. Also write the lop_end terminator. */ -static bfd_boolean +static bool mmo_write_symbols_and_terminator (bfd *abfd) { int count = bfd_get_symcount (abfd); @@ -2944,9 +2969,10 @@ mmo_write_symbols_and_terminator (bfd *abfd) symbols. Make sure we have room for it. */ table = bfd_alloc (abfd, (count + 1) * sizeof (asymbol *)); if (table == NULL) - return FALSE; + return false; - memcpy (table, orig_table, count * sizeof (asymbol *)); + if (count != 0) + memcpy (table, orig_table, count * sizeof (asymbol *)); /* Move :Main (if there is one) to the first position. This is necessary to get the same layout of the trie-tree when linking as @@ -2983,11 +3009,11 @@ mmo_write_symbols_and_terminator (bfd *abfd) _bfd_error_handler /* xgettext:c-format */ - (_("%B: Bad symbol definition: `Main' set to %s rather" + (_("%pB: bad symbol definition: `Main' set to %s rather" " than the start address %s\n"), abfd, vmas_main, vmas_start); bfd_set_error (bfd_error_bad_value); - return FALSE; + return false; } break; } @@ -3057,7 +3083,7 @@ mmo_write_symbols_and_terminator (bfd *abfd) sym.serno = serno++; if (! mmo_internal_add_3_sym (abfd, &root, &sym)) - return FALSE; + return false; } } } @@ -3082,7 +3108,7 @@ mmo_write_symbols_and_terminator (bfd *abfd) _bfd_error_handler /* xgettext:c-format */ - (_("%B: warning: symbol table too large for mmo, larger than 65535" + (_("%pB: warning: symbol table too large for mmo, larger than 65535" " 32-bit words: %d. Only `Main' will be emitted.\n"), abfd, trie_len); @@ -3100,7 +3126,7 @@ mmo_write_symbols_and_terminator (bfd *abfd) root.right = NULL; if (! mmo_internal_add_3_sym (abfd, &root, &sym)) - return FALSE; + return false; root.symchar = ':'; root.middle = root.left; @@ -3116,7 +3142,7 @@ mmo_write_symbols_and_terminator (bfd *abfd) /* Put out the lop_stab mark. */ bfd_put_32 (abfd, (LOP << 24) | (LOP_STAB << 16), buf); if (bfd_bwrite (buf, 4, abfd) != 4) - return FALSE; + return false; /* Dump out symbols. */ mmo_internal_3_dump (abfd, &root); @@ -3128,12 +3154,12 @@ mmo_write_symbols_and_terminator (bfd *abfd) diagnostic and fail "normally". */ _bfd_error_handler /* xgettext:c-format */ - (_("%B: internal error, symbol table changed size from %d to %d" + (_("%pB: internal error, symbol table changed size from %d to %d" " words\n"), abfd, trie_len, (abfd->tdata.mmo_data->byte_no + 3)/4); bfd_set_error (bfd_error_bad_value); - return FALSE; + return false; } /* Dump out remaining bytes in the buffer and handle I/O errors by @@ -3146,7 +3172,7 @@ mmo_write_symbols_and_terminator (bfd *abfd) if (abfd->tdata.mmo_data->have_error || bfd_bwrite (abfd->tdata.mmo_data->buf, 4, abfd) != 4) - return FALSE; + return false; } bfd_put_32 (abfd, (LOP << 24) | (LOP_END << 16) | trie_len, buf); @@ -3174,18 +3200,18 @@ mmo_write_section_unless_reg_contents (bfd *abfd, asection *sec, void *p) /* Exclude the convenience register section. */ if (strcmp (sec->name, MMIX_REG_SECTION_NAME) == 0) { - if (bfd_get_section_flags (abfd, sec) & SEC_HAS_CONTENTS) + if (bfd_section_flags (sec) & SEC_HAS_CONTENTS) { /* Make sure it hasn't got contents. It seems impossible to make it carry contents, so we don't have a test-case for this. */ _bfd_error_handler /* xgettext:c-format */ - (_("%B: internal error, internal register section %A had" + (_("%pB: internal error, internal register section %pA had" " contents\n"), abfd, sec); bfd_set_error (bfd_error_bad_value); - infop->retval = FALSE; + infop->retval = false; return; } @@ -3198,23 +3224,23 @@ mmo_write_section_unless_reg_contents (bfd *abfd, asection *sec, void *p) /* Do the actual output of a file. Assumes mmo_set_section_contents is already called. */ -static bfd_boolean +static bool mmo_write_object_contents (bfd *abfd) { struct mmo_write_sec_info wsecinfo; /* First, there are a few words of preamble. */ if (! mmo_internal_write_header (abfd)) - return FALSE; + return false; wsecinfo.reg_section = NULL; - wsecinfo.retval = TRUE; + wsecinfo.retval = true; bfd_map_over_sections (abfd, mmo_write_section_unless_reg_contents, &wsecinfo); if (! wsecinfo.retval) - return FALSE; + return false; if (wsecinfo.reg_section != NULL) { @@ -3232,31 +3258,31 @@ mmo_write_object_contents (bfd *abfd) if (sec->size == 0) /* There must always be at least one such register. */ _bfd_error_handler - (_("%B: no initialized registers; section length 0\n"), + (_("%pB: no initialized registers; section length 0\n"), abfd); else if (sec->vma > (256 - 32) * 8) /* Provide better error message for the case of too many global registers. */ _bfd_error_handler /* xgettext:c-format */ - (_("%B: too many initialized registers; section length %Ld"), - abfd, sec->size); + (_("%pB: too many initialized registers; section length %" PRId64), + abfd, (int64_t) sec->size); else _bfd_error_handler /* xgettext:c-format */ - (_("%B: invalid start address for initialized registers of" - " length %Ld: %#Lx"), - abfd, sec->size, sec->vma); + (_("%pB: invalid start address for initialized registers of" + " length %" PRId64 ": %#" PRIx64), + abfd, (int64_t) sec->size, (uint64_t) sec->vma); - return FALSE; + return false; } if (! mmo_internal_write_post (abfd, z, sec)) - return FALSE; + return false; } else if (! mmo_internal_write_post (abfd, 255, NULL)) - return FALSE; + return false; return mmo_write_symbols_and_terminator (abfd); } @@ -3275,8 +3301,7 @@ mmo_write_object_contents (bfd *abfd) /* Perhaps we need to adjust this one; mmo labels (originally) without a leading ':' might more appropriately be called local. */ #define mmo_bfd_is_local_label_name bfd_generic_is_local_label_name -#define mmo_bfd_is_target_special_symbol \ - ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false_any) +#define mmo_bfd_is_target_special_symbol _bfd_bool_bfd_asymbol_false #define mmo_get_symbol_version_string \ _bfd_nosymbols_get_symbol_version_string @@ -3315,10 +3340,12 @@ mmo_write_object_contents (bfd *abfd) #define mmo_bfd_relax_section bfd_generic_relax_section #define mmo_bfd_merge_sections bfd_generic_merge_sections #define mmo_bfd_is_group_section bfd_generic_is_group_section +#define mmo_bfd_group_name bfd_generic_group_name #define mmo_bfd_discard_group bfd_generic_discard_group #define mmo_section_already_linked \ _bfd_generic_section_already_linked #define mmo_bfd_define_common_symbol bfd_generic_define_common_symbol +#define mmo_bfd_link_hide_symbol _bfd_generic_link_hide_symbol #define mmo_bfd_define_start_stop bfd_generic_define_start_stop /* We want to copy time of creation, otherwise we'd use @@ -3350,6 +3377,7 @@ const bfd_target mmix_mmo_vec = ' ', /* ar_pad_char */ 16, /* ar_max_namelen */ 0, /* match priority. */ + TARGET_KEEP_UNUSED_SECTION_SYMBOLS, /* keep unused section symbols. */ bfd_getb64, bfd_getb_signed_64, bfd_putb64, bfd_getb32, bfd_getb_signed_32, bfd_putb32, bfd_getb16, bfd_getb_signed_16, bfd_putb16, /* data */ @@ -3364,16 +3392,16 @@ const bfd_target mmix_mmo_vec = _bfd_dummy_target, }, { - bfd_false, + _bfd_bool_bfd_false_error, mmo_mkobject, - bfd_false, - bfd_false, + _bfd_bool_bfd_false_error, + _bfd_bool_bfd_false_error, }, { /* bfd_write_contents */ - bfd_false, + _bfd_bool_bfd_false_error, mmo_write_object_contents, - bfd_false, - bfd_false, + _bfd_bool_bfd_false_error, + _bfd_bool_bfd_false_error, }, BFD_JUMP_TABLE_GENERIC (mmo),