obj-evax.c tidy

[Alan Modra <amodra at gmail dot com>]

This started out as fixing decode_16, which used a char to index a 256
byte decodings array.  When char is signed that could result in an out
of bounds array access.  The rest of the patch is for consistency and
just general cleanup.

	* config/obj-evax.c (crc32, encode_32, encode_16, decode_16):
	Remove unnecessary prototypes.
	(number_of_codings): Delete, use ARRAY_SIZE instead throughout.
	(codings, decodings): Make arrays of unsigned char.
	(crc32): Use unsigned variables.  Delete unnecessary mask.
	(encode_32, encode_16): Return unsigned char*, and make static
	buffer an unsigned char array.
	(decode_16): Make arg an unsigned char*.  Remove useless casts.
	(shorten_identifier): Use unsigned char crc_chars.
	(is_truncated_identifier): Make ptr an unsigned char*.

diff --git a/gas/config/obj-evax.c b/gas/config/obj-evax.c
index 75642d036d..dd09077632 100644
--- a/gas/config/obj-evax.c
+++ b/gas/config/obj-evax.c
@@ -30,10 +30,6 @@
 #include "safe-ctype.h"
 
 static void s_evax_weak (int);
-static unsigned int crc32 (unsigned char *, int);
-static char *encode_32 (unsigned int);
-static char *encode_16 (unsigned int);
-static int decode_16 (const char *);
 
 const pseudo_typeS obj_pseudo_table[] =
 {
@@ -338,19 +334,16 @@ evax_shorten_name (char *id)
 
 /* Table used to convert an integer into a string.  */
 
-static const char codings[] = {
+static const unsigned char codings[] = {
   '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', '_'};
 
-/* The number of codings in the above table.  */
-static const int number_of_codings = sizeof (codings) / sizeof (char);
-
 /* Table used by decode_16 () to convert an encoded string back into
    an integer.  */
-static char decodings[256];
+static unsigned char decodings[256];
 
 /* Table used by the crc32 function to calculate the checksum.  */
 static unsigned int crc32_table[256] = {0, 0};
@@ -367,7 +360,7 @@ crc32 (unsigned char *buf, int len)
   if (! crc32_table[1])
     {
       /* Initialize the CRC table and the decoding table. */
-      int i, j;
+      unsigned int i, j;
       unsigned int c;
 
       for (i = 0; i < 256; i++)
@@ -377,8 +370,8 @@ crc32 (unsigned char *buf, int len)
 	  crc32_table[i] = c;
 	  decodings[i] = 0;
 	}
-      for (i = 0; i < number_of_codings; i++)
-	decodings[codings[i] & 255] = i;
+      for (i = 0; i < ARRAY_SIZE (codings); i++)
+	decodings[codings[i]] = i;
     }
 
   while (len--)
@@ -391,34 +384,34 @@ crc32 (unsigned char *buf, int len)
 
 /* Encode the lower 32 bits of VALUE as a 5-character string.  */
 
-static char *
+static unsigned char *
 encode_32 (unsigned int value)
 {
-  static char res[6];
+  static unsigned char res[6];
   int x;
 
   res[5] = 0;
   for(x = 0; x < 5; x++)
     {
-      res[x] = codings[value % number_of_codings];
-      value = value / number_of_codings;
+      res[x] = codings[value % ARRAY_SIZE (codings)];
+      value = value / ARRAY_SIZE (codings);
     }
   return res;
 }
 
 /* Encode the lower 16 bits of VALUE as a 3-character string.  */
 
-static char *
+static unsigned char *
 encode_16 (unsigned int value)
 {
-  static char res[4];
+  static unsigned char res[4];
   int x;
 
   res[3] = 0;
   for(x = 0; x < 3; x++)
     {
-      res[x] = codings[value % number_of_codings];
-      value = value / number_of_codings;
+      res[x] = codings[value % ARRAY_SIZE (codings)];
+      value = value / ARRAY_SIZE (codings);
     }
   return res;
 }
@@ -427,11 +420,11 @@ encode_16 (unsigned int value)
    16-bit integer.  */
 
 static int
-decode_16 (const char *string)
+decode_16 (const unsigned char *string)
 {
-  return decodings[(int) string[2]] * number_of_codings * number_of_codings
-    + decodings[(int) string[1]] * number_of_codings
-    + decodings[(int) string[0]];
+  return (decodings[string[2]] * ARRAY_SIZE (codings) * ARRAY_SIZE (codings)
+	  + decodings[string[1]] * ARRAY_SIZE (codings)
+	  + decodings[string[0]]);
 }
 
 /* ID_SUFFIX_LENGTH is used to determine how many characters in the
@@ -452,14 +445,14 @@ static char *
 shorten_identifier (char *name)
 {
   int crc, len, sum, x, final_len;
-  char *crc_chars;
+  unsigned char *crc_chars;
   int suffix_length = ID_SUFFIX_LENGTH (name);
 
   if ((len = strlen (name)) <= MAX_LABEL_LENGTH)
     return name;
 
   final_len = MAX_LABEL_LENGTH - 2 - 5 - 3 - 3 - suffix_length;
-  crc = crc32 ((unsigned char *)name + final_len,
+  crc = crc32 ((unsigned char *) name + final_len,
 	       len - final_len - suffix_length);
   crc_chars = encode_32 (crc);
   sum = 0;
@@ -487,7 +480,7 @@ shorten_identifier (char *name)
 static int
 is_truncated_identifier (char *id)
 {
-  char *ptr;
+  unsigned char *ptr;
   int len = strlen (id);
   /* If it's not exactly MAX_LABEL_LENGTH characters long, it can't be
      a truncated identifier.  */
@@ -496,8 +489,8 @@ is_truncated_identifier (char *id)
 
   /* Start scanning backwards for a _h.  */
   len = len - 3 - 3 - 5 - 2;
-  ptr = id + len;
-  while (ptr >= id)
+  ptr = (unsigned char *) id + len;
+  while (ptr >= (unsigned char *) id)
     {
       if (ptr[0] == '_' && ptr[1] == 'h')
 	{

-- 
Alan Modra
Australia Development Lab, IBM