Touches most files in bfd/, so likely will be blamed for everything..

o  bfd_read and bfd_write lose an unnecessary param and become
   bfd_bread and bfd_bwrite.

o  bfd_*alloc now all take a bfd_size_type arg, and will error if
   size_t is too small.  eg. 32 bit host, 64 bit bfd, verrry big files
   or bugs in linker scripts etc.

o  file_ptr becomes a bfd_signed_vma.  Besides matching sizes with
   various other types involved in handling sections, this should make
   it easier for bfd to support a 64 bit off_t on 32 bit hosts that
   provide it.

o  I've made the H_GET_* and H_PUT_* macros (which invoke bfd_h_{get,put}_*)
   generally available.  They now cast their args to bfd_vma and
   bfd_byte * as appropriate, which removes a swag of casts from the
   source.

o  Bug fixes to bfd_get8, aix386_core_vec, elf32_h8_relax_section, and
   aout-encap.c.

o  Zillions of formatting and -Wconversion fixes.

1 files changed, 134 insertions, 135 deletions

diff --git a/bfd/oasys.c b/bfd/oasys.c
index ab836a515e8..dcb2b7381ac 100644
--- a/bfd/oasys.c
+++ b/bfd/oasys.c
@@ -27,13 +27,11 @@
 #include "oasys.h"
 #include "liboasys.h"
 
-static boolean oasys_read_record PARAMS ((bfd *,
-					  oasys_record_union_type *));
+static boolean oasys_slurp_section_data PARAMS ((bfd * const));
+static boolean oasys_read_record PARAMS ((bfd *, oasys_record_union_type *));
 static boolean oasys_write_sections PARAMS ((bfd *));
-static boolean oasys_write_record PARAMS ((bfd *,
-					   oasys_record_enum_type,
-					   oasys_record_union_type *,
-					   size_t));
+static boolean oasys_write_record
+  PARAMS ((bfd *, oasys_record_enum_type, oasys_record_union_type *, size_t));
 static boolean oasys_write_syms PARAMS ((bfd *));
 static boolean oasys_write_header PARAMS ((bfd *));
 static boolean oasys_write_end PARAMS ((bfd *));
@@ -45,7 +43,8 @@ static const bfd_target *oasys_archive_p PARAMS ((bfd *));
 static boolean oasys_mkobject PARAMS ((bfd *));
 static const bfd_target *oasys_object_p PARAMS ((bfd *));
 static void oasys_get_symbol_info PARAMS ((bfd *, asymbol *, symbol_info *));
-static void oasys_print_symbol PARAMS ((bfd *, void *, asymbol *, bfd_print_symbol_type));
+static void oasys_print_symbol
+  PARAMS ((bfd *, void *, asymbol *, bfd_print_symbol_type));
 static boolean oasys_new_section_hook PARAMS ((bfd *, asection *));
 static long int oasys_get_reloc_upper_bound PARAMS ((bfd *, sec_ptr));
 static boolean oasys_get_section_contents
@@ -57,34 +56,35 @@ static boolean oasys_set_section_contents
 static asymbol *oasys_make_empty_symbol PARAMS ((bfd *));
 static bfd *oasys_openr_next_archived_file PARAMS ((bfd *, bfd *));
 static boolean oasys_find_nearest_line
-  PARAMS ((bfd *, asection *, asymbol **, bfd_vma, char **, char **, unsigned int *));
+  PARAMS ((bfd *, asection *, asymbol **, bfd_vma,
+	   const char **, const char **, unsigned int *));
 static int oasys_generic_stat_arch_elt PARAMS ((bfd *, struct stat *));
 static int oasys_sizeof_headers PARAMS ((bfd *, boolean));
 
 long oasys_get_symtab PARAMS ((bfd *, asymbol **));
-long oasys_canonicalize_reloc PARAMS ((bfd *, sec_ptr, arelent **, asymbol **));
+long oasys_canonicalize_reloc
+  PARAMS ((bfd *, sec_ptr, arelent **, asymbol **));
 
 /* Read in all the section data and relocation stuff too.  */
