* printcmd.c (decode_format): Don't blithely set the size for

an address to 'w'.  Make it 'g' or 'h', depending on TARGET_PTR_BIT.

	* defs.h: Just typedef CORE_ADDR to bfd_vma.  Include bfd.h.
	If BFD64, make a LONGEST a BFD_HOST_64_BIT.
	* defs.h (longest_to_int): Don't depend on CC_HAS_LONG_LONG; instead
	always just check against INT_MIN and INT_MAX (this also fixes things
	if sizeof (long) > sizeof (int), e.g. Alpha).
	* config/pa/tm-hppa.h, config/i386/sun386.h, config/rs6000/tm-rs6000.h:
	Don't define LONGEST or BUILTIN_TYPE_LONGEST.
	* gdbtypes.h: Remove BUILTIN_TYPE_LONGEST and
	BUILTIN_TYPE_UNSIGNED_LONGEST.
	* language.h, c-lang.c, ch-lang.c, m2-lang.c: Remove longest_int
	and longest_unsigned_int.
	* value.h (struct value): Just align to LONGEST, rather than worrying
	about CC_HAS_LONG_LONG.
	* valarith.c (value_binop, _initialize_valarith): Figure out type
	ourself based on sizeof (LONGEST) rather than relying on
	BUILTIN_TYPE_LONGEST.  The point is that we don't depend on
	CC_HAS_LONG_LONG anymore.
	* valprint.c (val_print_type_code_int): Just call
	extract_unsigned_integer directly, rather than going through
	unpack_long.
	* printcmd.c (decode_format): Remove code which would sometimes
	change 'g' size to 'w' for integers.  print_scalar_formatted handles
	printing huge integers well enough, thank you.

gdb/ChangeLog

@@ -1,5 +1,32 @@
 Wed Feb  2 11:16:45 1994  Jim Kingdon  (kingdon@lioth.cygnus.com)
 
+	* printcmd.c (decode_format): Don't blithely set the size for
+	an address to 'w'.  Make it 'g' or 'h', depending on TARGET_PTR_BIT.
+
+	* defs.h: Just typedef CORE_ADDR to bfd_vma.  Include bfd.h.
+	If BFD64, make a LONGEST a BFD_HOST_64_BIT.
+	* defs.h (longest_to_int): Don't depend on CC_HAS_LONG_LONG; instead
+	always just check against INT_MIN and INT_MAX (this also fixes things
+	if sizeof (long) > sizeof (int), e.g. Alpha).
+	* config/pa/tm-hppa.h, config/i386/sun386.h, config/rs6000/tm-rs6000.h:
+	Don't define LONGEST or BUILTIN_TYPE_LONGEST.
+	* gdbtypes.h: Remove BUILTIN_TYPE_LONGEST and
+	BUILTIN_TYPE_UNSIGNED_LONGEST.
+	* language.h, c-lang.c, ch-lang.c, m2-lang.c: Remove longest_int
+	and longest_unsigned_int.
+	* value.h (struct value): Just align to LONGEST, rather than worrying
+	about CC_HAS_LONG_LONG.
+	* valarith.c (value_binop, _initialize_valarith): Figure out type
+	ourself based on sizeof (LONGEST) rather than relying on
+	BUILTIN_TYPE_LONGEST.  The point is that we don't depend on
+	CC_HAS_LONG_LONG anymore.
+	* valprint.c (val_print_type_code_int): Just call
+	extract_unsigned_integer directly, rather than going through
+	unpack_long.
+	* printcmd.c (decode_format): Remove code which would sometimes
+	change 'g' size to 'w' for integers.  print_scalar_formatted handles
+	printing huge integers well enough, thank you.
+
 	* command.c (add_set_cmd, no_just_help_class_command): Change
 	to make this the sfunc, not cfunc, since that is how we call it.
 	* command.h: Comment difference between sfunc and cfunc.

gdb/c-lang.c

