[commit] Support 64-bit constants/enums on 32-bit host [Re: [PATCH] Allow 64-bit enum values]

[Jan Kratochvil <jan.kratochvil@redhat.com>]

Hi Siddhesh,

On Wed, 21 Mar 2012 11:06:32 +0100, Siddhesh Poyarekar wrote:
> In the following patch, I introduce a separate
> field_location union member 'enumval' which can accept LONGEST and
> hence expand enum values to 64-bit signed values.

your testcase does not test really 64-bit values.
	> +enum e { I, J = 0xffffffffU } e = J;

When I used 64-bit entries like
	+enum e { I, J = 0xffffffffU, K = 0xf000000000000000ULL } e = J, f = K;

it worked on amd64 but it did not work with GDB compiled on 32-bit host.

This patch is unrelated.  Testcase for 64-bit values going to post in the
thread
	[PATCH] Allow 64-bit enum values

It increases memory footprint but only on 32-bit hosts compiled without
--enable-64-bit-bfd.
sizeof (struct symbol):         44 -> 48
sizeof (struct minimal_symbol): 40 -> 44

BTW why we have minimal_symbol and expand it later when it has "the same"
size?  Just expanding the types would have the same effect.

In all other configuration it has no memory footprint change.

-    /* The fact that this is a long not a LONGEST mainly limits the
-       range of a LOC_CONST.  Since LOC_CONST_BYTES exists, I'm not
-       sure that is a big deal.  */
-    long ivalue;
+    LONGEST ivalue;

Going to check it in, probably today, if there are any concerns about those
4 added bytes.

No regressions on {x86_64,x86_64-m32,i686}-fedora17-linux-gnu and with
-gstabs+.


Thanks,
Jan


gdb/
2012-04-17  Jan Kratochvil  <jan.kratochvil@redhat.com>

	Fix 64-bit constants on 32-bit hosts.
	* dwarf2read.c (read_unsigned_leb128): Change declaration return type
	from unsigned long to ULONGEST.
	(read_signed_leb128): Change declaration return type from long to
	LONGEST.
	(dwarf2_const_value_attr): Change declaration parameter value from long
	to LONGEST.
	(dwarf2_compute_name): Change variable value from long to LONGEST.
	(read_unsigned_leb128): Change return type, variable result and some
	casts from unsigned long to ULONGEST.
	(read_signed_leb128): Change return type, variable result and some
	casts from long to LONGEST.
	(dwarf2_const_value_data, dwarf2_const_value_attr): Change parameter
	value from long to LONGEST.
	(dwarf2_const_value): Change variable value from long to LONGEST.
	* symmisc.c (print_symbol): Change SYMBOL_VALUE format strings to use
	plongest and hex_string.
	* symtab.h (struct general_symbol_info): Change ivalue from long to
	LONGEST, remove the comment.
	* tracepoint.c (validate_actionline, collect_symbol, scope_info):
	Change SYMBOL_VALUE format strings to use plongest and hex_string.

diff --git a/gdb/dwarf2read.c b/gdb/dwarf2read.c
index 0e211ae..d237efb 100644
--- a/gdb/dwarf2read.c
+++ b/gdb/dwarf2read.c
@@ -957,9 +957,9 @@ static char *read_indirect_string (bfd *, gdb_byte *,
                                    const struct comp_unit_head *,
                                    unsigned int *);
 
-static unsigned long read_unsigned_leb128 (bfd *, gdb_byte *, unsigned int *);
+static ULONGEST read_unsigned_leb128 (bfd *, gdb_byte *, unsigned int *);
 
-static long read_signed_leb128 (bfd *, gdb_byte *, unsigned int *);
+static LONGEST read_signed_leb128 (bfd *, gdb_byte *, unsigned int *);
 
 static gdb_byte *skip_leb128 (bfd *, gdb_byte *);
 
@@ -1008,7 +1008,7 @@ static void dwarf2_const_value_attr (struct attribute *attr,
 				     struct type *type,
 				     const char *name,
 				     struct obstack *obstack,
-				     struct dwarf2_cu *cu, long *value,
+				     struct dwarf2_cu *cu, LONGEST *value,
 				     gdb_byte **bytes,
 				     struct dwarf2_locexpr_baton **baton);
 