-PROTO (static boolean, oasys_slurp_section_data, (bfd * CONST abfd));
 
 static boolean
 oasys_read_record (abfd, record)
      bfd *abfd;
      oasys_record_union_type *record;
 {
-  if (bfd_read ((PTR) record, 1, sizeof (record->header), abfd)
-      != sizeof (record->header))
+  bfd_size_type amt = sizeof (record->header);
+  if (bfd_bread ((PTR) record, amt, abfd) != amt)
     return false;
 
-  if ((size_t) record->header.length <= (size_t) sizeof (record->header))
+  amt = record->header.length - sizeof (record->header);
+  if ((long) amt <= 0)
     return true;
-  if (bfd_read ((PTR) (((char *) record) + sizeof (record->header)),
-		1, record->header.length - sizeof (record->header),
-		abfd)
-      != record->header.length - sizeof (record->header))
+  if (bfd_bread ((PTR) ((char *) record + sizeof (record->header)), amt, abfd)
+      != amt)
     return false;
   return true;
 }
+
 static size_t
 oasys_string_length (record)
      oasys_record_union_type *record;
@@ -111,7 +111,7 @@ moving in, and the defined symbols at the end of the table moving back.
 
 static boolean
 oasys_slurp_symbol_table (abfd)
-     bfd *CONST abfd;
+     bfd *const abfd;
 {
   oasys_record_union_type record;
   oasys_data_type *data = OASYS_DATA (abfd);
@@ -119,22 +119,24 @@ oasys_slurp_symbol_table (abfd)
   asymbol *dest_defined;
   asymbol *dest;
   char *string_ptr;
-
+  bfd_size_type amt;
 
   if (data->symbols != (asymbol *) NULL)
     {
       return true;
     }
   /* Buy enough memory for all the symbols and all the names */
-  data->symbols =
-    (asymbol *) bfd_alloc (abfd, sizeof (asymbol) * abfd->symcount);
+  amt = abfd->symcount;
+  amt *= sizeof (asymbol);
+  data->symbols = (asymbol *) bfd_alloc (abfd, amt);
+
+  amt = data->symbol_string_length;
 #ifdef UNDERSCORE_HACK
   /* buy 1 more char for each symbol to keep the underscore in*/
-  data->strings = bfd_alloc (abfd, data->symbol_string_length +
-			     abfd->symcount);
-#else
-  data->strings = bfd_alloc (abfd, data->symbol_string_length);
+  amt += abfd->symcount;
 #endif
+  data->strings = bfd_alloc (abfd, amt);
+
   if (!data->symbols || !data->strings)
     return false;
 
@@ -191,7 +193,7 @@ oasys_slurp_symbol_table (abfd)
 		  }
 		break;
 	      case RELOCATION_TYPE_UND:
-		dest = data->symbols + bfd_h_get_16 (abfd, record.symbol.refno);
+		dest = data->symbols + H_GET_16 (abfd, record.symbol.refno);
 		dest->section = bfd_und_section_ptr;
 		break;
 	      case RELOCATION_TYPE_COM:
@@ -210,7 +212,7 @@ oasys_slurp_symbol_table (abfd)
 	    dest->name = string_ptr;
 	    dest->the_bfd = abfd;
 	    dest->udata.p = (PTR) NULL;
-	    dest->value = bfd_h_get_32 (abfd, record.symbol.value);
+	    dest->value = H_GET_32 (abfd, record.symbol.value);
 
 #ifdef UNDERSCORE_HACK
 	    if (record.symbol.name[0] != '_')
@@ -235,7 +237,7 @@ oasys_slurp_symbol_table (abfd)
 
 static long
 oasys_get_symtab_upper_bound (abfd)