@@ -404,8 +404,6 @@ const struct language_defn c_language_defn = {
   c_create_fundamental_type,	/* Create fundamental type in this language */
   c_print_type,			/* Print a type using appropriate syntax */
   c_val_print,			/* Print a value using appropriate syntax */
-  &BUILTIN_TYPE_LONGEST,	/* longest signed   integral type */
-  &BUILTIN_TYPE_UNSIGNED_LONGEST,/* longest unsigned integral type */
   &builtin_type_double,		/* longest floating point type */ /*FIXME*/
   {"",     "",    "",  ""},	/* Binary format info */
   {"0%lo",  "0",   "o", ""},	/* Octal format info */
@@ -428,8 +426,6 @@ const struct language_defn cplus_language_defn = {
   c_create_fundamental_type,	/* Create fundamental type in this language */
   c_print_type,			/* Print a type using appropriate syntax */
   c_val_print,			/* Print a value using appropriate syntax */
-  &BUILTIN_TYPE_LONGEST,	 /* longest signed   integral type */
-  &BUILTIN_TYPE_UNSIGNED_LONGEST,/* longest unsigned integral type */
   &builtin_type_double,		/* longest floating point type */ /*FIXME*/
   {"",      "",    "",   ""},	/* Binary format info */
   {"0%lo",   "0",   "o",  ""},	/* Octal format info */

gdb/ch-lang.c

@@ -315,8 +315,6 @@ const struct language_defn chill_language_defn = {
   chill_create_fundamental_type,/* Create fundamental type in this language */
   chill_print_type,		/* Print a type using appropriate syntax */
   chill_val_print,		/* Print a value using appropriate syntax */
-  &BUILTIN_TYPE_LONGEST,	/* longest signed   integral type */
-  &BUILTIN_TYPE_UNSIGNED_LONGEST,/* longest unsigned integral type */
   &builtin_type_chill_real,	/* longest floating point type */
   {"",      "B'",  "",   ""},	/* Binary format info */
   {"O'%lo",  "O'",  "o",  ""},	/* Octal format info */

gdb/config/i386/tm-sun386.h

@@ -86,12 +86,6 @@ i386_skip_prologue PARAMS ((int));
 
 #define INVALID_FLOAT(p, len) (0)
 
-/* Largest integer type */
-#define LONGEST long
-
-/* Name of the builtin type for the LONGEST type above. */
-#define BUILTIN_TYPE_LONGEST builtin_type_long
-
 /* Say how long (ordinary) registers are.  This is a piece of bogosity
    used in push_word and a few other places; REGISTER_RAW_SIZE is the
    real way to know how big a register is.  */

gdb/gdbtypes.h

@@ -600,20 +600,6 @@ extern struct type *builtin_type_chill_long;
 extern struct type *builtin_type_chill_ulong;
 extern struct type *builtin_type_chill_real;
 
-/* CC_HAS_LONG_LONG is defined if the host has "long long".  */
-
-#ifdef CC_HAS_LONG_LONG
-
-#define BUILTIN_TYPE_LONGEST builtin_type_long_long
-#define BUILTIN_TYPE_UNSIGNED_LONGEST builtin_type_unsigned_long_long
-
-#else /* not CC_HAS_LONG_LONG.  */
-
-#define BUILTIN_TYPE_LONGEST builtin_type_long
-#define BUILTIN_TYPE_UNSIGNED_LONGEST builtin_type_unsigned_long
-
-#endif /* not CC_HAS_LONG_LONG.  */
-
 /* Maximum and minimum values of built-in types */
 
 #define	MAX_OF_TYPE(t)	\

gdb/language.h

@@ -144,14 +144,6 @@ struct language_defn
   int (*la_val_print) PARAMS ((struct type *, char *,  CORE_ADDR, GDB_FILE *,
 			       int, int, int, enum val_prettyprint));
 
-  /* Longest signed integral type */
-
-  struct type **la_longest_int;
-
-  /* Longest unsigned integral type */
-
-  struct type **la_longest_unsigned_int;
-
   /* Longest floating point type */
 
   struct type **la_longest_float;
@@ -244,8 +236,6 @@ set_language PARAMS ((enum language));
    with the "set language" command. */
 
 /* Returns some built-in types */
-#define	longest_int()		(*current_language->la_longest_int)
-#define	longest_unsigned_int()	(*current_language->la_longest_unsigned_int)
 #define	longest_float()		(*current_language->la_longest_float)
 
 #define create_fundamental_type(objfile,typeid) \

gdb/m2-lang.c

@@ -405,8 +405,6 @@ const struct language_defn m2_language_defn = {
   m2_create_fundamental_type,	/* Create fundamental type in this language */
   m2_print_type,		/* Print a type using appropriate syntax */
   m2_val_print,			/* Print a value using appropriate syntax */
-  &builtin_type_m2_int,		/* longest signed   integral type */
-  &builtin_type_m2_card,	/* longest unsigned integral type */
   &builtin_type_m2_real,	/* longest floating point type */
   {"",      "",   "",   ""},	/* Binary format info */
   {"%loB",   "",   "o",  "B"},	/* Octal format info */

gdb/valarith.c

@@ -24,6 +24,7 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 #include "expression.h"
 #include "target.h"
 #include "language.h"
+#include "demangle.h"
 #include <string.h>
 
 /* Define whether or not the C operator '/' truncates towards zero for
@@ -126,7 +127,10 @@ value_subscript (array, idx)
   value bound;
   struct type *range_type;
 
-  if (TYPE_CODE (VALUE_TYPE (array)) == TYPE_CODE_ARRAY)
+  COERCE_REF (array);
+
+  if (TYPE_CODE (VALUE_TYPE (array)) == TYPE_CODE_ARRAY
+      || TYPE_CODE (VALUE_TYPE (array)) == TYPE_CODE_STRING)
     {
       range_type = TYPE_FIELD_TYPE (VALUE_TYPE (array), 0);
       lowerbound = TYPE_FIELD_BITPOS (range_type, 0);
@@ -139,6 +143,7 @@ value_subscript (array, idx)
 	{
 	  return value_subscripted_rvalue (array, idx);
 	}
+      array = value_coerce_array (array);
     }
   return value_ind (value_add (array, idx));
 }
@@ -225,8 +230,8 @@ value_x_binop (arg1, arg2, op, otherop)
      enum exp_opcode op, otherop;
 {
   value * argvec;
-  char *ptr;
+  char *ptr, *mangle_ptr;
-  char tstr[13];
+  char tstr[13], mangle_tstr[13];
   int static_memfuncp;
 
   COERCE_REF (arg1);
@@ -292,7 +297,9 @@ value_x_binop (arg1, arg2, op, otherop)
     default:
       error ("Invalid binary operation specified.");
     }
+
   argvec[0] = value_struct_elt (&arg1, argvec+1, tstr, &static_memfuncp, "structure");
+  
   if (argvec[0])
     {
       if (static_memfuncp)
@@ -320,8 +327,8 @@ value_x_unop (arg1, op)
      enum exp_opcode op;
 {
   value * argvec;
-  char *ptr;
+  char *ptr, *mangle_ptr;
-  char tstr[13];
+  char tstr[13], mangle_tstr[13];
   int static_memfuncp;
 
   COERCE_ENUM (arg1);
@@ -339,6 +346,8 @@ value_x_unop (arg1, op)
   /* make the right function name up */  
   strcpy(tstr,"operator__");
   ptr = tstr+8;
+  strcpy(mangle_tstr, "__");
+  mangle_ptr = mangle_tstr+2;
   switch (op)
     {
     case UNOP_PREINCREMENT:	strcpy(ptr,"++"); break;
@@ -351,7 +360,9 @@ value_x_unop (arg1, op)
     default:
       error ("Invalid binary operation specified.");
     }
+
   argvec[0] = value_struct_elt (&arg1, argvec+1, tstr, &static_memfuncp, "structure");
+
   if (argvec[0])
     {
       if (static_memfuncp)
@@ -506,6 +517,15 @@ value_concat (arg1, arg2)
 }
 
 
+/* The type we give to value_binop results.  This is a kludge to get around
+   the fact that we don't know how to determine the result type from
+   the types of the operands.  (I'm not really sure how much we feel
+   the need to duplicate the exact rules of the current language.
+   They can get really hairy.  But not to do so makes it hard to document
+   just what we *do* do).  */
+static struct type *signed_operation_result;
+static struct type *unsigned_operation_result;
+
 /* Perform a binary operation on two operands which have reasonable
    representations as integers or floats.  This includes booleans,
    characters, integers, or floats.
@@ -543,6 +563,9 @@ value_binop (arg1, arg2, op)
       ||
       TYPE_CODE (VALUE_TYPE (arg2)) == TYPE_CODE_FLT)
     {
+      /* FIXME-if-picky-about-floating-accuracy: Should be doing this
+	 in target format.  real.c in GCC probably has the necessary
+	 code.  */
       double v1, v2, v;
       v1 = value_as_double (arg1);
       v2 = value_as_double (arg2);
@@ -569,8 +592,8 @@ value_binop (arg1, arg2, op)
 	}
 
       val = allocate_value (builtin_type_double);
-      SWAP_TARGET_AND_HOST (&v, sizeof (v));
+      store_floating (VALUE_CONTENTS_RAW (val), TYPE_LENGTH (VALUE_TYPE (val)),
-      *(double *) VALUE_CONTENTS_RAW (val) = v;
+		      v);
     }
   else if (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_BOOL
 	   &&
@@ -598,11 +621,10 @@ value_binop (arg1, arg2, op)
 	      error ("Invalid operation on booleans.");
 	    }
 	  
-	  /* start-sanitize-chill (FIXME!) */
 	  val = allocate_value (builtin_type_chill_bool);
-	  /* end-sanitize-chill */
+	  store_signed_integer (VALUE_CONTENTS_RAW (val),
-	  SWAP_TARGET_AND_HOST (&v, sizeof (v));
+				TYPE_LENGTH (VALUE_TYPE (val)),
-	  *(LONGEST *) VALUE_CONTENTS_RAW (val) = v;
+				v);
       }
   else
     /* Integral operations here.  */
@@ -612,7 +634,7 @@ value_binop (arg1, arg2, op)
       if ((TYPE_UNSIGNED (VALUE_TYPE (arg1))
 	   || TYPE_UNSIGNED (VALUE_TYPE (arg2)))
 	  && (TYPE_LENGTH (VALUE_TYPE (arg1)) >= sizeof (unsigned LONGEST)
-	      || TYPE_LENGTH (VALUE_TYPE (arg1)) >= sizeof (unsigned LONGEST)))
+	      || TYPE_LENGTH (VALUE_TYPE (arg2)) >= sizeof (unsigned LONGEST)))
 	{
 	  unsigned LONGEST v1, v2, v;
 	  v1 = (unsigned LONGEST) value_as_long (arg1);
@@ -643,14 +665,12 @@ value_binop (arg1, arg2, op)
 	    case BINOP_MOD:
 	      /* Knuth 1.2.4, integer only.  Note that unlike the C '%' op,
 	         v1 mod 0 has a defined value, v1. */
-	      /* start-sanitize-chill */
 	      /* Chill specifies that v2 must be > 0, so check for that. */
 	      if (current_language -> la_language == language_chill
 		  && value_as_long (arg2) <= 0)
 		{
 		  error ("Second operand of MOD must be greater than zero.");
 		}
-	      /* end-sanitize-chill */
 	      if (v2 == 0)
 		{
 		  v = v1;
@@ -703,9 +723,10 @@ value_binop (arg1, arg2, op)
 	      error ("Invalid binary operation on numbers.");
 	    }
 
-	  val = allocate_value (BUILTIN_TYPE_UNSIGNED_LONGEST);
+	  val = allocate_value (unsigned_operation_result);
-	  SWAP_TARGET_AND_HOST (&v, sizeof (v));
+	  store_unsigned_integer (VALUE_CONTENTS_RAW (val),
-	  *(unsigned LONGEST *) VALUE_CONTENTS_RAW (val) = v;
+				  TYPE_LENGTH (VALUE_TYPE (val)),
+				  v);
 	}
       else
 	{
@@ -738,14 +759,12 @@ value_binop (arg1, arg2, op)
 	    case BINOP_MOD:
 	      /* Knuth 1.2.4, integer only.  Note that unlike the C '%' op,
 	         X mod 0 has a defined value, X. */
-	      /* start-sanitize-chill */
 	      /* Chill specifies that v2 must be > 0, so check for that. */
 	      if (current_language -> la_language == language_chill
 		  && v2 <= 0)
 		{
 		  error ("Second operand of MOD must be greater than zero.");
 		}
-	      /* end-sanitize-chill */
 	      if (v2 == 0)
 		{
 		  v = v1;
@@ -802,9 +821,10 @@ value_binop (arg1, arg2, op)
 	      error ("Invalid binary operation on numbers.");
 	    }
 	  
-	  val = allocate_value (BUILTIN_TYPE_LONGEST);
+	  val = allocate_value (signed_operation_result);
-	  SWAP_TARGET_AND_HOST (&v, sizeof (v));
+	  store_signed_integer (VALUE_CONTENTS_RAW (val),
-	  *(LONGEST *) VALUE_CONTENTS_RAW (val) = v;
+				TYPE_LENGTH (VALUE_TYPE (val)),
+				v);
 	}
     }
 
