[rfc][03/37] Eliminate builtin_type_ macros: Extract bitstring subscript handling

[uweigand@de.ibm.com]

[-- Attachment #1: diff-type-bitstring --]
[-- Type: text/plain, Size: 5316 bytes --]

Hello,

in preparation to removing use of the LA_BOOL_TYPE macro, this patch
moves handling of TYPE_CODE_BITSTRING subscripts out of value_subscript
into a new function value_bitstring_subscript that gets the boolean
type requested by the caller as argument.

Bye,
Ulrich


ChangeLog:

	* value.h (value_bitstring_subscript): New prototype.
	* valarith.h (value_bitstring_subscript): New function.
	(value_subscript): No longer handle TYPE_CODE_BITSTRING.
	* eval.c (evaluate_subexp_standard): Call value_bitstring_subscript
	instead of value_subscript to handle TYPE_CODE_BITSTRING.


Index: gdb-head/gdb/eval.c
===================================================================
--- gdb-head.orig/gdb/eval.c
+++ gdb-head/gdb/eval.c
@@ -1666,7 +1666,28 @@ evaluate_subexp_standard (struct type *e
 	    }
 	  else
 	    {
-	      arg1 = value_subscript (arg1, arg2);
+	      arg1 = coerce_ref (arg1);
+	      type = check_typedef (value_type (arg1));
+
+	      switch (TYPE_CODE (type))
+		{
+		case TYPE_CODE_PTR:
+		case TYPE_CODE_ARRAY:
+		case TYPE_CODE_STRING:
+		  arg1 = value_subscript (arg1, arg2);
+		  break;
+
+		case TYPE_CODE_BITSTRING:
+		  arg1 = value_bitstring_subscript (LA_BOOL_TYPE, arg1, arg2);
+		  break;
+
+		default:
+		  if (TYPE_NAME (type))
+		    error (_("cannot subscript something of type `%s'"),
+			   TYPE_NAME (type));
+		  else
+		    error (_("cannot subscript requested type"));
+		}
 	    }
 	}
       return (arg1);
Index: gdb-head/gdb/valarith.c
===================================================================
--- gdb-head.orig/gdb/valarith.c
+++ gdb-head/gdb/valarith.c
@@ -218,34 +218,6 @@ value_subscript (struct value *array, st
       array = value_coerce_array (array);
     }
 
-  if (TYPE_CODE (tarray) == TYPE_CODE_BITSTRING)
-    {
-      struct type *range_type = TYPE_INDEX_TYPE (tarray);
-      LONGEST index = value_as_long (idx);
-      struct value *v;
-      int offset, byte, bit_index;
-      LONGEST lowerbound, upperbound;
-      get_discrete_bounds (range_type, &lowerbound, &upperbound);
-      if (index < lowerbound || index > upperbound)
-	error (_("bitstring index out of range"));
-      index -= lowerbound;
-      offset = index / TARGET_CHAR_BIT;
-      byte = *((char *) value_contents (array) + offset);
-      bit_index = index % TARGET_CHAR_BIT;
-      byte >>= (gdbarch_bits_big_endian (current_gdbarch) ?
-		TARGET_CHAR_BIT - 1 - bit_index : bit_index);
-      v = value_from_longest (LA_BOOL_TYPE, byte & 1);
-      set_value_bitpos (v, bit_index);
-      set_value_bitsize (v, 1);
-      VALUE_LVAL (v) = VALUE_LVAL (array);
-      if (VALUE_LVAL (array) == lval_internalvar)
-	VALUE_LVAL (v) = lval_internalvar_component;
-      VALUE_ADDRESS (v) = VALUE_ADDRESS (array);
-      VALUE_FRAME_ID (v) = VALUE_FRAME_ID (array);
-      set_value_offset (v, offset + value_offset (array));
-      return v;
-    }
-
   if (c_style)
     return value_ind (value_add (array, idx));
   else
@@ -286,6 +258,52 @@ value_subscripted_rvalue (struct value *
   set_value_offset (v, value_offset (array) + elt_offs);
   return v;
 }
+
+/* Return the value of BITSTRING[IDX] as (boolean) type TYPE.  */
+
+struct value *
+value_bitstring_subscript (struct type *type,
+			   struct value *bitstring, struct value *idx)
+{
+
+  struct type *bitstring_type, *range_type;
+  LONGEST index = value_as_long (idx);
+  struct value *v;
+  int offset, byte, bit_index;
+  LONGEST lowerbound, upperbound;
+
+  bitstring_type = check_typedef (value_type (bitstring));
+  gdb_assert (TYPE_CODE (bitstring_type) == TYPE_CODE_BITSTRING);
+
+  range_type = TYPE_INDEX_TYPE (bitstring_type);
+  get_discrete_bounds (range_type, &lowerbound, &upperbound);
+  if (index < lowerbound || index > upperbound)
+    error (_("bitstring index out of range"));
+
+  index -= lowerbound;
+  offset = index / TARGET_CHAR_BIT;
+  byte = *((char *) value_contents (bitstring) + offset);
+
+  bit_index = index % TARGET_CHAR_BIT;
+  byte >>= (gdbarch_bits_big_endian (current_gdbarch) ?
+	    TARGET_CHAR_BIT - 1 - bit_index : bit_index);
+
+  v = value_from_longest (type, byte & 1);
+
+  set_value_bitpos (v, bit_index);
+  set_value_bitsize (v, 1);
+
+  VALUE_LVAL (v) = VALUE_LVAL (bitstring);
+  if (VALUE_LVAL (bitstring) == lval_internalvar)
+    VALUE_LVAL (v) = lval_internalvar_component;
+  VALUE_ADDRESS (v) = VALUE_ADDRESS (bitstring);
+  VALUE_FRAME_ID (v) = VALUE_FRAME_ID (bitstring);
+
+  set_value_offset (v, offset + value_offset (bitstring));
+
+  return v;
+}
+
 \f
 /* Check to see if either argument is a structure, or a reference to
    one.  This is called so we know whether to go ahead with the normal
Index: gdb-head/gdb/value.h
===================================================================
--- gdb-head.orig/gdb/value.h
+++ gdb-head/gdb/value.h
@@ -405,6 +405,10 @@ extern struct value *value_repeat (struc
 
 extern struct value *value_subscript (struct value *array, struct value *idx);
 
+extern struct value *value_bitstring_subscript (struct type *type,
+						struct value *bitstring,
+						struct value *idx);
+
 extern struct value *register_value_being_returned (struct type *valtype,
 						    struct regcache *retbuf);
 

-- 
  Dr. Ulrich Weigand
  GNU Toolchain for Linux on System z and Cell BE
  Ulrich.Weigand@de.ibm.com