-     bfd *CONST abfd;
+     bfd *const abfd;
 {
   if (! oasys_slurp_symbol_table (abfd))
     return -1;
@@ -277,24 +279,25 @@ oasys_archive_p (abfd)
   oasys_extarchive_header_type header_ext;
   unsigned int i;
   file_ptr filepos;
+  bfd_size_type amt;
 
-  if (bfd_seek (abfd, (file_ptr) 0, false) != 0
-      || (bfd_read ((PTR) & header_ext, 1, sizeof (header_ext), abfd)
-	  != sizeof (header_ext)))
+  amt = sizeof (header_ext);
+  if (bfd_seek (abfd, (file_ptr) 0, 0) != 0
+      || bfd_bread ((PTR) &header_ext, amt, abfd) != amt)
     {
       if (bfd_get_error () != bfd_error_system_call)
 	bfd_set_error (bfd_error_wrong_format);
       return NULL;
     }
 
-  header.version = bfd_h_get_32 (abfd, header_ext.version);
-  header.mod_count = bfd_h_get_32 (abfd, header_ext.mod_count);
-  header.mod_tbl_offset = bfd_h_get_32 (abfd, header_ext.mod_tbl_offset);
-  header.sym_tbl_size = bfd_h_get_32 (abfd, header_ext.sym_tbl_size);
-  header.sym_count = bfd_h_get_32 (abfd, header_ext.sym_count);
-  header.sym_tbl_offset = bfd_h_get_32 (abfd, header_ext.sym_tbl_offset);
-  header.xref_count = bfd_h_get_32 (abfd, header_ext.xref_count);
-  header.xref_lst_offset = bfd_h_get_32 (abfd, header_ext.xref_lst_offset);
+  header.version = H_GET_32 (abfd, header_ext.version);
+  header.mod_count = H_GET_32 (abfd, header_ext.mod_count);
+  header.mod_tbl_offset = H_GET_32 (abfd, header_ext.mod_tbl_offset);
+  header.sym_tbl_size = H_GET_32 (abfd, header_ext.sym_tbl_size);
+  header.sym_count = H_GET_32 (abfd, header_ext.sym_count);
+  header.sym_tbl_offset = H_GET_32 (abfd, header_ext.sym_tbl_offset);
+  header.xref_count = H_GET_32 (abfd, header_ext.xref_count);
+  header.xref_lst_offset = H_GET_32 (abfd, header_ext.xref_lst_offset);
 
   /*
     There isn't a magic number in an Oasys archive, so the best we
@@ -313,14 +316,17 @@ oasys_archive_p (abfd)
     the headers.
     */
   {
-    oasys_ar_data_type *ar =
-    (oasys_ar_data_type *) bfd_alloc (abfd, sizeof (oasys_ar_data_type));
-
-    oasys_module_info_type *module =
-    (oasys_module_info_type *)
-    bfd_alloc (abfd, sizeof (oasys_module_info_type) * header.mod_count);
+    oasys_ar_data_type *ar;
+    oasys_module_info_type *module;
     oasys_module_table_type record;
 
+    amt = sizeof (oasys_ar_data_type);
+    ar = (oasys_ar_data_type *) bfd_alloc (abfd, amt);
+
+    amt = header.mod_count;
+    amt *= sizeof (oasys_module_info_type);
+    module = (oasys_module_info_type *) bfd_alloc (abfd, amt);
+
     if (!ar || !module)
       return NULL;
 
@@ -339,18 +345,19 @@ oasys_archive_p (abfd)
 	if (0)
 	  {
 	    oasys_extmodule_table_type_a_type record_ext;
-	    if (bfd_read ((PTR) & record_ext, 1, sizeof (record_ext), abfd)
-		!= sizeof (record_ext))
+
+	    amt = sizeof (record_ext);
+	    if (bfd_bread ((PTR) &record_ext, amt, abfd) != amt)
 	      return NULL;
 
-	    record.mod_size = bfd_h_get_32 (abfd, record_ext.mod_size);
-	    record.file_offset = bfd_h_get_32 (abfd, record_ext.file_offset);
+	    record.mod_size = H_GET_32 (abfd, record_ext.mod_size);
+	    record.file_offset = H_GET_32 (abfd, record_ext.file_offset);
 
-	    record.dep_count = bfd_h_get_32 (abfd, record_ext.dep_count);
-	    record.depee_count = bfd_h_get_32 (abfd, record_ext.depee_count);
-	    record.sect_count = bfd_h_get_32 (abfd, record_ext.sect_count);
+	    record.dep_count = H_GET_32 (abfd, record_ext.dep_count);
+	    record.depee_count = H_GET_32 (abfd, record_ext.depee_count);
+	    record.sect_count = H_GET_32 (abfd, record_ext.sect_count);
 
-	    module[i].name = bfd_alloc (abfd, 33);
+	    module[i].name = bfd_alloc (abfd, (bfd_size_type) 33);
 	    if (!module[i].name)
 	      return NULL;
 
@@ -364,39 +371,36 @@ oasys_archive_p (abfd)
 	else
 	  {
 	    oasys_extmodule_table_type_b_type record_ext;
-	    if (bfd_read ((PTR) & record_ext, 1, sizeof (record_ext), abfd)
-		!= sizeof (record_ext))
+
+	    amt = sizeof (record_ext);
+	    if (bfd_bread ((PTR) &record_ext, amt, abfd) != amt)
 	      return NULL;
 
-	    record.mod_size = bfd_h_get_32 (abfd, record_ext.mod_size);
-	    record.file_offset = bfd_h_get_32 (abfd, record_ext.file_offset);
+	    record.mod_size = H_GET_32 (abfd, record_ext.mod_size);
+	    record.file_offset = H_GET_32 (abfd, record_ext.file_offset);
 
-	    record.dep_count = bfd_h_get_32 (abfd, record_ext.dep_count);
-	    record.depee_count = bfd_h_get_32 (abfd, record_ext.depee_count);
-	    record.sect_count = bfd_h_get_32 (abfd, record_ext.sect_count);
-	    record.module_name_size = bfd_h_get_32 (abfd, record_ext.mod_name_length);
+	    record.dep_count = H_GET_32 (abfd, record_ext.dep_count);
+	    record.depee_count = H_GET_32 (abfd, record_ext.depee_count);
+	    record.sect_count = H_GET_32 (abfd, record_ext.sect_count);
+	    record.module_name_size = H_GET_32 (abfd,
+						record_ext.mod_name_length);
 
-	    module[i].name = bfd_alloc (abfd, record.module_name_size + 1);
+	    amt = record.module_name_size;
+	    module[i].name = bfd_alloc (abfd, amt + 1);
 	    if (!module[i].name)
 	      return NULL;
-	    if (bfd_read ((PTR) module[i].name, 1, record.module_name_size,
-			  abfd)
-		!= record.module_name_size)
+	    if (bfd_bread ((PTR) module[i].name, amt, abfd) != amt)
 	      return NULL;
 	    module[i].name[record.module_name_size] = 0;
-	    filepos +=
-	      sizeof (record_ext) +
-	      record.dep_count * 4 +
-	      record.module_name_size + 1;
-
+	    filepos += (sizeof (record_ext)
+			+ record.dep_count * 4
+			+ record.module_name_size + 1);
 	  }
 
-
 	module[i].size = record.mod_size;
 	module[i].pos = record.file_offset;
 	module[i].abfd = 0;
       }
-
   }
   return abfd->xvec;
 }
