X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=bfd%2Fsom.c;h=5308ac5aa9ece42c2ce43f8afa0e2d4d4188fde3;hb=eec8bf7eab693186badfd5285cf713d3e22205e2;hp=8e8960ed83f36db237fe5bb117243479b74e5127;hpb=ef4e5ba50c76511d4306edf1526c15269f1d7747;p=deliverable%2Fbinutils-gdb.git diff --git a/bfd/som.c b/bfd/som.c index 8e8960ed83..5308ac5aa9 100644 --- a/bfd/som.c +++ b/bfd/som.c @@ -1,5 +1,5 @@ /* bfd back-end for HP PA-RISC SOM objects. - Copyright (C) 1990-2020 Free Software Foundation, Inc. + Copyright (C) 1990-2021 Free Software Foundation, Inc. Contributed by the Center for Software Science at the University of Utah. @@ -22,7 +22,6 @@ 02110-1301, USA. */ #include "sysdep.h" -#include "alloca-conf.h" #include "bfd.h" #include "libiberty.h" #include "libbfd.h" @@ -33,12 +32,12 @@ static bfd_reloc_status_type hppa_som_reloc (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **); -static bfd_boolean som_mkobject (bfd *); -static bfd_boolean som_is_space (asection *); -static bfd_boolean som_is_subspace (asection *); +static bool som_mkobject (bfd *); +static bool som_is_space (asection *); +static bool som_is_subspace (asection *); static int compare_subspaces (const void *, const void *); -static unsigned long som_compute_checksum (struct som_external_header *); -static bfd_boolean som_build_and_write_symbol_table (bfd *); +static uint32_t som_compute_checksum (struct som_external_header *); +static bool som_build_and_write_symbol_table (bfd *); static unsigned int som_slurp_symbol_table (bfd *); /* Magic not defined in standard HP-UX header files until 8.0. */ @@ -114,7 +113,7 @@ static unsigned int som_slurp_symbol_table (bfd *); Note one side effect of using a R_PREV_FIXUP is the relocation that is being repeated moves to the front of the queue. */ -struct reloc_queue +static struct reloc_queue { unsigned char *reloc; unsigned int size; @@ -637,7 +636,7 @@ static const int comp3_opcodes[] = #endif #define SOM_HOWTO(TYPE, NAME) \ - HOWTO(TYPE, 0, 0, 32, FALSE, 0, 0, hppa_som_reloc, NAME, FALSE, 0, 0, FALSE) + HOWTO(TYPE, 0, 0, 32, false, 0, 0, hppa_som_reloc, NAME, false, 0, 0, false) static reloc_howto_type som_hppa_howto_table[] = { @@ -1425,7 +1424,7 @@ hppa_som_gen_reloc_type (bfd *abfd, /* The difference of two symbols needs *very* special handling. */ if (sym_diff) { - bfd_size_type amt = sizeof (int); + size_t amt = sizeof (int); final_types[0] = bfd_alloc (abfd, amt); final_types[1] = bfd_alloc (abfd, amt); @@ -1509,7 +1508,7 @@ hppa_som_gen_reloc_type (bfd *abfd, /* The difference of two symbols needs *very* special handling. */ if (sym_diff) { - bfd_size_type amt = sizeof (int); + size_t amt = sizeof (int); final_types[0] = bfd_alloc (abfd, amt); final_types[1] = bfd_alloc (abfd, amt); @@ -1548,7 +1547,7 @@ hppa_som_gen_reloc_type (bfd *abfd, /* If we have short and long pcrel modes, then generate the proper mode selector, then the pcrel relocation. Redundant selectors will be eliminated as the relocs are sized and emitted. */ - bfd_size_type amt = sizeof (int); + size_t amt = sizeof (int); final_types[0] = bfd_alloc (abfd, amt); if (!final_types[0]) @@ -1945,7 +1944,7 @@ som_swap_lst_header_in (struct som_external_lst_header *src, /* Perform some initialization for an object. Save results of this initialization in the BFD. */ -static const bfd_target * +static bfd_cleanup som_object_setup (bfd *abfd, struct som_header *file_hdrp, struct som_exec_auxhdr *aux_hdrp, @@ -2060,7 +2059,7 @@ som_object_setup (bfd *abfd, + current_offset); obj_som_exec_data (abfd)->system_id = file_hdrp->system_id; - return abfd->xvec; + return _bfd_no_cleanup; } /* Convert all of the space and subspace info into BFD sections. Each space @@ -2069,7 +2068,7 @@ som_object_setup (bfd *abfd, BFD sections which correspond to spaces will overlap the sections for the associated subspaces. */ -static bfd_boolean +static bool setup_sections (bfd *abfd, struct som_header *file_hdr, unsigned long current_offset) @@ -2079,23 +2078,20 @@ setup_sections (bfd *abfd, unsigned int total_subspaces = 0; asection **subspace_sections = NULL; asection *section; - bfd_size_type amt; + size_t amt; /* First, read in space names. */ amt = file_hdr->space_strings_size; - if (amt == (bfd_size_type) -1) + if (amt == (size_t) -1) { bfd_set_error (bfd_error_no_memory); goto error_return; } - space_strings = bfd_malloc (amt + 1); - if (space_strings == NULL && amt != 0) - goto error_return; - if (bfd_seek (abfd, current_offset + file_hdr->space_strings_location, SEEK_SET) != 0) goto error_return; - if (bfd_bread (space_strings, amt, abfd) != amt) + space_strings = (char *) _bfd_malloc_and_read (abfd, amt + 1, amt); + if (space_strings == NULL) goto error_return; /* Make sure that the string table is NUL terminated. */ space_strings[amt] = 0; @@ -2200,6 +2196,9 @@ setup_sections (bfd *abfd, som_swap_subspace_dictionary_in (&ext_subspace, &subspace); /* Setup the subspace name string. */ + if (subspace.name >= file_hdr->space_strings_size) + goto error_return; + subspace_name = subspace.name + space_strings; amt = strlen (subspace_name) + 1; @@ -2344,7 +2343,12 @@ setup_sections (bfd *abfd, } /* Now that we've read in all the subspace records, we need to assign a target index to each subspace. */ - subspace_sections = bfd_malloc2 (total_subspaces, sizeof (asection *)); + if (_bfd_mul_overflow (total_subspaces, sizeof (asection *), &amt)) + { + bfd_set_error (bfd_error_file_too_big); + goto error_return; + } + subspace_sections = bfd_malloc (amt); if (subspace_sections == NULL) goto error_return; @@ -2364,27 +2368,20 @@ setup_sections (bfd *abfd, for (i = 0; i < total_subspaces; i++) subspace_sections[i]->target_index = i; - if (space_strings != NULL) - free (space_strings); - - if (subspace_sections != NULL) - free (subspace_sections); - - return TRUE; + free (space_strings); + free (subspace_sections); + return true; error_return: - if (space_strings != NULL) - free (space_strings); - - if (subspace_sections != NULL) - free (subspace_sections); - return FALSE; + free (space_strings); + free (subspace_sections); + return false; } /* Read in a SOM object and make it into a BFD. */ -static const bfd_target * +static bfd_cleanup som_object_p (bfd *abfd) { struct som_external_header ext_file_hdr; @@ -2393,7 +2390,7 @@ som_object_p (bfd *abfd) unsigned long current_offset = 0; struct som_external_lst_header ext_lst_header; struct som_external_som_entry ext_som_entry; - bfd_size_type amt; + size_t amt; unsigned int loc; #define ENTRY_SIZE sizeof (struct som_external_som_entry) @@ -2529,31 +2526,31 @@ som_object_p (bfd *abfd) /* Create a SOM object. */ -static bfd_boolean +static bool som_mkobject (bfd *abfd) { /* Allocate memory to hold backend information. */ abfd->tdata.som_data = bfd_zalloc (abfd, (bfd_size_type) sizeof (struct som_data_struct)); if (abfd->tdata.som_data == NULL) - return FALSE; - return TRUE; + return false; + return true; } /* Initialize some information in the file header. This routine makes not attempt at doing the right thing for a full executable; it is only meant to handle relocatable objects. */ -static bfd_boolean +static bool som_prep_headers (bfd *abfd) { struct som_header *file_hdr; asection *section; - bfd_size_type amt = sizeof (struct som_header); + size_t amt = sizeof (struct som_header); /* Make and attach a file header to the BFD. */ file_hdr = bfd_zalloc (abfd, amt); if (file_hdr == NULL) - return FALSE; + return false; obj_som_file_hdr (abfd) = file_hdr; if (abfd->flags & (EXEC_P | DYNAMIC)) @@ -2562,7 +2559,7 @@ som_prep_headers (bfd *abfd) amt = sizeof (struct som_exec_auxhdr); obj_som_exec_hdr (abfd) = bfd_zalloc (abfd, amt); if (obj_som_exec_hdr (abfd) == NULL) - return FALSE; + return false; if (abfd->flags & D_PAGED) file_hdr->a_magic = DEMAND_MAGIC; @@ -2604,7 +2601,7 @@ som_prep_headers (bfd *abfd) amt = sizeof (struct som_space_dictionary_record); som_section_data (section)->space_dict = bfd_zalloc (abfd, amt); if (som_section_data (section)->space_dict == NULL) - return FALSE; + return false; /* Set space attributes. Note most attributes of SOM spaces are set based on the subspaces it contains. */ som_section_data (section)->space_dict->loader_fix_index = -1; @@ -2626,7 +2623,7 @@ som_prep_headers (bfd *abfd) amt = sizeof (struct som_subspace_dictionary_record); som_section_data (section)->subspace_dict = bfd_zalloc (abfd, amt); if (som_section_data (section)->subspace_dict == NULL) - return FALSE; + return false; /* Set subspace attributes. Basic stuff is done here, additional attributes are filled in later as more information becomes @@ -2661,56 +2658,56 @@ som_prep_headers (bfd *abfd) som_section_data (section)->copy_data->dup_common; } } - return TRUE; + return true; } /* Return TRUE if the given section is a SOM space, FALSE otherwise. */ -static bfd_boolean +static bool som_is_space (asection *section) { /* If no copy data is available, then it's neither a space nor a subspace. */ if (som_section_data (section)->copy_data == NULL) - return FALSE; + return false; /* If the containing space isn't the same as the given section, then this isn't a space. */ if (som_section_data (section)->copy_data->container != section && (som_section_data (section)->copy_data->container->output_section != section)) - return FALSE; + return false; /* OK. Must be a space. */ - return TRUE; + return true; } /* Return TRUE if the given section is a SOM subspace, FALSE otherwise. */ -static bfd_boolean +static bool som_is_subspace (asection *section) { /* If no copy data is available, then it's neither a space nor a subspace. */ if (som_section_data (section)->copy_data == NULL) - return FALSE; + return false; /* If the containing space is the same as the given section, then this isn't a subspace. */ if (som_section_data (section)->copy_data->container == section || (som_section_data (section)->copy_data->container->output_section == section)) - return FALSE; + return false; /* OK. Must be a subspace. */ - return TRUE; + return true; } /* Return TRUE if the given space contains the given subspace. It is safe to assume space really is a space, and subspace really is a subspace. */ -static bfd_boolean +static bool som_is_container (asection *space, asection *subspace) { return (som_section_data (subspace)->copy_data->container == space) @@ -2798,12 +2795,16 @@ compare_subspaces (const void *arg1, const void *arg2) /* Perform various work in preparation for emitting the fixup stream. */ -static void +static bool som_prep_for_fixups (bfd *abfd, asymbol **syms, unsigned long num_syms) { unsigned long i; asection *section; asymbol **sorted_syms; + size_t amt; + + if (num_syms == 0) + return true; /* Most SOM relocations involving a symbol have a length which is dependent on the index of the symbol. So symbols which are @@ -2875,7 +2876,14 @@ som_prep_for_fixups (bfd *abfd, asymbol **syms, unsigned long num_syms) /* Sort a copy of the symbol table, rather than the canonical output symbol table. */ - sorted_syms = bfd_zalloc2 (abfd, num_syms, sizeof (asymbol *)); + if (_bfd_mul_overflow (num_syms, sizeof (asymbol *), &amt)) + { + bfd_set_error (bfd_error_no_memory); + return false; + } + sorted_syms = bfd_zalloc (abfd, amt); + if (sorted_syms == NULL) + return false; memcpy (sorted_syms, syms, num_syms * sizeof (asymbol *)); qsort (sorted_syms, num_syms, sizeof (asymbol *), compare_syms); obj_som_sorted_syms (abfd) = sorted_syms; @@ -2891,9 +2899,10 @@ som_prep_for_fixups (bfd *abfd, asymbol **syms, unsigned long num_syms) else som_symbol_data (sorted_syms[i])->index = i; } + return true; } -static bfd_boolean +static bool som_write_fixups (bfd *abfd, unsigned long current_offset, unsigned int *total_reloc_sizep) @@ -2907,7 +2916,7 @@ som_write_fixups (bfd *abfd, unsigned int subspace_reloc_size = 0; unsigned int num_spaces = obj_som_file_hdr (abfd)->space_total; asection *section = abfd->sections; - bfd_size_type amt; + size_t amt; memset (tmp_space, 0, SOM_TMP_BUFSIZE); p = tmp_space; @@ -2962,7 +2971,7 @@ som_write_fixups (bfd *abfd, for this subspace in preparation for writing out its fixup stream. */ if (bfd_seek (abfd, current_offset + total_reloc_size, SEEK_SET) != 0) - return FALSE; + return false; /* Buffer space has already been allocated. Just perform some initialization here. */ @@ -3001,7 +3010,7 @@ som_write_fixups (bfd *abfd, { amt = p - tmp_space; if (bfd_bwrite ((void *) tmp_space, amt, abfd) != amt) - return FALSE; + return false; p = tmp_space; som_initialize_reloc_queue (reloc_queue); @@ -3286,7 +3295,7 @@ som_write_fixups (bfd *abfd, /* Scribble out the relocations. */ amt = p - tmp_space; if (bfd_bwrite ((void *) tmp_space, amt, abfd) != amt) - return FALSE; + return false; p = tmp_space; total_reloc_size += subspace_reloc_size; @@ -3296,12 +3305,12 @@ som_write_fixups (bfd *abfd, section = section->next; } *total_reloc_sizep = total_reloc_size; - return TRUE; + return true; } /* Write out the space/subspace string table. */ -static bfd_boolean +static bool som_write_space_strings (bfd *abfd, unsigned long current_offset, unsigned int *string_sizep) @@ -3313,16 +3322,16 @@ som_write_space_strings (bfd *abfd, char *p = tmp_space; unsigned int strings_size = 0; asection *section; - bfd_size_type amt; + size_t amt; bfd_size_type res; if (tmp_space == NULL) - return FALSE; + return false; /* Seek to the start of the space strings in preparation for writing them out. */ if (bfd_seek (abfd, (file_ptr) current_offset, SEEK_SET) != 0) - return FALSE; + return false; /* Walk through all the spaces and subspaces (order is not important) building up and writing string table entries for their names. */ @@ -3347,7 +3356,7 @@ som_write_space_strings (bfd *abfd, /* Flush buffer before refilling or reallocating. */ amt = p - tmp_space; if (bfd_bwrite ((void *) &tmp_space[0], amt, abfd) != amt) - return FALSE; + return false; /* Reallocate if now empty buffer still too small. */ if (5 + length > tmp_space_size) @@ -3403,14 +3412,14 @@ som_write_space_strings (bfd *abfd, res = bfd_bwrite ((void *) &tmp_space[0], amt, abfd); free (tmp_space); if (res != amt) - return FALSE; + return false; *string_sizep = strings_size; - return TRUE; + return true; } /* Write out the symbol string table. */ -static bfd_boolean +static bool som_write_symbol_strings (bfd *abfd, unsigned long current_offset, asymbol **syms, @@ -3425,11 +3434,11 @@ som_write_symbol_strings (bfd *abfd, char *tmp_space = bfd_malloc (tmp_space_size); char *p = tmp_space; unsigned int strings_size = 0; - bfd_size_type amt; + size_t amt; bfd_size_type res; if (tmp_space == NULL) - return FALSE; + return false; /* This gets a bit gruesome because of the compilation unit. The strings within the compilation unit are part of the symbol @@ -3441,7 +3450,7 @@ som_write_symbol_strings (bfd *abfd, /* Seek to the start of the space strings in preparation for writing them out. */ if (bfd_seek (abfd, (file_ptr) current_offset, SEEK_SET) != 0) - return FALSE; + return false; if (compilation_unit) { @@ -3478,7 +3487,7 @@ som_write_symbol_strings (bfd *abfd, /* Flush buffer before refilling or reallocating. */ amt = p - tmp_space; if (bfd_bwrite ((void *) &tmp_space[0], amt, abfd) != amt) - return FALSE; + return false; /* Reallocate if now empty buffer still too small. */ if (5 + length > tmp_space_size) @@ -3533,7 +3542,7 @@ som_write_symbol_strings (bfd *abfd, /* Flush buffer before refilling or reallocating. */ amt = p - tmp_space; if (bfd_bwrite ((void *) &tmp_space[0], amt, abfd) != amt) - return FALSE; + return false; /* Reallocate if now empty buffer still too small. */ if (5 + length > tmp_space_size) @@ -3579,17 +3588,17 @@ som_write_symbol_strings (bfd *abfd, res = bfd_bwrite ((void *) &tmp_space[0], amt, abfd); free (tmp_space); if (res != amt) - return FALSE; + return false; *string_sizep = strings_size; - return TRUE; + return true; } /* Compute variable information to be placed in the SOM headers, space/subspace dictionaries, relocation streams, etc. Begin writing parts of the object file. */ -static bfd_boolean +static bool som_begin_writing (bfd *abfd) { unsigned long current_offset = 0; @@ -3635,7 +3644,7 @@ som_begin_writing (bfd *abfd) bfd_size_type len; if (bfd_seek (abfd, (file_ptr) current_offset, SEEK_SET) != 0) - return FALSE; + return false; /* Write the aux_id structure and the string length. */ len = sizeof (struct som_external_string_auxhdr); @@ -3644,7 +3653,7 @@ som_begin_writing (bfd *abfd) som_swap_string_auxhdr_out (obj_som_version_hdr (abfd), &ext_string_auxhdr); if (bfd_bwrite (&ext_string_auxhdr, len, abfd) != len) - return FALSE; + return false; /* Write the version string. */ len = obj_som_version_hdr (abfd)->header_id.length - 4; @@ -3652,7 +3661,7 @@ som_begin_writing (bfd *abfd) current_offset += len; if (bfd_bwrite ((void *) obj_som_version_hdr (abfd)->string, len, abfd) != len) - return FALSE; + return false; } if (obj_som_copyright_hdr (abfd) != NULL) @@ -3661,7 +3670,7 @@ som_begin_writing (bfd *abfd) bfd_size_type len; if (bfd_seek (abfd, (file_ptr) current_offset, SEEK_SET) != 0) - return FALSE; + return false; /* Write the aux_id structure and the string length. */ len = sizeof (struct som_external_string_auxhdr); @@ -3670,7 +3679,7 @@ som_begin_writing (bfd *abfd) som_swap_string_auxhdr_out (obj_som_copyright_hdr (abfd), &ext_string_auxhdr); if (bfd_bwrite (&ext_string_auxhdr, len, abfd) != len) - return FALSE; + return false; /* Write the copyright string. */ len = obj_som_copyright_hdr (abfd)->header_id.length - 4; @@ -3678,7 +3687,7 @@ som_begin_writing (bfd *abfd) current_offset += len; if (bfd_bwrite ((void *) obj_som_copyright_hdr (abfd)->string, len, abfd) != len) - return FALSE; + return false; } /* Next comes the initialization pointers; we have no initialization @@ -3728,7 +3737,7 @@ som_begin_writing (bfd *abfd) /* Scribble out the space strings. */ if (! som_write_space_strings (abfd, current_offset, &strings_size)) - return FALSE; + return false; /* Record total string table size in the header and update the current offset. */ @@ -3925,9 +3934,9 @@ som_begin_writing (bfd *abfd) if (abfd->flags & (EXEC_P | DYNAMIC)) current_offset = SOM_ALIGN (current_offset, PA_PAGESIZE); if (bfd_seek (abfd, (file_ptr) current_offset - 1, SEEK_SET) != 0) - return FALSE; + return false; if (bfd_bwrite ((void *) "", (bfd_size_type) 1, abfd) != 1) - return FALSE; + return false; obj_som_file_hdr (abfd)->unloadable_sp_size = current_offset - obj_som_file_hdr (abfd)->unloadable_sp_location; @@ -3939,12 +3948,12 @@ som_begin_writing (bfd *abfd) /* Done. Store the total size of the SOM so far. */ obj_som_file_hdr (abfd)->som_length = current_offset; - return TRUE; + return true; } /* Finally, scribble out the various headers to the disk. */ -static bfd_boolean +static bool som_finish_writing (bfd *abfd) { int num_spaces = som_count_spaces (abfd); @@ -3955,7 +3964,7 @@ som_finish_writing (bfd *abfd) asection *section; unsigned long current_offset; unsigned int strings_size, total_reloc_size; - bfd_size_type amt; + size_t amt; struct som_external_header ext_header; /* We must set up the version identifier here as objcopy/strip copy @@ -4001,7 +4010,7 @@ som_finish_writing (bfd *abfd) if (! som_write_symbol_strings (abfd, current_offset, syms, num_syms, &strings_size, obj_som_compilation_unit (abfd))) - return FALSE; + return false; /* Record total string table size in header and update the current offset. */ @@ -4009,9 +4018,10 @@ som_finish_writing (bfd *abfd) current_offset += strings_size; /* Do prep work before handling fixups. */ - som_prep_for_fixups (abfd, - bfd_get_outsymbols (abfd), - bfd_get_symcount (abfd)); + if (!som_prep_for_fixups (abfd, + bfd_get_outsymbols (abfd), + bfd_get_symcount (abfd))) + return false; /* At the end of the file is the fixup stream which starts on a word boundary. */ @@ -4022,7 +4032,7 @@ som_finish_writing (bfd *abfd) /* Write the fixups and update fields in subspace headers which relate to the fixup stream. */ if (! som_write_fixups (abfd, current_offset, &total_reloc_size)) - return FALSE; + return false; /* Record the total size of the fixup stream in the file header. */ obj_som_file_hdr (abfd)->fixup_request_total = total_reloc_size; @@ -4033,7 +4043,7 @@ som_finish_writing (bfd *abfd) /* Now that the symbol table information is complete, build and write the symbol table. */ if (! som_build_and_write_symbol_table (abfd)) - return FALSE; + return false; /* Subspaces are written first so that we can set up information about them in their containing spaces as the subspace is written. */ @@ -4041,7 +4051,7 @@ som_finish_writing (bfd *abfd) /* Seek to the start of the subspace dictionary records. */ location = obj_som_file_hdr (abfd)->subspace_location; if (bfd_seek (abfd, location, SEEK_SET) != 0) - return FALSE; + return false; section = abfd->sections; /* Now for each loadable space write out records for its subspaces. */ @@ -4093,7 +4103,7 @@ som_finish_writing (bfd *abfd) (som_section_data (subsection)->subspace_dict, &ext_subspace_dict); amt = sizeof (struct som_subspace_dictionary_record); if (bfd_bwrite (&ext_subspace_dict, amt, abfd) != amt) - return FALSE; + return false; } /* Goto the next section. */ section = section->next; @@ -4151,7 +4161,7 @@ som_finish_writing (bfd *abfd) (som_section_data (subsection)->subspace_dict, &ext_subspace_dict); amt = sizeof (struct som_subspace_dictionary_record); if (bfd_bwrite (&ext_subspace_dict, amt, abfd) != amt) - return FALSE; + return false; } /* Goto the next section. */ section = section->next; @@ -4164,7 +4174,7 @@ som_finish_writing (bfd *abfd) dictionary records. */ location = obj_som_file_hdr (abfd)->space_location; if (bfd_seek (abfd, location, SEEK_SET) != 0) - return FALSE; + return false; section = abfd->sections; for (i = 0; i < num_spaces; i++) @@ -4180,7 +4190,7 @@ som_finish_writing (bfd *abfd) &ext_space_dict); amt = sizeof (struct som_external_space_dictionary_record); if (bfd_bwrite (&ext_space_dict, amt, abfd) != amt) - return FALSE; + return false; /* Goto the next section. */ section = section->next; @@ -4193,14 +4203,14 @@ som_finish_writing (bfd *abfd) location = obj_som_file_hdr (abfd)->compiler_location; if (bfd_seek (abfd, location, SEEK_SET) != 0) - return FALSE; + return false; som_swap_compilation_unit_out (obj_som_compilation_unit (abfd), &ext_comp_unit); amt = sizeof (struct som_external_compilation_unit); if (bfd_bwrite (&ext_comp_unit, amt, abfd) != amt) - return FALSE; + return false; } /* Setting of the system_id has to happen very late now that copying of @@ -4222,10 +4232,10 @@ som_finish_writing (bfd *abfd) /* Only thing left to do is write out the file header. It is always at location zero. Seek there and write it. */ if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0) - return FALSE; + return false; amt = sizeof (struct som_external_header); if (bfd_bwrite (&ext_header, amt, abfd) != amt) - return FALSE; + return false; /* Now write the exec header. */ if (abfd->flags & (EXEC_P | DYNAMIC)) @@ -4255,32 +4265,33 @@ som_finish_writing (bfd *abfd) || exec_header->exec_dfile + exec_header->exec_dsize > som_length) { bfd_set_error (bfd_error_bad_value); - return FALSE; + return false; } som_swap_exec_auxhdr_out (exec_header, &ext_exec_header); if (bfd_seek (abfd, obj_som_file_hdr (abfd)->aux_header_location, SEEK_SET) != 0) - return FALSE; + return false; amt = sizeof (ext_exec_header); if (bfd_bwrite (&ext_exec_header, amt, abfd) != amt) - return FALSE; + return false; } - return TRUE; + return true; } /* Compute and return the checksum for a SOM file header. */ -static unsigned long +static uint32_t som_compute_checksum (struct som_external_header *hdr) { - unsigned long checksum, count, i; - unsigned long *buffer = (unsigned long *) hdr; + size_t count, i; + uint32_t checksum; + uint32_t *buffer = (uint32_t *) hdr; checksum = 0; - count = sizeof (struct som_external_header) / 4; + count = sizeof (*hdr) / sizeof (*buffer); for (i = 0; i < count; i++) checksum ^= *(buffer + i); @@ -4401,9 +4412,9 @@ som_bfd_derive_misc_symbol_info (bfd *abfd ATTRIBUTE_UNUSED, /* The secondary_def field is for "weak" symbols. */ if (sym->flags & BSF_WEAK) - info->secondary_def = TRUE; + info->secondary_def = true; else - info->secondary_def = FALSE; + info->secondary_def = false; /* The is_comdat, is_common and dup_common fields provide various flavors of common. @@ -4447,7 +4458,7 @@ som_bfd_derive_misc_symbol_info (bfd *abfd ATTRIBUTE_UNUSED, /* Build and write, in one big chunk, the entire symbol table for this BFD. */ -static bfd_boolean +static bool som_build_and_write_symbol_table (bfd *abfd) { unsigned int num_syms = bfd_get_symcount (abfd); @@ -4456,12 +4467,18 @@ som_build_and_write_symbol_table (bfd *abfd) struct som_external_symbol_dictionary_record *som_symtab = NULL; unsigned int i; bfd_size_type symtab_size; + size_t amt; /* Compute total symbol table size and allocate a chunk of memory to hold the symbol table as we build it. */ - som_symtab - = bfd_zmalloc2 (num_syms, - sizeof (struct som_external_symbol_dictionary_record)); + if (_bfd_mul_overflow (num_syms, + sizeof (struct som_external_symbol_dictionary_record), + &amt)) + { + bfd_set_error (bfd_error_no_memory); + return false; + } + som_symtab = bfd_zmalloc (amt); if (som_symtab == NULL && num_syms != 0) goto error_return; @@ -4500,25 +4517,24 @@ som_build_and_write_symbol_table (bfd *abfd) /* Everything is ready, seek to the right location and scribble out the symbol table. */ if (bfd_seek (abfd, symtab_location, SEEK_SET) != 0) - return FALSE; + goto error_return; symtab_size = num_syms; symtab_size *= sizeof (struct som_external_symbol_dictionary_record); if (bfd_bwrite ((void *) som_symtab, symtab_size, abfd) != symtab_size) goto error_return; - if (som_symtab != NULL) - free (som_symtab); - return TRUE; + free (som_symtab); + return true; + error_return: - if (som_symtab != NULL) - free (som_symtab); - return FALSE; + free (som_symtab); + return false; } /* Write an object in SOM format. */ -static bfd_boolean +static bool som_write_object_contents (bfd *abfd) { if (! abfd->output_has_begun) @@ -4526,7 +4542,7 @@ som_write_object_contents (bfd *abfd) /* Set up fixed parts of the file, space, and subspace headers. Notify the world that output has begun. */ som_prep_headers (abfd); - abfd->output_has_begun = TRUE; + abfd->output_has_begun = true; /* Start writing the object file. This include all the string tables, fixup streams, and other portions of the object file. */ som_begin_writing (abfd); @@ -4537,7 +4553,7 @@ som_write_object_contents (bfd *abfd) /* Read and save the string table associated with the given BFD. */ -static bfd_boolean +static bool som_slurp_string_table (bfd *abfd) { char *stringtab; @@ -4545,7 +4561,7 @@ som_slurp_string_table (bfd *abfd) /* Use the saved version if its available. */ if (obj_som_stringtab (abfd) != NULL) - return TRUE; + return true; /* I don't think this can currently happen, and I'm not sure it should really be an error, but it's better than getting unpredictable results @@ -4553,24 +4569,20 @@ som_slurp_string_table (bfd *abfd) if (obj_som_stringtab_size (abfd) == 0) { bfd_set_error (bfd_error_no_symbols); - return FALSE; + return false; } /* Allocate and read in the string table. */ + if (bfd_seek (abfd, obj_som_str_filepos (abfd), SEEK_SET) != 0) + return false; amt = obj_som_stringtab_size (abfd); - stringtab = bfd_zmalloc (amt); + stringtab = (char *) _bfd_malloc_and_read (abfd, amt, amt); if (stringtab == NULL) - return FALSE; - - if (bfd_seek (abfd, obj_som_str_filepos (abfd), SEEK_SET) != 0) - return FALSE; - - if (bfd_bread (stringtab, amt, abfd) != amt) - return FALSE; + return false; /* Save our results and return success. */ obj_som_stringtab (abfd) = stringtab; - return TRUE; + return true; } /* Return the amount of data (in bytes) required to hold the symbol @@ -4634,12 +4646,12 @@ bfd_section_from_som_symbol static unsigned int som_slurp_symbol_table (bfd *abfd) { - int symbol_count = bfd_get_symcount (abfd); - int symsize = sizeof (struct som_external_symbol_dictionary_record); + unsigned int symbol_count = bfd_get_symcount (abfd); + size_t symsize = sizeof (struct som_external_symbol_dictionary_record); char *stringtab; struct som_external_symbol_dictionary_record *buf = NULL, *bufp, *endbufp; - som_symbol_type *sym, *symbase; - bfd_size_type amt; + som_symbol_type *sym, *symbase = NULL; + size_t amt; /* Return saved value if it exists. */ if (obj_som_symtab (abfd) != NULL) @@ -4654,19 +4666,26 @@ som_slurp_symbol_table (bfd *abfd) stringtab = obj_som_stringtab (abfd); - symbase = bfd_zmalloc2 (symbol_count, sizeof (som_symbol_type)); - if (symbase == NULL) - goto error_return; - /* Read in the external SOM representation. */ - buf = bfd_malloc2 (symbol_count, symsize); - if (buf == NULL) - goto error_return; + if (_bfd_mul_overflow (symbol_count, symsize, &amt)) + { + bfd_set_error (bfd_error_file_too_big); + goto error_return; + } if (bfd_seek (abfd, obj_som_sym_filepos (abfd), SEEK_SET) != 0) goto error_return; - amt = symbol_count; - amt *= symsize; - if (bfd_bread (buf, amt, abfd) != amt) + buf = (struct som_external_symbol_dictionary_record *) + _bfd_malloc_and_read (abfd, amt, amt); + if (buf == NULL) + goto error_return; + + if (_bfd_mul_overflow (symbol_count, sizeof (som_symbol_type), &amt)) + { + bfd_set_error (bfd_error_file_too_big); + goto error_return; + } + symbase = bfd_zmalloc (amt); + if (symbase == NULL) goto error_return; /* Iterate over all the symbols and internalize them. */ @@ -4783,12 +4802,12 @@ som_slurp_symbol_table (bfd *abfd) && sym->symbol.name[strlen (sym->symbol.name) - 1] == '$' && !strcmp (sym->symbol.name, sym->symbol.section->name)) sym->symbol.flags |= BSF_SECTION_SYM; - else if (CONST_STRNEQ (sym->symbol.name, "L$0\002")) + else if (startswith (sym->symbol.name, "L$0\002")) { sym->symbol.flags |= BSF_SECTION_SYM; sym->symbol.name = sym->symbol.section->name; } - else if (CONST_STRNEQ (sym->symbol.name, "L$0\001")) + else if (startswith (sym->symbol.name, "L$0\001")) sym->symbol.flags |= BSF_DEBUGGING; /* Note increment at bottom of loop, since we skip some symbols @@ -4803,14 +4822,13 @@ som_slurp_symbol_table (bfd *abfd) /* Save our results and return success. */ obj_som_symtab (abfd) = symbase; successful_return: - if (buf != NULL) - free (buf); - return (TRUE); + free (buf); + return true; error_return: - if (buf != NULL) - free (buf); - return FALSE; + free (symbase); + free (buf); + return false; } /* Canonicalize a SOM symbol table. Return the number of entries @@ -4841,7 +4859,7 @@ som_canonicalize_symtab (bfd *abfd, asymbol **location) static asymbol * som_make_empty_symbol (bfd *abfd) { - bfd_size_type amt = sizeof (som_symbol_type); + size_t amt = sizeof (som_symbol_type); som_symbol_type *new_symbol_type = bfd_zalloc (abfd, amt); if (new_symbol_type == NULL) @@ -4883,7 +4901,7 @@ som_print_symbol (bfd *abfd, } } -static bfd_boolean +static bool som_bfd_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED, const char *name) { @@ -4909,7 +4927,7 @@ som_set_reloc_info (unsigned char *fixup, arelent *internal_relocs, asection *section, asymbol **symbols, - bfd_boolean just_count) + bool just_count) { unsigned int op, varname, deallocate_contents = 0; unsigned char *end_fixups = &fixup[end]; @@ -5204,8 +5222,7 @@ som_set_reloc_info (unsigned char *fixup, if (!bfd_malloc_and_get_section (section->owner, section, &contents)) { - if (contents != NULL) - free (contents); + free (contents); return (unsigned) -1; } section->contents = contents; @@ -5245,67 +5262,68 @@ som_set_reloc_info (unsigned char *fixup, set to TRUE to indicate it only needs a count of the number of actual relocations. */ -static bfd_boolean +static bool som_slurp_reloc_table (bfd *abfd, asection *section, asymbol **symbols, - bfd_boolean just_count) + bool just_count) { unsigned char *external_relocs; unsigned int fixup_stream_size; arelent *internal_relocs; unsigned int num_relocs; - bfd_size_type amt; + size_t amt; fixup_stream_size = som_section_data (section)->reloc_size; /* If there were no relocations, then there is nothing to do. */ if (section->reloc_count == 0) - return TRUE; + return true; /* If reloc_count is -1, then the relocation stream has not been parsed. We must do so now to know how many relocations exist. */ if (section->reloc_count == (unsigned) -1) { + /* Read in the external forms. */ + if (bfd_seek (abfd, obj_som_reloc_filepos (abfd) + section->rel_filepos, + SEEK_SET) != 0) + return false; amt = fixup_stream_size; - external_relocs = bfd_malloc (amt); + external_relocs = _bfd_malloc_and_read (abfd, amt, amt); if (external_relocs == NULL) - return FALSE; - /* Read in the external forms. */ - if (bfd_seek (abfd, - obj_som_reloc_filepos (abfd) + section->rel_filepos, - SEEK_SET) - != 0) - return FALSE; - if (bfd_bread (external_relocs, amt, abfd) != amt) - return FALSE; + return false; /* Let callers know how many relocations found. also save the relocation stream as we will need it again. */ section->reloc_count = som_set_reloc_info (external_relocs, fixup_stream_size, - NULL, NULL, NULL, TRUE); + NULL, NULL, NULL, true); som_section_data (section)->reloc_stream = external_relocs; } /* If the caller only wanted a count, then return now. */ if (just_count) - return TRUE; + return true; num_relocs = section->reloc_count; external_relocs = som_section_data (section)->reloc_stream; /* Return saved information about the relocations if it is available. */ if (section->relocation != NULL) - return TRUE; + return true; - internal_relocs = bfd_zalloc2 (abfd, num_relocs, sizeof (arelent)); + if (_bfd_mul_overflow (num_relocs, sizeof (arelent), &amt)) + { + bfd_set_error (bfd_error_file_too_big); + return false; + } + internal_relocs = bfd_zalloc (abfd, amt); if (internal_relocs == NULL) - return FALSE; + return false; /* Process and internalize the relocations. */ som_set_reloc_info (external_relocs, fixup_stream_size, - internal_relocs, section, symbols, FALSE); + internal_relocs, section, symbols, false); /* We're done with the external relocations. Free them. */ free (external_relocs); @@ -5313,7 +5331,7 @@ som_slurp_reloc_table (bfd *abfd, /* Save our results and return success. */ section->relocation = internal_relocs; - return TRUE; + return true; } /* Return the number of bytes required to store the relocation @@ -5326,7 +5344,7 @@ som_get_reloc_upper_bound (bfd *abfd, sec_ptr asect) and parse it to determine how many relocations exist. */ if (asect->flags & SEC_RELOC) { - if (! som_slurp_reloc_table (abfd, asect, NULL, TRUE)) + if (! som_slurp_reloc_table (abfd, asect, NULL, true)) return -1; return (asect->reloc_count + 1) * sizeof (arelent *); } @@ -5349,7 +5367,7 @@ som_canonicalize_reloc (bfd *abfd, arelent *tblptr; int count; - if (! som_slurp_reloc_table (abfd, section, symbols, FALSE)) + if (! som_slurp_reloc_table (abfd, section, symbols, false)) return -1; count = section->reloc_count; @@ -5366,16 +5384,16 @@ extern const bfd_target hppa_som_vec; /* A hook to set up object file dependent section information. */ -static bfd_boolean +static bool som_new_section_hook (bfd *abfd, asection *newsect) { if (!newsect->used_by_bfd) { - bfd_size_type amt = sizeof (struct som_section_data_struct); + size_t amt = sizeof (struct som_section_data_struct); newsect->used_by_bfd = bfd_zalloc (abfd, amt); if (!newsect->used_by_bfd) - return FALSE; + return false; } newsect->alignment_power = 3; @@ -5386,7 +5404,7 @@ som_new_section_hook (bfd *abfd, asection *newsect) /* Copy any private info we understand from the input symbol to the output symbol. */ -static bfd_boolean +static bool som_bfd_copy_private_symbol_data (bfd *ibfd, asymbol *isymbol, bfd *obfd, @@ -5398,37 +5416,37 @@ som_bfd_copy_private_symbol_data (bfd *ibfd, /* One day we may try to grok other private data. */ if (ibfd->xvec->flavour != bfd_target_som_flavour || obfd->xvec->flavour != bfd_target_som_flavour) - return FALSE; + return false; /* The only private information we need to copy is the argument relocation bits. */ output_symbol->tc_data.ap.hppa_arg_reloc = input_symbol->tc_data.ap.hppa_arg_reloc; - return TRUE; + return true; } /* Copy any private info we understand from the input section to the output section. */ -static bfd_boolean +static bool som_bfd_copy_private_section_data (bfd *ibfd, asection *isection, bfd *obfd, asection *osection) { - bfd_size_type amt; + size_t amt; /* One day we may try to grok other private data. */ if (ibfd->xvec->flavour != bfd_target_som_flavour || obfd->xvec->flavour != bfd_target_som_flavour || (!som_is_space (isection) && !som_is_subspace (isection))) - return TRUE; + return true; amt = sizeof (struct som_copyable_section_data_struct); som_section_data (osection)->copy_data = bfd_zalloc (obfd, amt); if (som_section_data (osection)->copy_data == NULL) - return FALSE; + return false; memcpy (som_section_data (osection)->copy_data, som_section_data (isection)->copy_data, @@ -5436,38 +5454,48 @@ som_bfd_copy_private_section_data (bfd *ibfd, /* Reparent if necessary. */ if (som_section_data (osection)->copy_data->container) - som_section_data (osection)->copy_data->container = - som_section_data (osection)->copy_data->container->output_section; + { + if (som_section_data (osection)->copy_data->container->output_section) + som_section_data (osection)->copy_data->container = + som_section_data (osection)->copy_data->container->output_section; + else + { + /* User has specified a subspace without its containing space. */ + _bfd_error_handler (_("%pB[%pA]: no output section for space %pA"), + obfd, osection, som_section_data (osection)->copy_data->container); + return false; + } + } - return TRUE; + return true; } /* Copy any private info we understand from the input bfd to the output bfd. */ -static bfd_boolean +static bool som_bfd_copy_private_bfd_data (bfd *ibfd, bfd *obfd) { /* One day we may try to grok other private data. */ if (ibfd->xvec->flavour != bfd_target_som_flavour || obfd->xvec->flavour != bfd_target_som_flavour) - return TRUE; + return true; /* Allocate some memory to hold the data we need. */ obj_som_exec_data (obfd) = bfd_zalloc (obfd, (bfd_size_type) sizeof (struct som_exec_data)); if (obj_som_exec_data (obfd) == NULL) - return FALSE; + return false; /* Now copy the data. */ memcpy (obj_som_exec_data (obfd), obj_som_exec_data (ibfd), sizeof (struct som_exec_data)); - return TRUE; + return true; } /* Display the SOM header. */ -static bfd_boolean +static bool som_bfd_print_private_bfd_data (bfd *abfd, void *farg) { struct som_exec_auxhdr *exec_header; @@ -5509,13 +5537,13 @@ som_bfd_print_private_bfd_data (bfd *abfd, void *farg) fprintf (f, " bss initializer %#lx\n", (long) exec_header->exec_bfill); } - return TRUE; + return true; } /* Set backend info for sections which can not be described in the BFD data structures. */ -bfd_boolean +bool bfd_som_set_section_attributes (asection *section, int defined, int private, @@ -5525,24 +5553,24 @@ bfd_som_set_section_attributes (asection *section, /* Allocate memory to hold the magic information. */ if (som_section_data (section)->copy_data == NULL) { - bfd_size_type amt = sizeof (struct som_copyable_section_data_struct); + size_t amt = sizeof (struct som_copyable_section_data_struct); som_section_data (section)->copy_data = bfd_zalloc (section->owner, amt); if (som_section_data (section)->copy_data == NULL) - return FALSE; + return false; } som_section_data (section)->copy_data->sort_key = sort_key; som_section_data (section)->copy_data->is_defined = defined; som_section_data (section)->copy_data->is_private = private; som_section_data (section)->copy_data->container = section; som_section_data (section)->copy_data->space_number = spnum; - return TRUE; + return true; } /* Set backend info for subsections which can not be described in the BFD data structures. */ -bfd_boolean +bool bfd_som_set_subsection_attributes (asection *section, asection *container, int access_ctr, @@ -5555,11 +5583,11 @@ bfd_som_set_subsection_attributes (asection *section, /* Allocate memory to hold the magic information. */ if (som_section_data (section)->copy_data == NULL) { - bfd_size_type amt = sizeof (struct som_copyable_section_data_struct); + size_t amt = sizeof (struct som_copyable_section_data_struct); som_section_data (section)->copy_data = bfd_zalloc (section->owner, amt); if (som_section_data (section)->copy_data == NULL) - return FALSE; + return false; } som_section_data (section)->copy_data->sort_key = sort_key; som_section_data (section)->copy_data->access_control_bits = access_ctr; @@ -5568,7 +5596,7 @@ bfd_som_set_subsection_attributes (asection *section, som_section_data (section)->copy_data->is_comdat = comdat; som_section_data (section)->copy_data->is_common = common; som_section_data (section)->copy_data->dup_common = dup_common; - return TRUE; + return true; } /* Set the full SOM symbol type. SOM needs far more symbol information @@ -5586,10 +5614,10 @@ bfd_som_set_symbol_type (asymbol *symbol, unsigned int type) /* Attach an auxiliary header to the BFD backend so that it may be written into the object file. */ -bfd_boolean +bool bfd_som_attach_aux_hdr (bfd *abfd, int type, char *string) { - bfd_size_type amt; + size_t amt; if (type == VERSION_AUX_ID) { @@ -5601,7 +5629,7 @@ bfd_som_attach_aux_hdr (bfd *abfd, int type, char *string) amt = sizeof (struct som_string_auxhdr) + len + pad; obj_som_version_hdr (abfd) = bfd_zalloc (abfd, amt); if (!obj_som_version_hdr (abfd)) - return FALSE; + return false; obj_som_version_hdr (abfd)->header_id.type = VERSION_AUX_ID; obj_som_version_hdr (abfd)->header_id.length = 4 + len + pad; obj_som_version_hdr (abfd)->string_length = len; @@ -5618,20 +5646,20 @@ bfd_som_attach_aux_hdr (bfd *abfd, int type, char *string) amt = sizeof (struct som_string_auxhdr) + len + pad; obj_som_copyright_hdr (abfd) = bfd_zalloc (abfd, amt); if (!obj_som_copyright_hdr (abfd)) - return FALSE; + return false; obj_som_copyright_hdr (abfd)->header_id.type = COPYRIGHT_AUX_ID; obj_som_copyright_hdr (abfd)->header_id.length = len + pad + 4; obj_som_copyright_hdr (abfd)->string_length = len; memcpy (obj_som_copyright_hdr (abfd)->string, string, len); memset (obj_som_copyright_hdr (abfd)->string + len, 0, pad); } - return TRUE; + return true; } /* Attach a compilation unit header to the BFD backend so that it may be written into the object file. */ -bfd_boolean +bool bfd_som_attach_compilation_unit (bfd *abfd, const char *name, const char *language_name, @@ -5643,14 +5671,14 @@ bfd_som_attach_compilation_unit (bfd *abfd, n = (struct som_compilation_unit *) bfd_zalloc (abfd, (bfd_size_type) sizeof (*n)); if (n == NULL) - return FALSE; + return false; #define STRDUP(f) \ if (f != NULL) \ { \ n->f.name = bfd_alloc (abfd, (bfd_size_type) strlen (f) + 1); \ if (n->f.name == NULL) \ - return FALSE; \ + return false; \ strcpy (n->f.name, f); \ } @@ -5663,10 +5691,10 @@ bfd_som_attach_compilation_unit (bfd *abfd, obj_som_compilation_unit (abfd) = n; - return TRUE; + return true; } -static bfd_boolean +static bool som_get_section_contents (bfd *abfd, sec_ptr section, void *location, @@ -5674,15 +5702,15 @@ som_get_section_contents (bfd *abfd, bfd_size_type count) { if (count == 0 || ((section->flags & SEC_HAS_CONTENTS) == 0)) - return TRUE; + return true; if ((bfd_size_type) (offset+count) > section->size || bfd_seek (abfd, (file_ptr) (section->filepos + offset), SEEK_SET) != 0 || bfd_bread (location, count, abfd) != count) - return FALSE; /* On error. */ - return TRUE; + return false; /* On error. */ + return true; } -static bfd_boolean +static bool som_set_section_contents (bfd *abfd, sec_ptr section, const void *location, @@ -5694,7 +5722,7 @@ som_set_section_contents (bfd *abfd, /* Set up fixed parts of the file, space, and subspace headers. Notify the world that output has begun. */ som_prep_headers (abfd); - abfd->output_has_begun = TRUE; + abfd->output_has_begun = true; /* Start writing the object file. This include all the string tables, fixup streams, and other portions of the object file. */ som_begin_writing (abfd); @@ -5704,20 +5732,20 @@ som_set_section_contents (bfd *abfd, are not generated at run time by the OS). */ if (!som_is_subspace (section) || ((section->flags & SEC_HAS_CONTENTS) == 0)) - return TRUE; + return true; /* Seek to the proper offset within the object file and write the data. */ offset += som_section_data (section)->subspace_dict->file_loc_init_value; if (bfd_seek (abfd, offset, SEEK_SET) != 0) - return FALSE; + return false; if (bfd_bwrite (location, count, abfd) != count) - return FALSE; - return TRUE; + return false; + return true; } -static bfd_boolean +static bool som_set_arch_mach (bfd *abfd, enum bfd_architecture arch, unsigned long machine) @@ -5726,7 +5754,7 @@ som_set_arch_mach (bfd *abfd, return bfd_default_set_arch_mach (abfd, arch, machine); } -static bfd_boolean +static bool som_find_nearest_line (bfd *abfd, asymbol **symbols, asection *section, @@ -5736,7 +5764,7 @@ som_find_nearest_line (bfd *abfd, unsigned int *line_ptr, unsigned int *discriminator_ptr) { - bfd_boolean found; + bool found; asymbol *func; bfd_vma low_func; asymbol **p; @@ -5748,13 +5776,13 @@ som_find_nearest_line (bfd *abfd, & found, filename_ptr, functionname_ptr, line_ptr, & somdata (abfd).line_info)) - return FALSE; + return false; if (found) - return TRUE; + return true; if (symbols == NULL) - return FALSE; + return false; /* Fallback: find function name from symbols table. */ func = NULL; @@ -5775,13 +5803,13 @@ som_find_nearest_line (bfd *abfd, } if (func == NULL) - return FALSE; + return false; *filename_ptr = NULL; *functionname_ptr = bfd_asymbol_name (func); *line_ptr = 0; - return TRUE; + return true; } static int @@ -5873,31 +5901,32 @@ som_get_symbol_info (bfd *ignore_abfd ATTRIBUTE_UNUSED, /* Count the number of symbols in the archive symbol table. Necessary so that we can allocate space for all the carsyms at once. */ -static bfd_boolean +static bool som_bfd_count_ar_symbols (bfd *abfd, struct som_lst_header *lst_header, symindex *count) { unsigned int i; unsigned char *hash_table; - bfd_size_type amt; + size_t amt; file_ptr lst_filepos; lst_filepos = bfd_tell (abfd) - sizeof (struct som_external_lst_header); - hash_table = bfd_malloc2 (lst_header->hash_size, 4); + /* Read in the hash table. The hash table is an array of 32-bit + file offsets which point to the hash chains. */ + if (_bfd_mul_overflow (lst_header->hash_size, 4, &amt)) + { + bfd_set_error (bfd_error_file_too_big); + return false; + } + hash_table = _bfd_malloc_and_read (abfd, amt, amt); if (hash_table == NULL && lst_header->hash_size != 0) goto error_return; /* Don't forget to initialize the counter! */ *count = 0; - /* Read in the hash table. The hash table is an array of 32-bit - file offsets which point to the hash chains. */ - amt = (bfd_size_type) lst_header->hash_size * 4; - if (bfd_bread ((void *) hash_table, amt, abfd) != amt) - goto error_return; - /* Walk each chain counting the number of symbols found on that particular chain. */ for (i = 0; i < lst_header->hash_size; i++) @@ -5949,20 +5978,18 @@ som_bfd_count_ar_symbols (bfd *abfd, (*count)++; } } - if (hash_table != NULL) - free (hash_table); - return TRUE; + free (hash_table); + return true; error_return: - if (hash_table != NULL) - free (hash_table); - return FALSE; + free (hash_table); + return false; } /* Fill in the canonical archive symbols (SYMS) from the archive described by ABFD and LST_HEADER. */ -static bfd_boolean +static bool som_bfd_fill_in_ar_symbols (bfd *abfd, struct som_lst_header *lst_header, carsym **syms) @@ -5971,19 +5998,21 @@ som_bfd_fill_in_ar_symbols (bfd *abfd, carsym *set = syms[0]; unsigned char *hash_table; struct som_external_som_entry *som_dict = NULL; - bfd_size_type amt; + size_t amt; file_ptr lst_filepos; unsigned int string_loc; lst_filepos = bfd_tell (abfd) - sizeof (struct som_external_lst_header); - hash_table = bfd_malloc2 (lst_header->hash_size, 4); - if (hash_table == NULL && lst_header->hash_size != 0) - goto error_return; /* Read in the hash table. The has table is an array of 32bit file offsets which point to the hash chains. */ - amt = (bfd_size_type) lst_header->hash_size * 4; - if (bfd_bread ((void *) hash_table, amt, abfd) != amt) + if (_bfd_mul_overflow (lst_header->hash_size, 4, &amt)) + { + bfd_set_error (bfd_error_file_too_big); + return false; + } + hash_table = _bfd_malloc_and_read (abfd, amt, amt); + if (hash_table == NULL && lst_header->hash_size != 0) goto error_return; /* Seek to and read in the SOM dictionary. We will need this to fill @@ -5991,16 +6020,17 @@ som_bfd_fill_in_ar_symbols (bfd *abfd, if (bfd_seek (abfd, lst_filepos + lst_header->dir_loc, SEEK_SET) != 0) goto error_return; - som_dict = bfd_malloc2 (lst_header->module_count, - sizeof (struct som_external_som_entry)); + if (_bfd_mul_overflow (lst_header->module_count, + sizeof (struct som_external_som_entry), &amt)) + { + bfd_set_error (bfd_error_file_too_big); + goto error_return; + } + som_dict = (struct som_external_som_entry *) + _bfd_malloc_and_read (abfd, amt, amt); if (som_dict == NULL && lst_header->module_count != 0) goto error_return; - amt = lst_header->module_count; - amt *= sizeof (struct som_external_som_entry); - if (bfd_bread ((void *) som_dict, amt, abfd) != amt) - goto error_return; - string_loc = lst_header->string_loc; /* Walk each chain filling in the carsyms as we go along. */ @@ -6047,12 +6077,9 @@ som_bfd_fill_in_ar_symbols (bfd *abfd, bfd_set_error (bfd_error_no_memory); goto error_return; } - name = bfd_zalloc (abfd, (bfd_size_type) len + 1); + name = (char *) _bfd_alloc_and_read (abfd, len + 1, len); if (!name) goto error_return; - if (bfd_bread (name, (bfd_size_type) len, abfd) != len) - goto error_return; - name[len] = 0; set->name = name; @@ -6101,12 +6128,9 @@ som_bfd_fill_in_ar_symbols (bfd *abfd, bfd_set_error (bfd_error_no_memory); goto error_return; } - name = bfd_zalloc (abfd, (bfd_size_type) len + 1); + name = (char *) _bfd_alloc_and_read (abfd, len + 1, len); if (!name) goto error_return; - - if (bfd_bread (name, (bfd_size_type) len, abfd) != len) - goto error_return; name[len] = 0; set->name = name; @@ -6127,23 +6151,19 @@ som_bfd_fill_in_ar_symbols (bfd *abfd, } /* If we haven't died by now, then we successfully read the entire archive symbol table. */ - if (hash_table != NULL) - free (hash_table); - if (som_dict != NULL) - free (som_dict); - return TRUE; + free (hash_table); + free (som_dict); + return true; error_return: - if (hash_table != NULL) - free (hash_table); - if (som_dict != NULL) - free (som_dict); - return FALSE; + free (hash_table); + free (som_dict); + return false; } /* Read in the LST from the archive. */ -static bfd_boolean +static bool som_slurp_armap (bfd *abfd) { struct som_external_lst_header ext_lst_header; @@ -6152,34 +6172,34 @@ som_slurp_armap (bfd *abfd) unsigned int parsed_size; struct artdata *ardata = bfd_ardata (abfd); char nextname[17]; - bfd_size_type amt = 16; + size_t amt = 16; int i = bfd_bread ((void *) nextname, amt, abfd); /* Special cases. */ if (i == 0) - return TRUE; + return true; if (i != 16) - return FALSE; + return false; if (bfd_seek (abfd, (file_ptr) -16, SEEK_CUR) != 0) - return FALSE; + return false; /* For archives without .o files there is no symbol table. */ - if (! CONST_STRNEQ (nextname, "/ ")) + if (! startswith (nextname, "/ ")) { - abfd->has_armap = FALSE; - return TRUE; + abfd->has_armap = false; + return true; } /* Read in and sanity check the archive header. */ amt = sizeof (struct ar_hdr); if (bfd_bread ((void *) &ar_header, amt, abfd) != amt) - return FALSE; + return false; if (strncmp (ar_header.ar_fmag, ARFMAG, 2)) { bfd_set_error (bfd_error_malformed_archive); - return FALSE; + return false; } /* How big is the archive symbol table entry? */ @@ -6188,7 +6208,7 @@ som_slurp_armap (bfd *abfd) if (errno != 0) { bfd_set_error (bfd_error_malformed_archive); - return FALSE; + return false; } /* Save off the file offset of the first real user data. */ @@ -6198,7 +6218,7 @@ som_slurp_armap (bfd *abfd) in just a minute. */ amt = sizeof (struct som_external_lst_header); if (bfd_bread ((void *) &ext_lst_header, amt, abfd) != amt) - return FALSE; + return false; som_swap_lst_header_in (&ext_lst_header, &lst_header); @@ -6206,37 +6226,42 @@ som_slurp_armap (bfd *abfd) if (lst_header.a_magic != LIBMAGIC) { bfd_set_error (bfd_error_malformed_archive); - return FALSE; + return false; } /* Count the number of symbols in the library symbol table. */ if (! som_bfd_count_ar_symbols (abfd, &lst_header, &ardata->symdef_count)) - return FALSE; + return false; /* Get back to the start of the library symbol table. */ if (bfd_seek (abfd, (ardata->first_file_filepos - parsed_size + sizeof (struct som_external_lst_header)), SEEK_SET) != 0) - return FALSE; + return false; /* Initialize the cache and allocate space for the library symbols. */ ardata->cache = 0; - ardata->symdefs = bfd_alloc2 (abfd, ardata->symdef_count, sizeof (carsym)); + if (_bfd_mul_overflow (ardata->symdef_count, sizeof (carsym), &amt)) + { + bfd_set_error (bfd_error_file_too_big); + return false; + } + ardata->symdefs = bfd_alloc (abfd, amt); if (!ardata->symdefs) - return FALSE; + return false; /* Now fill in the canonical archive symbols. */ if (! som_bfd_fill_in_ar_symbols (abfd, &lst_header, &ardata->symdefs)) - return FALSE; + return false; /* Seek back to the "first" file in the archive. Note the "first" file may be the extended name table. */ if (bfd_seek (abfd, ardata->first_file_filepos, SEEK_SET) != 0) - return FALSE; + return false; /* Notify the generic archive code that we have a symbol map. */ - abfd->has_armap = TRUE; - return TRUE; + abfd->has_armap = true; + return true; } /* Begin preparing to write a SOM library symbol table. @@ -6244,7 +6269,7 @@ som_slurp_armap (bfd *abfd) As part of the prep work we need to determine the number of symbols and the size of the associated string section. */ -static bfd_boolean +static bool som_bfd_prep_for_ar_write (bfd *abfd, unsigned int *num_syms, unsigned int *stringsize) @@ -6273,7 +6298,7 @@ som_bfd_prep_for_ar_write (bfd *abfd, to it. It's a little slimey to grab the symbols via obj_som_symtab, but doing so avoids allocating lots of extra memory. */ if (! som_slurp_symbol_table (curr_bfd)) - return FALSE; + return false; sym = obj_som_symtab (curr_bfd); curr_count = bfd_get_symcount (curr_bfd); @@ -6312,7 +6337,7 @@ som_bfd_prep_for_ar_write (bfd *abfd, curr_bfd = curr_bfd->archive_next; } - return TRUE; + return true; } /* Hash a symbol name based on the hashing algorithm presented in the @@ -6334,7 +6359,7 @@ som_bfd_ar_symbol_hash (asymbol *symbol) /* Do the bulk of the work required to write the SOM library symbol table. */ -static bfd_boolean +static bool som_bfd_ar_write_symbol_stuff (bfd *abfd, unsigned int nsyms, unsigned int string_size, @@ -6348,22 +6373,39 @@ som_bfd_ar_write_symbol_stuff (bfd *abfd, struct som_external_som_entry *som_dict = NULL; struct som_external_lst_symbol_record **last_hash_entry = NULL; unsigned int curr_som_offset, som_index = 0; - bfd_size_type amt; + size_t amt; unsigned int module_count; unsigned int hash_size; hash_size = bfd_getb32 (lst.hash_size); - hash_table = bfd_zmalloc2 (hash_size, 4); + if (_bfd_mul_overflow (hash_size, 4, &amt)) + { + bfd_set_error (bfd_error_no_memory); + return false; + } + hash_table = bfd_zmalloc (amt); if (hash_table == NULL && hash_size != 0) goto error_return; module_count = bfd_getb32 (lst.module_count); - som_dict = bfd_zmalloc2 (module_count, sizeof (struct som_external_som_entry)); + if (_bfd_mul_overflow (module_count, + sizeof (struct som_external_som_entry), &amt)) + { + bfd_set_error (bfd_error_no_memory); + goto error_return; + } + som_dict = bfd_zmalloc (amt); if (som_dict == NULL && module_count != 0) goto error_return; - last_hash_entry - = bfd_zmalloc2 (hash_size, sizeof (struct som_external_lst_symbol_record *)); + if (_bfd_mul_overflow (hash_size, + sizeof (struct som_external_lst_symbol_record *), + &amt)) + { + bfd_set_error (bfd_error_no_memory); + goto error_return; + } + last_hash_entry = bfd_zmalloc (amt); if (last_hash_entry == NULL && hash_size != 0) goto error_return; @@ -6391,10 +6433,16 @@ som_bfd_ar_write_symbol_stuff (bfd *abfd, curr_som_offset = (curr_som_offset + 0x1) & ~0x1; /* FIXME should be done with buffers just like everything else... */ - lst_syms = bfd_malloc2 (nsyms, sizeof (struct som_external_lst_symbol_record)); + if (_bfd_mul_overflow (nsyms, + sizeof (struct som_external_lst_symbol_record), &amt)) + { + bfd_set_error (bfd_error_no_memory); + goto error_return; + } + lst_syms = bfd_malloc (amt); if (lst_syms == NULL && nsyms != 0) goto error_return; - strings = bfd_malloc ((bfd_size_type) string_size); + strings = bfd_malloc (string_size); if (strings == NULL && string_size != 0) goto error_return; @@ -6539,17 +6587,17 @@ som_bfd_ar_write_symbol_stuff (bfd *abfd, } /* Now scribble out the hash table. */ - amt = (bfd_size_type) hash_size * 4; + amt = (size_t) hash_size * 4; if (bfd_bwrite ((void *) hash_table, amt, abfd) != amt) goto error_return; /* Then the SOM dictionary. */ - amt = (bfd_size_type) module_count * sizeof (struct som_external_som_entry); + amt = (size_t) module_count * sizeof (struct som_external_som_entry); if (bfd_bwrite ((void *) som_dict, amt, abfd) != amt) goto error_return; /* The library symbols. */ - amt = (bfd_size_type) nsyms * sizeof (struct som_external_lst_symbol_record); + amt = (size_t) nsyms * sizeof (struct som_external_lst_symbol_record); if (bfd_bwrite ((void *) lst_syms, amt, abfd) != amt) goto error_return; @@ -6558,38 +6606,28 @@ som_bfd_ar_write_symbol_stuff (bfd *abfd, if (bfd_bwrite ((void *) strings, amt, abfd) != amt) goto error_return; - if (hash_table != NULL) - free (hash_table); - if (som_dict != NULL) - free (som_dict); - if (last_hash_entry != NULL) - free (last_hash_entry); - if (lst_syms != NULL) - free (lst_syms); - if (strings != NULL) - free (strings); - return TRUE; + free (hash_table); + free (som_dict); + free (last_hash_entry); + free (lst_syms); + free (strings); + return true; error_return: - if (hash_table != NULL) - free (hash_table); - if (som_dict != NULL) - free (som_dict); - if (last_hash_entry != NULL) - free (last_hash_entry); - if (lst_syms != NULL) - free (lst_syms); - if (strings != NULL) - free (strings); - - return FALSE; + free (hash_table); + free (som_dict); + free (last_hash_entry); + free (lst_syms); + free (strings); + + return false; } /* Write out the LST for the archive. You'll never believe this is really how armaps are handled in SOM... */ -static bfd_boolean +static bool som_write_armap (bfd *abfd, unsigned int elength, struct orl *map ATTRIBUTE_UNUSED, @@ -6602,15 +6640,15 @@ som_write_armap (bfd *abfd, struct ar_hdr hdr; struct som_external_lst_header lst; unsigned char *p; - bfd_size_type amt; + size_t amt; unsigned int csum; unsigned int module_count; /* We'll use this for the archive's date and mode later. */ - if (stat (abfd->filename, &statbuf) != 0) + if (stat (bfd_get_filename (abfd), &statbuf) != 0) { bfd_set_error (bfd_error_system_call); - return FALSE; + return false; } /* Fudge factor. */ bfd_ardata (abfd)->armap_timestamp = statbuf.st_mtime + 60; @@ -6662,7 +6700,7 @@ som_write_armap (bfd *abfd, /* Count how many symbols we will have on the hash chains and the size of the associated string table. */ if (! som_bfd_prep_for_ar_write (abfd, &nsyms, &stringsize)) - return FALSE; + return false; lst_size += sizeof (struct som_external_lst_symbol_record) * nsyms; @@ -6707,32 +6745,32 @@ som_write_armap (bfd *abfd, /* Scribble out the ar header. */ amt = sizeof (struct ar_hdr); if (bfd_bwrite ((void *) &hdr, amt, abfd) != amt) - return FALSE; + return false; /* Now scribble out the lst header. */ amt = sizeof (struct som_external_lst_header); if (bfd_bwrite ((void *) &lst, amt, abfd) != amt) - return FALSE; + return false; /* Build and write the armap. */ if (!som_bfd_ar_write_symbol_stuff (abfd, nsyms, stringsize, lst, elength)) - return FALSE; + return false; /* Done. */ - return TRUE; + return true; } /* Free all information we have cached for this BFD. We can always read it again later if we need it. */ -static bfd_boolean +static bool som_bfd_free_cached_info (bfd *abfd) { if (bfd_get_format (abfd) == bfd_object) { asection *o; -#define FREE(x) if (x != NULL) { free (x); x = NULL; } +#define FREE(x) do { free (x); x = NULL; } while (0) /* Free the native string and symbol tables. */ FREE (obj_som_symtab (abfd)); FREE (obj_som_stringtab (abfd)); @@ -6753,7 +6791,7 @@ som_bfd_free_cached_info (bfd *abfd) /* Linker support functions. */ -static bfd_boolean +static bool som_bfd_link_split_section (bfd *abfd ATTRIBUTE_UNUSED, asection *sec) { return som_is_subspace (sec) && sec->size > 240000; @@ -6820,6 +6858,7 @@ const bfd_target hppa_som_vec = '/', /* AR_pad_char. */ 14, /* 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. */