Add unit test for xml_escape_text

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

diff --git a/gdb/valarith.c b/gdb/valarith.c
index 97145a1526569855f7b9ae19cba87c4b9083c72b..a277be42bc03f0dad0a3e52616196db276786e55 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.
 
@@ -36,9 +36,6 @@
 #define TRUNCATION_TOWARDS_ZERO ((-5 / 2) == -2)
 #endif
 
-void _initialize_valarith (void);
-\f
-
 /* Given a pointer, return the size of its target.
    If the pointer type is void *, then return 1.
    If the target type is incomplete, then error out.
@@ -192,9 +189,8 @@ 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_units (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_units (array_type)))
@@ -207,21 +203,15 @@ value_subscripted_rvalue (struct value *array, LONGEST index, int lowerbound)
         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
@@ -239,11 +229,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
@@ -277,7 +267,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;
 }
@@ -512,7 +502,7 @@ value_x_binop (struct value *arg1, struct value *arg2, enum exp_opcode op,
            = TYPE_TARGET_TYPE (check_typedef (value_type (argvec[0])));
          return value_zero (return_type, VALUE_LVAL (arg1));
        }
-      return call_function_by_hand (argvec[0], 2 - static_memfuncp,
+      return call_function_by_hand (argvec[0], NULL, 2 - static_memfuncp,
                                    argvec + 1);
     }
   throw_error (NOT_FOUND_ERROR,
@@ -631,7 +621,7 @@ value_x_unop (struct value *arg1, enum exp_opcode op, enum noside noside)
            = TYPE_TARGET_TYPE (check_typedef (value_type (argvec[0])));
          return value_zero (return_type, VALUE_LVAL (arg1));
        }
-      return call_function_by_hand (argvec[0], nargs, argvec + 1);
+      return call_function_by_hand (argvec[0], NULL, nargs, argvec + 1);
     }
   throw_error (NOT_FOUND_ERROR,
                _("member function %s not found"), tstr);
@@ -704,12 +694,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;
@@ -718,7 +705,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
@@ -727,12 +714,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)
        {
@@ -746,8 +732,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)
@@ -756,31 +740,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)
     {