@@ -405,8 +409,8 @@ static boolean
 oasys_mkobject (abfd)
      bfd *abfd;
 {
-
-  abfd->tdata.oasys_obj_data = (oasys_data_type *) bfd_alloc (abfd, sizeof (oasys_data_type));
+  bfd_size_type amt = sizeof (oasys_data_type);
+  abfd->tdata.oasys_obj_data = (oasys_data_type *) bfd_alloc (abfd, amt);
   return abfd->tdata.oasys_obj_data ? true : false;
 }
 
@@ -463,7 +467,7 @@ oasys_object_p (abfd)
 	      {
 		goto fail;
 	      }
-	    buffer = bfd_alloc (abfd, 3);
+	    buffer = bfd_alloc (abfd, (bfd_size_type) 3);
 	    if (!buffer)
 	      goto fail;
 	    section_number = record.section.relb & RELOCATION_SECT_BITS;
@@ -480,8 +484,8 @@ oasys_object_p (abfd)
 		BFD_FAIL ();
 	      }
 
-	    s->_raw_size = bfd_h_get_32 (abfd, record.section.value);
-	    s->vma = bfd_h_get_32 (abfd, record.section.vma);
+	    s->_raw_size = H_GET_32 (abfd, record.section.value);
+	    s->vma = H_GET_32 (abfd, record.section.vma);
 	    s->flags = 0;
 	    had_usefull = true;
 	  }