@@ -5146,7 +5146,7 @@ dwarf2_compute_name (char *name, struct die_info *die, struct dwarf2_cu *cu,
 	      for (child = die->child; child != NULL; child = child->sibling)
 		{
 		  struct type *type;
-		  long value;
+		  LONGEST value;
 		  gdb_byte *bytes;
 		  struct dwarf2_locexpr_baton *baton;
 		  struct value *v;
@@ -10660,10 +10660,10 @@ read_indirect_string (bfd *abfd, gdb_byte *buf,
   return read_indirect_string_at_offset (abfd, str_offset);
 }
 
-static unsigned long
+static ULONGEST
 read_unsigned_leb128 (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
 {
-  unsigned long result;
+  ULONGEST result;
   unsigned int num_read;
   int i, shift;
   unsigned char byte;
@@ -10677,7 +10677,7 @@ read_unsigned_leb128 (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
       byte = bfd_get_8 (abfd, buf);
       buf++;
       num_read++;
-      result |= ((unsigned long)(byte & 127) << shift);
+      result |= ((ULONGEST) (byte & 127) << shift);
       if ((byte & 128) == 0)
 	{
 	  break;
@@ -10688,10 +10688,10 @@ read_unsigned_leb128 (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
   return result;
 }
 
-static long
+static LONGEST
 read_signed_leb128 (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
 {
-  long result;
+  LONGEST result;
   int i, shift, num_read;
   unsigned char byte;
 
@@ -10704,7 +10704,7 @@ read_signed_leb128 (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
       byte = bfd_get_8 (abfd, buf);
       buf++;
       num_read++;
-      result |= ((long)(byte & 127) << shift);
+      result |= ((LONGEST) (byte & 127) << shift);
       shift += 7;
       if ((byte & 128) == 0)
 	{
@@ -10712,7 +10712,7 @@ read_signed_leb128 (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
 	}
     }
   if ((shift < 8 * sizeof (result)) && (byte & 0x40))
-    result |= -(((long)1) << shift);
+    result |= -(((LONGEST) 1) << shift);
   *bytes_read_ptr = num_read;
   return result;
 }
@@ -12037,7 +12037,7 @@ new_symbol (struct die_info *die, struct type *type, struct dwarf2_cu *cu)
 static gdb_byte *
 dwarf2_const_value_data (struct attribute *attr, struct type *type,
 			 const char *name, struct obstack *obstack,
-			 struct dwarf2_cu *cu, long *value, int bits)
+			 struct dwarf2_cu *cu, LONGEST *value, int bits)
 {
   struct objfile *objfile = cu->objfile;
   enum bfd_endian byte_order = bfd_big_endian (objfile->obfd) ?
@@ -12071,7 +12071,7 @@ static void
 dwarf2_const_value_attr (struct attribute *attr, struct type *type,
 			 const char *name, struct obstack *obstack,
 			 struct dwarf2_cu *cu,
-			 long *value, gdb_byte **bytes,
+			 LONGEST *value, gdb_byte **bytes,
 			 struct dwarf2_locexpr_baton **baton)
 {
   struct objfile *objfile = cu->objfile;
@@ -12178,7 +12178,7 @@ dwarf2_const_value (struct attribute *attr, struct symbol *sym,
 {
   struct objfile *objfile = cu->objfile;
   struct comp_unit_head *cu_header = &cu->header;
-  long value;
+  LONGEST value;
   gdb_byte *bytes;
   struct dwarf2_locexpr_baton *baton;
 
diff --git a/gdb/symmisc.c b/gdb/symmisc.c
index daa0b43..b0ab29b 100644
--- a/gdb/symmisc.c
+++ b/gdb/symmisc.c
@@ -509,9 +509,9 @@ print_symbol (void *args)
       switch (SYMBOL_CLASS (symbol))
 	{
 	case LOC_CONST:
-	  fprintf_filtered (outfile, "const %ld (0x%lx)",
-			    SYMBOL_VALUE (symbol),
-			    SYMBOL_VALUE (symbol));
+	  fprintf_filtered (outfile, "const %s (%s)",
+			    plongest (SYMBOL_VALUE (symbol)),
+			    hex_string (SYMBOL_VALUE (symbol)));
 	  break;
 
 	case LOC_CONST_BYTES:
@@ -539,28 +539,31 @@ print_symbol (void *args)
 
 	case LOC_REGISTER:
 	  if (SYMBOL_IS_ARGUMENT (symbol))
-	    fprintf_filtered (outfile, "parameter register %ld",
-			      SYMBOL_VALUE (symbol));
+	    fprintf_filtered (outfile, "parameter register %s",
+			      plongest (SYMBOL_VALUE (symbol)));
 	  else
-	    fprintf_filtered (outfile, "register %ld", SYMBOL_VALUE (symbol));
+	    fprintf_filtered (outfile, "register %s",
+			      plongest (SYMBOL_VALUE (symbol)));
 	  break;
 
 	case LOC_ARG:
-	  fprintf_filtered (outfile, "arg at offset 0x%lx",
-			    SYMBOL_VALUE (symbol));
+	  fprintf_filtered (outfile, "arg at offset %s",
+			    hex_string (SYMBOL_VALUE (symbol)));
 	  break;
 
 	case LOC_REF_ARG:
-	  fprintf_filtered (outfile, "reference arg at 0x%lx", SYMBOL_VALUE (symbol));
+	  fprintf_filtered (outfile, "reference arg at %s",
+			    hex_string (SYMBOL_VALUE (symbol)));
 	  break;
 
 	case LOC_REGPARM_ADDR:
-	  fprintf_filtered (outfile, "address parameter register %ld", SYMBOL_VALUE (symbol));
+	  fprintf_filtered (outfile, "address parameter register %s",
+			    plongest (SYMBOL_VALUE (symbol)));
 	  break;
 
 	case LOC_LOCAL:
-	  fprintf_filtered (outfile, "local at offset 0x%lx",
-			    SYMBOL_VALUE (symbol));
+	  fprintf_filtered (outfile, "local at offset %s",
+			    hex_string (SYMBOL_VALUE (symbol)));
 	  break;
 
 	case LOC_TYPEDEF:
diff --git a/gdb/symtab.h b/gdb/symtab.h
index d9e5f4a..6933c0c 100644
--- a/gdb/symtab.h
+++ b/gdb/symtab.h
@@ -109,10 +109,7 @@ struct general_symbol_info
 
   union
   {
-    /* The fact that this is a long not a LONGEST mainly limits the
-       range of a LOC_CONST.  Since LOC_CONST_BYTES exists, I'm not
-       sure that is a big deal.  */
-    long ivalue;
+    LONGEST ivalue;
 
     struct block *block;
 
diff --git a/gdb/tracepoint.c b/gdb/tracepoint.c
index 057b441..86b6cfa 100644
--- a/gdb/tracepoint.c
+++ b/gdb/tracepoint.c
@@ -740,10 +740,10 @@ validate_actionline (char **line, struct breakpoint *b)
 		{
 		  if (SYMBOL_CLASS (exp->elts[2].symbol) == LOC_CONST)
 		    {
-		      error (_("constant `%s' (value %ld) "
+		      error (_("constant `%s' (value %s) "
 			       "will not be collected."),
 			     SYMBOL_PRINT_NAME (exp->elts[2].symbol),
-			     SYMBOL_VALUE (exp->elts[2].symbol));
+			     plongest (SYMBOL_VALUE (exp->elts[2].symbol)));
 		    }
 		  else if (SYMBOL_CLASS (exp->elts[2].symbol)
 			   == LOC_OPTIMIZED_OUT)
@@ -980,8 +980,8 @@ collect_symbol (struct collection_list *collect,
 		       SYMBOL_CLASS (sym));
       break;
     case LOC_CONST:
-      printf_filtered ("constant %s (value %ld) will not be collected.\n",
-		       SYMBOL_PRINT_NAME (sym), SYMBOL_VALUE (sym));
+      printf_filtered ("constant %s (value %s) will not be collected.\n",
+		       SYMBOL_PRINT_NAME (sym), plongest (SYMBOL_VALUE (sym)));
       break;
     case LOC_STATIC:
       offset = SYMBOL_VALUE_ADDRESS (sym);
@@ -2623,8 +2623,9 @@ scope_info (char *args, int from_tty)
 	      count--;		/* Don't count this one.  */
 	      continue;
 	    case LOC_CONST:
-	      printf_filtered ("a constant with value %ld (0x%lx)",
-			       SYMBOL_VALUE (sym), SYMBOL_VALUE (sym));
+	      printf_filtered ("a constant with value %s (%s)",
+			       plongest (SYMBOL_VALUE (sym)),
+			       hex_string (SYMBOL_VALUE (sym)));
 	      break;
 	    case LOC_CONST_BYTES:
 	      printf_filtered ("constant bytes: ");
@@ -2657,16 +2658,16 @@ scope_info (char *args, int from_tty)
 				 gdbarch_register_name (gdbarch, regno));
 	      break;
 	    case LOC_ARG:
-	      printf_filtered ("an argument at stack/frame offset %ld",
-			       SYMBOL_VALUE (sym));
+	      printf_filtered ("an argument at stack/frame offset %s",
+			       plongest (SYMBOL_VALUE (sym)));
 	      break;
 	    case LOC_LOCAL:
-	      printf_filtered ("a local variable at frame offset %ld",
-			       SYMBOL_VALUE (sym));
+	      printf_filtered ("a local variable at frame offset %s",
+			       plongest (SYMBOL_VALUE (sym)));
 	      break;
 	    case LOC_REF_ARG:
-	      printf_filtered ("a reference argument at offset %ld",
-			       SYMBOL_VALUE (sym));
+	      printf_filtered ("a reference argument at offset %s",
+			       plongest (SYMBOL_VALUE (sym)));
 	      break;
 	    case LOC_REGPARM_ADDR:
 	      /* Note comment at LOC_REGISTER.  */