Remove 'varsize-limit'

This makes the Ada-specific "varsize-limit" a synonym for
"max-value-size", and removes the Ada-specific checks of the limit.

I am not certain of the history here, but it seems to me that this
code is fully obsolete now.  And, removing this makes it possible to
index large Ada arrays without triggering an error.  A new test case
is included to demonstrate this.

diff --git a/gdb/NEWS b/gdb/NEWS
index e0fb006909ef441c463b1e4b1cc42af78746c638..7ca1f842cb1e1ffaf91467a0a92160a1306175be 100644 (file)
--- a/gdb/NEWS
+++ b/gdb/NEWS
@@ -19,6 +19,11 @@ show source open
   to open and read source code files, which can be useful if the files
   are located over a slow network connection.
 
   to open and read source code files, which can be useful if the files
   are located over a slow network connection.
 

+set varsize-limit
+show varsize-limit
+  These are now deprecated aliases for "set max-value-size" and
+  "show max-value-size".
+

 maint set internal-error backtrace on|off
 maint show internal-error backtrace
 maint set internal-warning backtrace on|off
 maint set internal-error backtrace on|off
 maint show internal-error backtrace
 maint set internal-warning backtrace on|off

diff --git a/gdb/ada-lang.c b/gdb/ada-lang.c
index 3b7c10f8e6cd61cdaaf8829dfd280e02a9a97e9f..6a19ad9d01c6f58abda2fe696deee7b22945a89c 100644 (file)
--- a/gdb/ada-lang.c
+++ b/gdb/ada-lang.c
@@ -247,9 +247,6 @@ struct ada_symbol_cache
   struct cache_entry *root[HASH_SIZE] {};
 };
 
   struct cache_entry *root[HASH_SIZE] {};
 };
 

-/* Maximum-sized dynamic type.  */
-static unsigned int varsize_limit;
-

 static const char ada_completer_word_break_characters[] =
 #ifdef VMS
   " \t\n!@#%^&*()+=|~`}{[]\";:?/,-";
 static const char ada_completer_word_break_characters[] =
 #ifdef VMS
   " \t\n!@#%^&*()+=|~`}{[]\";:?/,-";


@@ -524,10 +521,6 @@ coerce_unspec_val_to_type (struct value *val, struct type *type)
     {
       struct value *result;
 
     {
       struct value *result;
 

-      /* Make sure that the object size is not unreasonable before
-        trying to allocate some memory for it.  */
-      ada_ensure_varsize_limit (type);
-

       if (value_optimized_out (val))
        result = allocate_optimized_out_value (type);
       else if (value_lazy (val)
       if (value_optimized_out (val))
        result = allocate_optimized_out_value (type);
       else if (value_lazy (val)


@@ -589,17 +582,6 @@ lim_warning (const char *format, ...)
   va_end (args);
 }
 
   va_end (args);
 }
 

-/* Issue an error if the size of an object of type T is unreasonable,
-   i.e. if it would be a bad idea to allocate a value of this type in
-   GDB.  */
-
-void
-ada_ensure_varsize_limit (const struct type *type)
-{
-  if (TYPE_LENGTH (type) > varsize_limit)
-    error (_("object size is larger than varsize-limit"));
-}
-

 /* Maximum value of a SIZE-byte signed integer type.  */
 static LONGEST
 max_of_size (int size)
 /* Maximum value of a SIZE-byte signed integer type.  */
 static LONGEST
 max_of_size (int size)


@@ -1898,7 +1880,6 @@ ada_coerce_to_simple_array (struct value *arr)
 
       if (arrVal == NULL)
        error (_("Bounds unavailable for null array pointer."));
 
       if (arrVal == NULL)
        error (_("Bounds unavailable for null array pointer."));

-      ada_ensure_varsize_limit (TYPE_TARGET_TYPE (value_type (arrVal)));

       return value_ind (arrVal);
     }
   else if (ada_is_constrained_packed_array_type (value_type (arr)))
       return value_ind (arrVal);
     }
   else if (ada_is_constrained_packed_array_type (value_type (arr)))


@@ -7539,12 +7520,6 @@ ada_template_to_fixed_record_type_1 (struct type *type,
 
          if (dval0 == NULL)
            {
 
          if (dval0 == NULL)
            {

-             /* rtype's length is computed based on the run-time
-                value of discriminants.  If the discriminants are not
-                initialized, the type size may be completely bogus and
-                GDB may fail to allocate a value for it.  So check the
-                size first before creating the value.  */
-             ada_ensure_varsize_limit (rtype);

              /* Using plain value_from_contents_and_address here
                 causes problems because we will end up trying to
                 resolve a type that is currently being
              /* Using plain value_from_contents_and_address here
                 causes problems because we will end up trying to
                 resolve a type that is currently being


@@ -7585,14 +7560,6 @@ ada_template_to_fixed_record_type_1 (struct type *type,
          field_type = ada_get_base_type (field_type);
          field_type = ada_to_fixed_type (field_type, field_valaddr,
                                          field_address, dval, 0);
          field_type = ada_get_base_type (field_type);
          field_type = ada_to_fixed_type (field_type, field_valaddr,
                                          field_address, dval, 0);

-         /* If the field size is already larger than the maximum
-            object size, then the record itself will necessarily
-            be larger than the maximum object size.  We need to make
-            this check now, because the size might be so ridiculously
-            large (due to an uninitialized variable in the inferior)
-            that it would cause an overflow when adding it to the
-            record size.  */
-         ada_ensure_varsize_limit (field_type);

 
          rtype->field (f).set_type (field_type);
          rtype->field (f).set_name (type->field (f).name ());
 
          rtype->field (f).set_type (field_type);
          rtype->field (f).set_name (type->field (f).name ());


@@ -7713,8 +7680,6 @@ ada_template_to_fixed_record_type_1 (struct type *type,
     }
 
   value_free_to_mark (mark);
     }
 
   value_free_to_mark (mark);

-  if (TYPE_LENGTH (rtype) > varsize_limit)
-    error (_("record type with dynamic size is larger than varsize-limit"));

   return rtype;
 }
 
   return rtype;
 }
 