@@ -555,8 +559,8 @@ oasys_print_symbol (abfd, afile, symbol, how)
       break;
     case bfd_print_symbol_all:
       {
-	CONST char *section_name = symbol->section == (asection *) NULL ?
-	(CONST char *) "*abs" : symbol->section->name;
+	const char *section_name = symbol->section == (asection *) NULL ?
+	(const char *) "*abs" : symbol->section->name;
 
 	bfd_print_symbol_vandf (abfd, (PTR) file, symbol);
 
@@ -583,15 +587,14 @@ static reloc_howto_type howto_table[] =
 /* Read in all the section data and relocation stuff too */
 static boolean
 oasys_slurp_section_data (abfd)
-     bfd *CONST abfd;
+     bfd *const abfd;
 {
   oasys_record_union_type record;
   oasys_data_type *data = OASYS_DATA (abfd);
   boolean loop = true;
-
   oasys_per_section_type *per;
-
   asection *s;
+  bfd_size_type amt;
 
   /* See if the data has been slurped already .. */
   for (s = abfd->sections; s != (asection *) NULL; s = s->next)
@@ -634,14 +637,15 @@ oasys_slurp_section_data (abfd)
 		per->data = (bfd_byte *) bfd_zalloc (abfd, section->_raw_size);
 		if (!per->data)
 		  return false;
-		per->reloc_tail_ptr = (oasys_reloc_type **) & (section->relocation);
+		per->reloc_tail_ptr
+		  = (oasys_reloc_type **) &section->relocation;
 		per->had_vma = false;
 		per->initialized = true;
 		section->reloc_count = 0;
 		section->flags = SEC_ALLOC;
 	      }
 
-	    dst_offset = bfd_h_get_32 (abfd, record.data.addr);
+	    dst_offset = H_GET_32 (abfd, record.data.addr);
 	    if (per->had_vma == false)
 	      {
 		/* Take the first vma we see as the base */
@@ -695,10 +699,11 @@ oasys_slurp_section_data (abfd)
 			      case RELOCATION_TYPE_REL:
 				{
 				  /* Relocate the item relative to the section */
-				  oasys_reloc_type *r =
-				  (oasys_reloc_type *)
-				  bfd_alloc (abfd,
-					     sizeof (oasys_reloc_type));
+				  oasys_reloc_type *r;
+
+				  amt = sizeof (oasys_reloc_type);
+				  r = (oasys_reloc_type *) bfd_alloc (abfd,
+								      amt);
 				  if (!r)
 				    return false;
 				  *(per->reloc_tail_ptr) = r;
@@ -739,10 +744,11 @@ oasys_slurp_section_data (abfd)
 
 			      case RELOCATION_TYPE_UND:
 				{
-				  oasys_reloc_type *r =
-				  (oasys_reloc_type *)
-				  bfd_alloc (abfd,
-					     sizeof (oasys_reloc_type));
+				  oasys_reloc_type *r;
+
+				  amt = sizeof (oasys_reloc_type);
+				  r = (oasys_reloc_type *) bfd_alloc (abfd,
+								      amt);
 				  if (!r)
 				    return false;
 				  *(per->reloc_tail_ptr) = r;
@@ -808,7 +814,7 @@ oasys_new_section_hook (abfd, newsect)
      asection *newsect;
 {
   newsect->used_by_bfd = (PTR)
-    bfd_alloc (abfd, sizeof (oasys_per_section_type));
+    bfd_alloc (abfd, (bfd_size_type) sizeof (oasys_per_section_type));
   if (!newsect->used_by_bfd)
     return false;
   oasys_per_section (newsect)->data = (bfd_byte *) NULL;
@@ -846,11 +852,11 @@ oasys_get_section_contents (abfd, section, location, offset, count)
   oasys_slurp_section_data (abfd);
   if (p->initialized == false)
     {
-      (void) memset (location, 0, (int) count);
+      (void) memset (location, 0, (size_t) count);
     }
   else
     {
-      (void) memcpy (location, (PTR) (p->data + offset), (int) count);
+      (void) memcpy (location, (PTR) (p->data + offset), (size_t) count);
     }
   return true;
 }
@@ -913,7 +919,7 @@ oasys_write_record (abfd, type, record, size)
       checksum += *ptr++;
     }
   record->header.check_sum = 0xff & (-checksum);
-  if (bfd_write ((PTR) record, 1, size, abfd) != size)
+  if (bfd_bwrite ((PTR) record, (bfd_size_type) size, abfd) != size)
     return false;
   return true;
 }
@@ -931,28 +937,28 @@ oasys_write_syms (abfd)
     {
 
       oasys_symbol_record_type symbol;
-      asymbol *CONST g = generic[count];
+      asymbol *const g = generic[count];
 
-      CONST char *src = g->name;
+      const char *src = g->name;
       char *dst = symbol.name;
       unsigned int l = 0;
 
       if (bfd_is_com_section (g->section))
 	{
 	  symbol.relb = RELOCATION_TYPE_COM;
-	  bfd_h_put_16 (abfd, index, symbol.refno);
+	  H_PUT_16 (abfd, index, symbol.refno);
 	  index++;
 	}
       else if (bfd_is_abs_section (g->section))
 	{
 	  symbol.relb = RELOCATION_TYPE_ABS;
-	  bfd_h_put_16 (abfd, 0, symbol.refno);
+	  H_PUT_16 (abfd, 0, symbol.refno);
 
 	}
       else if (bfd_is_und_section (g->section))
 	{
 	  symbol.relb = RELOCATION_TYPE_UND;
-	  bfd_h_put_16 (abfd, index, symbol.refno);
+	  H_PUT_16 (abfd, index, symbol.refno);
 	  /* Overload the value field with the output index number */
 	  index++;
 	}
@@ -974,7 +980,7 @@ oasys_write_syms (abfd)
 	    {
 	      symbol.relb = RELOCATION_TYPE_REL | g->section->output_section->target_index;
 	    }
-	  bfd_h_put_16 (abfd, 0, symbol.refno);
+	  H_PUT_16 (abfd, 0, symbol.refno);
 	}
 #ifdef UNDERSCORE_HACK
       if (src[l] == '_')
@@ -986,7 +992,7 @@ oasys_write_syms (abfd)
 	  l++;
 	}
 
-      bfd_h_put_32 (abfd, g->value, symbol.value);
+      H_PUT_32 (abfd, g->value, symbol.value);
 
 
       if (g->flags & BSF_LOCAL)
@@ -1033,8 +1039,8 @@ oasys_write_sections (abfd)
 	  return false;
 	}
       out.relb = RELOCATION_TYPE_REL | s->target_index;