@@ -968,3 +988,82 @@ value_complement (arg1)
   return value_from_longest (VALUE_TYPE (arg1), ~ value_as_long (arg1));
 }
 
+/* The INDEX'th bit of SET value whose VALUE_TYPE is TYPE,
+   and whose VALUE_CONTENTS is valaddr.
+   Return -1 if out of range, -2 other error. */
+
+int
+value_bit_index (type, valaddr, index)
+     struct type *type;
+     char *valaddr;
+     int index;
+{
+  struct type *range;
+  int low_bound, high_bound, bit_length;
+  LONGEST word;
+  range = TYPE_FIELD_TYPE (type, 0);
+  if (TYPE_CODE (range) != TYPE_CODE_RANGE)
+    return -2;
+  low_bound = TYPE_LOW_BOUND (range);
+  high_bound = TYPE_HIGH_BOUND (range);
+  if (index < low_bound || index > high_bound)
+    return -1;
+  bit_length = high_bound - low_bound + 1;
+  index -= low_bound;
+  if (bit_length <= TARGET_CHAR_BIT)
+    word = unpack_long (builtin_type_unsigned_char, valaddr);
+  else if (bit_length <= TARGET_SHORT_BIT)
+    word = unpack_long (builtin_type_unsigned_short, valaddr);
+  else
+    {
+      int word_start_index = (index / TARGET_INT_BIT) * TARGET_INT_BIT;
+      index -= word_start_index;
+      word = unpack_long (builtin_type_unsigned_int,
+			  valaddr + (word_start_index / HOST_CHAR_BIT));
+    }
+#if BITS_BIG_ENDIAN
+  if (bit_length <= TARGET_CHAR_BIT)
+    index = TARGET_CHAR_BIT - 1 - index;
+  else if (bit_length <= TARGET_SHORT_BIT)
+    index = TARGET_SHORT_BIT - 1 - index;
+  else
+    index = TARGET_INT_BIT - 1 - index;
+#endif
+  return (word >> index) & 1;
+}
+
+value
+value_in (element, set)
+     value element, set;
+{
+  int member;
+  if (TYPE_CODE (VALUE_TYPE (set)) != TYPE_CODE_SET)
+    error ("Second argument of 'IN' has wrong type");
+  if (TYPE_CODE (VALUE_TYPE (element)) != TYPE_CODE_INT
+      && TYPE_CODE (VALUE_TYPE (element)) != TYPE_CODE_CHAR
+      && TYPE_CODE (VALUE_TYPE (element)) != TYPE_CODE_ENUM
+      && TYPE_CODE (VALUE_TYPE (element)) != TYPE_CODE_BOOL)
+    error ("First argument of 'IN' has wrong type");
+  member = value_bit_index (VALUE_TYPE (set), VALUE_CONTENTS (set),
+			    value_as_long (element));
+  if (member < 0)
+    error ("First argument of 'IN' not in range");
+  return value_from_longest (builtin_type_int, member);
+}
+
+void
+_initialize_valarith ()
+{
+  /* Can't just call init_type because we wouldn't know what names to give
+     them.  */
+  if (sizeof (LONGEST) > TARGET_LONG_BIT / HOST_CHAR_BIT)
+    {
+      unsigned_operation_result = builtin_type_unsigned_long_long;
+      signed_operation_result = builtin_type_long_long;
+    }
+  else
+    {
+      unsigned_operation_result = builtin_type_unsigned_long;
+      signed_operation_result = builtin_type_long;
+    }
+}