Move command lines types/declarations to cli-script.h

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

diff --git a/gdb/valarith.c b/gdb/valarith.c
index 0162c10681aeadade85f3ec68f8115c9547be5b4..9724acace78b1f84e0f70c540893d190f7193c00 100644 (file)
--- a/gdb/valarith.c
+++ b/gdb/valarith.c
@@ -1,6 +1,6 @@
 /* Perform arithmetic and other operations on values, for GDB.
 
-   Copyright (C) 1986-2015 Free Software Foundation, Inc.
+   Copyright (C) 1986-2017 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
@@ -54,7 +54,7 @@ find_size_for_pointer_math (struct type *ptr_type)
   gdb_assert (TYPE_CODE (ptr_type) == TYPE_CODE_PTR);
   ptr_target = check_typedef (TYPE_TARGET_TYPE (ptr_type));
 
-  sz = TYPE_LENGTH (ptr_target);
+  sz = type_length_units (ptr_target);
   if (sz == 0)
     {
       if (TYPE_CODE (ptr_type) == TYPE_CODE_VOID)
@@ -121,7 +121,7 @@ value_ptrdiff (struct value *arg1, struct value *arg2)
             "second argument is neither\n"
             "an integer nor a pointer of the same type."));
 
-  sz = TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type1)));
+  sz = type_length_units (check_typedef (TYPE_TARGET_TYPE (type1)));
   if (sz == 0) 
     {
       warning (_("Type size unknown, assuming 1. "
@@ -192,29 +192,29 @@ value_subscripted_rvalue (struct value *array, LONGEST index, int lowerbound)
 {
   struct type *array_type = check_typedef (value_type (array));
   struct type *elt_type = check_typedef (TYPE_TARGET_TYPE (array_type));
-  unsigned int elt_size = TYPE_LENGTH (elt_type);
-  unsigned int elt_offs = elt_size * longest_to_int (index - lowerbound);
-  struct value *v;
+  ULONGEST elt_size = type_length_units (elt_type);
+  ULONGEST elt_offs = elt_size * (index - lowerbound);
 
   if (index < lowerbound || (!TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (array_type)
-                            && elt_offs >= TYPE_LENGTH (array_type)))
-    error (_("no such vector element"));
+                            && elt_offs >= type_length_units (array_type)))
+    {
+      if (type_not_associated (array_type))
+        error (_("no such vector element (vector not associated)"));
+      else if (type_not_allocated (array_type))
+        error (_("no such vector element (vector not allocated)"));
+      else
+        error (_("no such vector element"));
+    }
 
-  if (VALUE_LVAL (array) == lval_memory && value_lazy (array))
-    v = allocate_value_lazy (elt_type);
-  else
+  if (is_dynamic_type (elt_type))
     {
-      v = allocate_value (elt_type);
-      value_contents_copy (v, value_embedded_offset (v),
-                          array, value_embedded_offset (array) + elt_offs,
-                          elt_size);
+      CORE_ADDR address;
+
+      address = value_address (array) + elt_offs;
+      elt_type = resolve_dynamic_type (elt_type, NULL, address);
     }
 
-  set_value_component_location (v, array);
-  VALUE_REGNUM (v) = VALUE_REGNUM (array);
-  VALUE_FRAME_ID (v) = VALUE_FRAME_ID (array);
-  set_value_offset (v, value_offset (array) + elt_offs);
-  return v;
+  return value_from_component (array, elt_type, elt_offs);
 }
 
 \f
@@ -232,11 +232,11 @@ binop_types_user_defined_p (enum exp_opcode op,
     return 0;
 
   type1 = check_typedef (type1);
-  if (TYPE_CODE (type1) == TYPE_CODE_REF)
+  if (TYPE_IS_REFERENCE (type1))
     type1 = check_typedef (TYPE_TARGET_TYPE (type1));
 
   type2 = check_typedef (type2);
-  if (TYPE_CODE (type2) == TYPE_CODE_REF)
+  if (TYPE_IS_REFERENCE (type2))
     type2 = check_typedef (TYPE_TARGET_TYPE (type2));
 
   return (TYPE_CODE (type1) == TYPE_CODE_STRUCT
@@ -270,7 +270,7 @@ unop_user_defined_p (enum exp_opcode op, struct value *arg1)
   if (op == UNOP_ADDR)
     return 0;
   type1 = check_typedef (value_type (arg1));
-  if (TYPE_CODE (type1) == TYPE_CODE_REF)
+  if (TYPE_IS_REFERENCE (type1))
     type1 = check_typedef (TYPE_TARGET_TYPE (type1));
   return TYPE_CODE (type1) == TYPE_CODE_STRUCT;
 }
@@ -697,12 +697,9 @@ value_concat (struct value *arg1, struct value *arg2)
       if (TYPE_CODE (type2) == TYPE_CODE_STRING
          || TYPE_CODE (type2) == TYPE_CODE_CHAR)
        {
-         struct cleanup *back_to;
-
          count = longest_to_int (value_as_long (inval1));
          inval2len = TYPE_LENGTH (type2);
-         ptr = (char *) xmalloc (count * inval2len);
-         back_to = make_cleanup (xfree, ptr);
+         std::vector<char> ptr (count * inval2len);
          if (TYPE_CODE (type2) == TYPE_CODE_CHAR)
            {
              char_type = type2;
@@ -711,7 +708,7 @@ value_concat (struct value *arg1, struct value *arg2)
                                           value_contents (inval2));
              for (idx = 0; idx < count; idx++)
                {
-                 *(ptr + idx) = inchar;
+                 ptr[idx] = inchar;
                }
            }
          else
@@ -720,12 +717,11 @@ value_concat (struct value *arg1, struct value *arg2)
 
              for (idx = 0; idx < count; idx++)
                {
-                 memcpy (ptr + (idx * inval2len), value_contents (inval2),
+                 memcpy (&ptr[idx * inval2len], value_contents (inval2),
                          inval2len);
                }
            }
-         outval = value_string (ptr, count * inval2len, char_type);
-         do_cleanups (back_to);
+         outval = value_string (ptr.data (), count * inval2len, char_type);
        }
       else if (TYPE_CODE (type2) == TYPE_CODE_BOOL)
        {
@@ -739,8 +735,6 @@ value_concat (struct value *arg1, struct value *arg2)
   else if (TYPE_CODE (type1) == TYPE_CODE_STRING
           || TYPE_CODE (type1) == TYPE_CODE_CHAR)
     {
-      struct cleanup *back_to;
-
       /* We have two character strings to concatenate.  */
       if (TYPE_CODE (type2) != TYPE_CODE_STRING
          && TYPE_CODE (type2) != TYPE_CODE_CHAR)
