* lib/gdb.exp (get_hexadecimal_valueof): New procedure.
[deliverable/binutils-gdb.git] / gdb / eval.c
index 0cccc82866276857a1e34418a0ab255e0d51c44c..038334b5e49aa514ed2982f8745570cdd5a10a7d 100644 (file)
@@ -1,8 +1,8 @@
 /* Evaluate expressions for GDB.
 
    Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
-   1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2005, 2006, 2007, 2008
-   Free Software Foundation, Inc.
+   1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2005, 2006, 2007, 2008,
+   2009 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
 #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))
@@ -826,7 +824,7 @@ evaluate_subexp_standard (struct type *expect_type,
       if (expect_type != NULL_TYPE && noside != EVAL_SKIP
          && TYPE_CODE (type) == TYPE_CODE_ARRAY)
        {
-         struct type *range_type = TYPE_FIELD_TYPE (type, 0);
+         struct type *range_type = TYPE_INDEX_TYPE (type);
          struct type *element_type = TYPE_TARGET_TYPE (type);
          struct value *array = allocate_value (expect_type);
          int element_size = TYPE_LENGTH (check_typedef (element_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
@@ -2561,13 +2560,8 @@ evaluate_subexp_for_address (struct expression *exp, int *pos,
          return
            value_zero (type, not_lval);
        }
-      else if (symbol_read_needs_frame (var))
-       return
-         locate_var_value
-         (var,
-          block_innermost_frame (exp->elts[pc + 1].block));
       else
-       return locate_var_value (var, NULL);
+       return address_of_variable (var, exp->elts[pc + 1].block);
 
     case OP_SCOPE:
       tem = longest_to_int (exp->elts[pc + 2].longconst);
@@ -2621,6 +2615,7 @@ evaluate_subexp_with_coercion (struct expression *exp,
   int pc;
   struct value *val;
   struct symbol *var;
+  struct type *type;
 
   pc = (*pos);
   op = exp->elts[pc].opcode;
@@ -2629,14 +2624,13 @@ evaluate_subexp_with_coercion (struct expression *exp,
     {
     case OP_VAR_VALUE:
       var = exp->elts[pc + 2].symbol;
-      if (TYPE_CODE (check_typedef (SYMBOL_TYPE (var))) == TYPE_CODE_ARRAY
+      type = check_typedef (SYMBOL_TYPE (var));
+      if (TYPE_CODE (type) == TYPE_CODE_ARRAY
          && CAST_IS_CONVERSION)
        {
          (*pos) += 4;
-         val =
-           locate_var_value
-           (var, block_innermost_frame (exp->elts[pc + 1].block));
-         return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (check_typedef (SYMBOL_TYPE (var)))),
+         val = address_of_variable (var, exp->elts[pc + 1].block);
+         return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
                             val);
        }
       /* FALLTHROUGH */
This page took 0.026427 seconds and 4 git commands to generate.