diff --git a/gdb/NEWS b/gdb/NEWS
index e0fb006909e..7ca1f842cb1 100644
--- 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.
 
+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
diff --git a/gdb/ada-lang.c b/gdb/ada-lang.c
index 3b7c10f8e6c..6a19ad9d01c 100644
--- a/gdb/ada-lang.c
+++ b/gdb/ada-lang.c
@@ -247,9 +247,6 @@ struct ada_symbol_cache
   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!@#%^&*()+=|~`}{[]\";:?/,-";
@@ -524,10 +521,6 @@ coerce_unspec_val_to_type (struct value *val, struct type *type)
     {
       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)
@@ -589,17 +582,6 @@ lim_warning (const char *format, ...)
   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)
@@ -1898,7 +1880,6 @@ ada_coerce_to_simple_array (struct value *arr)
 
       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)))
@@ -7539,12 +7520,6 @@ ada_template_to_fixed_record_type_1 (struct type *type,
 
 	  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
@@ -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);
-	  /* 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 ());
@@ -7713,8 +7680,6 @@ ada_template_to_fixed_record_type_1 (struct type *type,
     }
 
   value_free_to_mark (mark);
-  if (TYPE_LENGTH (rtype) > varsize_limit)
-    error (_("record type with dynamic size is larger than varsize-limit"));
   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);
 	}
-      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
@@ -10584,7 +10547,6 @@ ada_unop_ind_operation::evaluate (struct type *expect_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)
@@ -10619,11 +10581,6 @@ ada_unop_ind_operation::evaluate (struct type *expect_type,
 			      (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);
@@ -13593,15 +13550,6 @@ exception should cause a stop."),
 		     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\
diff --git a/gdb/ada-lang.h b/gdb/ada-lang.h
index a89ed29119a..0f52ba70649 100644
--- a/gdb/ada-lang.h
+++ b/gdb/ada-lang.h
@@ -149,8 +149,6 @@ struct ada_task_info
   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);
diff --git a/gdb/ada-valprint.c b/gdb/ada-valprint.c
index 979487f515e..e725cd3276e 100644
--- 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);
 
-  /* 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);
 
diff --git a/gdb/testsuite/gdb.ada/varsize_limit.exp b/gdb/testsuite/gdb.ada/varsize_limit.exp
index aca926a79ab..7cba87ce41b 100644
--- 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
 }
 
-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 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 3b19e722eb2..8bf367cda0f 100644
--- 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);
 
+   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
+   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 (BA'Address);
 end VsizeLim;
diff --git a/gdb/value.c b/gdb/value.c
index 19d81fd6e35..bb2adae0a51 100644
--- 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_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",