@@ -749,31 +743,29 @@ value_concat (struct value *arg1, struct value *arg2)
        }
       inval1len = TYPE_LENGTH (type1);
       inval2len = TYPE_LENGTH (type2);
-      ptr = (char *) xmalloc (inval1len + inval2len);
-      back_to = make_cleanup (xfree, ptr);
+      std::vector<char> ptr (inval1len + inval2len);
       if (TYPE_CODE (type1) == TYPE_CODE_CHAR)
        {
          char_type = type1;
 
-         *ptr = (char) unpack_long (type1, value_contents (inval1));
+         ptr[0] = (char) unpack_long (type1, value_contents (inval1));
        }
       else
        {
          char_type = TYPE_TARGET_TYPE (type1);
 
-         memcpy (ptr, value_contents (inval1), inval1len);
+         memcpy (ptr.data (), value_contents (inval1), inval1len);
        }
       if (TYPE_CODE (type2) == TYPE_CODE_CHAR)
        {
-         *(ptr + inval1len) =
+         ptr[inval1len] =
            (char) unpack_long (type2, value_contents (inval2));
        }
       else
        {
-         memcpy (ptr + inval1len, value_contents (inval2), inval2len);
+         memcpy (&ptr[inval1len], value_contents (inval2), inval2len);
        }
-      outval = value_string (ptr, inval1len + inval2len, char_type);
-      do_cleanups (back_to);
+      outval = value_string (ptr.data (), inval1len + inval2len, char_type);
     }
   else if (TYPE_CODE (type1) == TYPE_CODE_BOOL)
     {