@@ -8161,8 +8126,6 @@ to_fixed_array_type (struct type *type0, struct value *dval,
                                      result, range_type);
          elt_type0 = TYPE_TARGET_TYPE (elt_type0);
        }
                                      result, range_type);
          elt_type0 = TYPE_TARGET_TYPE (elt_type0);
        }

-      if (!ignore_too_big && TYPE_LENGTH (result) > varsize_limit)
-       error (_("array type with dynamic size is larger than varsize-limit"));

     }
 
   /* We want to preserve the type name.  This can be useful when
     }
 
   /* We want to preserve the type name.  This can be useful when


@@ -10584,7 +10547,6 @@ ada_unop_ind_operation::evaluate (struct type *expect_type,
                (ada_aligned_type
                 (ada_check_typedef (TYPE_TARGET_TYPE (type))));
            }
                (ada_aligned_type
                 (ada_check_typedef (TYPE_TARGET_TYPE (type))));
            }

-         ada_ensure_varsize_limit (type);

          return value_zero (type, lval_memory);
        }
       else if (type->code () == TYPE_CODE_INT)
          return value_zero (type, lval_memory);
        }
       else if (type->code () == TYPE_CODE_INT)


@@ -10619,11 +10581,6 @@ ada_unop_ind_operation::evaluate (struct type *expect_type,
                              (CORE_ADDR) value_as_address (arg1));
     }
 
                              (CORE_ADDR) value_as_address (arg1));
     }
 

-  struct type *target_type = (to_static_fixed_type
-                             (ada_aligned_type
-                              (ada_check_typedef (TYPE_TARGET_TYPE (type)))));
-  ada_ensure_varsize_limit (target_type);
-

   if (ada_is_array_descriptor_type (type))
     /* GDB allows dereferencing GNAT array descriptors.  */
     return ada_coerce_to_simple_array (arg1);
   if (ada_is_array_descriptor_type (type))
     /* GDB allows dereferencing GNAT array descriptors.  */
     return ada_coerce_to_simple_array (arg1);


@@ -13593,15 +13550,6 @@ exception should cause a stop."),
                     CATCH_PERMANENT,
                     CATCH_TEMPORARY);
 
                     CATCH_PERMANENT,
                     CATCH_TEMPORARY);
 