-      bfd_h_put_32 (abfd, s->_cooked_size, out.value);
-      bfd_h_put_32 (abfd, s->vma, out.vma);
+      H_PUT_32 (abfd, s->_cooked_size, out.value);
+      H_PUT_32 (abfd, s->vma, out.vma);
 
       if (! oasys_write_record (abfd,
 				oasys_record_is_section_enum,
@@ -1083,23 +1089,23 @@ oasys_write_end (abfd)
   oasys_end_record_type end;
   unsigned char null = 0;
   end.relb = RELOCATION_TYPE_ABS;
-  bfd_h_put_32 (abfd, abfd->start_address, end.entry);
-  bfd_h_put_16 (abfd, 0, end.fill);
+  H_PUT_32 (abfd, abfd->start_address, end.entry);
+  H_PUT_16 (abfd, 0, end.fill);
   end.zero = 0;
   if (! oasys_write_record (abfd,
 			    oasys_record_is_end_enum,
 			    (oasys_record_union_type *) & end,
 			    sizeof (end)))
     return false;
-  if (bfd_write ((PTR) & null, 1, 1, abfd) != 1)
+  if (bfd_bwrite ((PTR) &null, (bfd_size_type) 1, abfd) != 1)
     return false;
   return true;
 }
 
 static int
 comp (ap, bp)
-     CONST PTR ap;
-     CONST PTR bp;
+     const PTR ap;
+     const PTR bp;
 {
   arelent *a = *((arelent **) ap);
   arelent *b = *((arelent **) bp);
@@ -1148,8 +1154,8 @@ oasys_write_data (abfd)
 	      *mod = 0;
 
 
-	      bfd_h_put_32 (abfd, s->vma + current_byte_index,
-			    processed_data.addr);
+	      H_PUT_32 (abfd, s->vma + current_byte_index,
+			processed_data.addr);
 
 	      /* Don't start a relocation unless you're sure you can finish it
  	       within the same data record.  The worst case relocation is a
@@ -1221,16 +1227,16 @@ oasys_write_data (abfd)
 			  else
 #endif
 			    {
-			      asymbol *p = *(r->sym_ptr_ptr);
+			      asymbol *sym = *(r->sym_ptr_ptr);
 
 			      /* If this symbol has a section attached, then it
 			     has already been resolved.  Change from a symbol
 			     ref to a section ref */
-			      if (p->section != (asection *) NULL)
+			      if (sym->section != (asection *) NULL)
 				{
 				  rel_byte |= RELOCATION_TYPE_REL;
 				  rel_byte |=
-				    p->section->output_section->target_index;
+				    sym->section->output_section->target_index;
 				  *dst++ = rel_byte;
 				}
 			      else
@@ -1242,8 +1248,8 @@ oasys_write_data (abfd)
 			       into the symbol index in the table when the
 			       symbol table was written
 			       */
-				  *dst++ = p->value >> 8;
-				  *dst++ = p->value;
+				  *dst++ = sym->value >> 8;
+				  *dst++ = sym->value;
 				}
 			    }
 #define ADVANCE { if (++i >= 8) { i = 0; mod = dst++; *mod = 0; } current_byte_index++; }
