* cris.h (R_CRIS_32_IE): New relocation.

[deliverable/binutils-gdb.git] / gdb / eval.c

diff --git a/gdb/eval.c b/gdb/eval.c
index 0cccc82866276857a1e34418a0ab255e0d51c44c..ccb6b742b618b6a04f8840be23a34b7fc5cf4be4 100644 (file)
--- a/gdb/eval.c
+++ b/gdb/eval.c
@@ -39,16 +39,13 @@
 #include "exceptions.h"
 #include "regcache.h"
 #include "user-regs.h"
+#include "valprint.h"
 
 #include "gdb_assert.h"
 
 /* This is defined in valops.c */
 extern int overload_resolution;
 
-/* JYG: lookup rtti type of STRUCTOP_PTR when this is set to continue
-   on with successful lookup for member/method of the rtti type. */
-extern int objectprint;
-
 /* Prototypes for local functions. */
 
 static struct value *evaluate_subexp_for_sizeof (struct expression *, int *);
@@ -319,7 +316,8 @@ evaluate_struct_tuple (struct value *struct_val,
                  fieldno++;
                  /* Skip static fields.  */
                  while (fieldno < TYPE_NFIELDS (struct_type)
-                        && TYPE_FIELD_STATIC_KIND (struct_type, fieldno))
+                        && field_is_static (&TYPE_FIELD (struct_type,
+                                                         fieldno)))
                    fieldno++;
                  subfieldno = fieldno;
                  if (fieldno >= TYPE_NFIELDS (struct_type))
@@ -1076,8 +1074,9 @@ evaluate_subexp_standard (struct type *expect_type,
            type = lookup_function_type (type);
            type = lookup_pointer_type (type);
 
-           msg_send = find_function_in_inferior ("objc_msg_lookup");
-           msg_send_stret = find_function_in_inferior ("objc_msg_lookup");
+           msg_send = find_function_in_inferior ("objc_msg_lookup", NULL);
+           msg_send_stret
+             = find_function_in_inferior ("objc_msg_lookup", NULL);
 
            msg_send = value_from_pointer (type, value_as_address (msg_send));
            msg_send_stret = value_from_pointer (type, 
@@ -1085,9 +1084,10 @@ evaluate_subexp_standard (struct type *expect_type,
          }
        else
          {
-           msg_send = find_function_in_inferior ("objc_msgSend");
+           msg_send = find_function_in_inferior ("objc_msgSend", NULL);
            /* Special dispatcher for methods returning structs */
-           msg_send_stret = find_function_in_inferior ("objc_msgSend_stret");
+           msg_send_stret
+             = find_function_in_inferior ("objc_msgSend_stret", NULL);
          }
 
        /* Verify the target object responds to this method. The
@@ -1625,8 +1625,10 @@ evaluate_subexp_standard (struct type *expect_type,
         struct type *type = value_type (arg1);
         struct type *real_type;
         int full, top, using_enc;
-        
-        if (objectprint && TYPE_TARGET_TYPE(type) &&
+       struct value_print_options opts;
+
+       get_user_print_options (&opts);
+        if (opts.objectprint && TYPE_TARGET_TYPE(type) &&
             (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_CLASS))
           {
             real_type = value_rtti_target_type (arg1, &full, &top, &using_enc);
@@ -1974,6 +1976,8 @@ evaluate_subexp_standard (struct type *expect_type,
        if (nargs != ndimensions)
          error (_("Wrong number of subscripts"));
 
+       gdb_assert (nargs > 0);
+
        /* Now that we know we have a legal array subscript expression 
           let us actually find out where this element exists in the array. */
 
@@ -1992,13 +1996,8 @@ evaluate_subexp_standard (struct type *expect_type,
        /* Internal type of array is arranged right to left */
        for (i = 0; i < nargs; i++)
          {
-           retcode = f77_get_dynamic_upperbound (tmp_type, &upper);
-           if (retcode == BOUND_FETCH_ERROR)
-             error (_("Cannot obtain dynamic upper bound"));
-
-           retcode = f77_get_dynamic_lowerbound (tmp_type, &lower);
-           if (retcode == BOUND_FETCH_ERROR)
-             error (_("Cannot obtain dynamic lower bound"));
+           upper = f77_get_upperbound (tmp_type);
+           lower = f77_get_lowerbound (tmp_type);
 
            array_size_array[nargs - i - 1] = upper - lower + 1;
 
@@ -2028,7 +2027,7 @@ evaluate_subexp_standard (struct type *expect_type,
 
        /* Construct a value node with the value of the offset */
 
-       arg2 = value_from_longest (builtin_type_f_integer, offset_item);
+       arg2 = value_from_longest (builtin_type_int32, offset_item);
 
        /* Let us now play a dirty trick: we will take arg1 
           which is a value node pointing to the topmost level