-  varsize_limit = 65536;
-  add_setshow_uinteger_cmd ("varsize-limit", class_support,
-                           &varsize_limit, _("\
-Set the maximum number of bytes allowed in a variable-size object."), _("\
-Show the maximum number of bytes allowed in a variable-size object."), _("\
-Attempts to access an object whose size is not a compile-time constant\n\
-and exceeds this limit will cause an error."),
-                           NULL, NULL, &setlist, &showlist);
-

   add_info ("exceptions", info_exceptions_command,
            _("\
 List all Ada exception names.\n\
   add_info ("exceptions", info_exceptions_command,
            _("\
 List all Ada exception names.\n\

diff --git a/gdb/ada-lang.h b/gdb/ada-lang.h
index a89ed29119a24b9c18df066f1f4e3b1bf7b5abb1..0f52ba70649ad7ccbfd894ccf837ce7ef3b077a8 100644 (file)
--- a/gdb/ada-lang.h
+++ b/gdb/ada-lang.h
@@ -149,8 +149,6 @@ struct ada_task_info
   int base_cpu;
 };
 
   int base_cpu;
 };
 

-extern void ada_ensure_varsize_limit (const struct type *type);
-

 extern int ada_get_field_index (const struct type *type,
                                const char *field_name,
                                int maybe_missing);
 extern int ada_get_field_index (const struct type *type,
                                const char *field_name,
                                int maybe_missing);

diff --git a/gdb/ada-valprint.c b/gdb/ada-valprint.c
index 979487f515e2bc54478df76dd4af12bc8b528f79..e725cd3276ef3495e8fee55ca0763f1d9fb6e73f 100644 (file)
--- a/gdb/ada-valprint.c
+++ b/gdb/ada-valprint.c
@@ -970,12 +970,6 @@ ada_val_print_ref (struct type *type, const gdb_byte *valaddr,
   if (ada_is_tagged_type (value_type (deref_val), 1))
     deref_val = ada_tag_value_at_base_address (deref_val);
 
   if (ada_is_tagged_type (value_type (deref_val), 1))
     deref_val = ada_tag_value_at_base_address (deref_val);
 

-  /* Make sure that the object does not have an unreasonable size
-     before trying to print it.  This can happen for instance with
-     references to dynamic objects whose contents is uninitialized
-     (Eg: an array whose bounds are not set yet).  */
-  ada_ensure_varsize_limit (value_type (deref_val));
-

   if (value_lazy (deref_val))
     value_fetch_lazy (deref_val);
 
   if (value_lazy (deref_val))
     value_fetch_lazy (deref_val);
 

diff --git a/gdb/testsuite/gdb.ada/varsize_limit.exp b/gdb/testsuite/gdb.ada/varsize_limit.exp
index aca926a79ab92a84c6d3d9de271d77312675be6b..7cba87ce41b99407b3fe4b453125abe903bc265d 100644 (file)
--- a/gdb/testsuite/gdb.ada/varsize_limit.exp
+++ b/gdb/testsuite/gdb.ada/varsize_limit.exp
@@ -31,10 +31,13 @@ if ![runto "vsizelim.adb:$bp_location" ] then {
   return
 }
 
   return
 }
 

-gdb_test_no_output "set varsize-limit 16"
+gdb_test "set varsize-limit 16" \
+    "Warning: command 'set varsize-limit' is deprecated.\r\nUse 'set max-value-size'."

 
 gdb_test "print small" " = \"1234567890\""
 
 
 gdb_test "print small" " = \"1234567890\""
 

-gdb_test "print larger" "object size is larger than varsize-limit.*"
+gdb_test "print larger" "more than max-value-size.*"

 
 

-gdb_test "print name.all" "object size is larger than varsize-limit.*"
+gdb_test "print name.all" "more than max-value-size.*"
+
+gdb_test "print ba.data(5)" " = 5" "print array element"

diff --git a/gdb/testsuite/gdb.ada/varsize_limit/vsizelim.adb b/gdb/testsuite/gdb.ada/varsize_limit/vsizelim.adb
index 3b19e722eb23621f363772b48f5bd04c4f551054..8bf367cda0f8f833b1fa7bd2ebe2d325b4728832 100644 (file)
--- a/gdb/testsuite/gdb.ada/varsize_limit/vsizelim.adb
+++ b/gdb/testsuite/gdb.ada/varsize_limit/vsizelim.adb
@@ -30,8 +30,20 @@ procedure VsizeLim is
    Name_Str : String_Ptr := new String'(Larger);
    Name : Big_String_Ptr := To_Ptr (Name_Str.all'Address);
 
    Name_Str : String_Ptr := new String'(Larger);
    Name : Big_String_Ptr := To_Ptr (Name_Str.all'Address);
 

+   type Table is array (Positive range <>) of Integer;
+   type Object (N : Integer) is record
+       Data : Table (1 .. N);
+   end record;
+
+   BA : Object := (N => 1_000_000, Data => (others => 0));
+

 begin
 begin

+   for I in 1 .. 10 loop
+      BA.Data(I) := I;
+   end loop;
+

    Do_Nothing (Small'Address); -- STOP
    Do_Nothing (Larger'Address);
    Do_Nothing (Name'Address);
    Do_Nothing (Small'Address); -- STOP
    Do_Nothing (Larger'Address);
    Do_Nothing (Name'Address);

+   Do_Nothing (BA'Address);

 end VsizeLim;
 end VsizeLim;

diff --git a/gdb/value.c b/gdb/value.c
index 19d81fd6e357ab669edb25226873bc42f4529a6c..bb2adae0a51b1e68c7ea903df7228ffe09f2d079 100644 (file)
--- a/gdb/value.c
+++ b/gdb/value.c
@@ -4326,6 +4326,16 @@ prevents future values, larger than this size, from being allocated."),
                            set_max_value_size,
                            show_max_value_size,
                            &setlist, &showlist);
                            set_max_value_size,
                            show_max_value_size,
                            &setlist, &showlist);

+  set_show_commands vsize_limit
+    = add_setshow_zuinteger_unlimited_cmd ("varsize-limit", class_support,
+                                          &max_value_size, _("\
+Set the maximum number of bytes allowed in a variable-size object."), _("\
+Show the maximum number of bytes allowed in a variable-size object."), _("\
+Attempts to access an object whose size is not a compile-time constant\n\
+and exceeds this limit will cause an error."),
+                                          NULL, NULL, &setlist, &showlist);
+  deprecate_cmd (vsize_limit.set, "set max-value-size");
+

 #if GDB_SELF_TEST
   selftests::register_test ("ranges_contain", selftests::test_ranges_contain);
   selftests::register_test ("insert_into_bit_range_vector",
 #if GDB_SELF_TEST
   selftests::register_test ("ranges_contain", selftests::test_ranges_contain);
   selftests::register_test ("insert_into_bit_range_vector",