@@ -1283,11 +1289,10 @@ oasys_write_data (abfd)
 		  --dst;
 		}
 
-	      if (! oasys_write_record (abfd,
-					oasys_record_is_data_enum,
-					((oasys_record_union_type *)
-					 & processed_data),
-					dst - (bfd_byte *) & processed_data))
+	      if (! (oasys_write_record
+		     (abfd, oasys_record_is_data_enum,
+		      ((oasys_record_union_type *) &processed_data),
+		      (size_t) (dst - (bfd_byte *) &processed_data))))
 		return false;
 	    }
 	}
@@ -1357,9 +1362,8 @@ static asymbol *
 oasys_make_empty_symbol (abfd)
      bfd *abfd;
 {
-
-  oasys_symbol_type *new =
-  (oasys_symbol_type *) bfd_zalloc (abfd, sizeof (oasys_symbol_type));
+  bfd_size_type amt = sizeof (oasys_symbol_type);
+  oasys_symbol_type *new = (oasys_symbol_type *) bfd_zalloc (abfd, amt);
   if (!new)
     return NULL;
   new->symbol.the_bfd = abfd;
@@ -1410,19 +1414,14 @@ oasys_openr_next_archived_file (arch, prev)
 }
 
 static boolean
-oasys_find_nearest_line (abfd,
-			 section,
-			 symbols,
-			 offset,
-			 filename_ptr,
-			 functionname_ptr,
-			 line_ptr)
+oasys_find_nearest_line (abfd, section, symbols, offset,
+			 filename_ptr, functionname_ptr, line_ptr)
      bfd *abfd ATTRIBUTE_UNUSED;
      asection *section ATTRIBUTE_UNUSED;
      asymbol **symbols ATTRIBUTE_UNUSED;
      bfd_vma offset ATTRIBUTE_UNUSED;
-     char **filename_ptr ATTRIBUTE_UNUSED;
-     char **functionname_ptr ATTRIBUTE_UNUSED;
+     const char **filename_ptr ATTRIBUTE_UNUSED;
+     const char **functionname_ptr ATTRIBUTE_UNUSED;
      unsigned int *line_ptr ATTRIBUTE_UNUSED;
 {
   return false;
@@ -1547,6 +1546,6 @@ const bfd_target oasys_vec =
   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
 
   NULL,
-  
+
   (PTR) 0
 };