gdb/linux-tdep.c: Add Perms to the 'info proc mappings' output

[binutils-gdb.git] / gdb / valprint.c

diff --git a/gdb/valprint.c b/gdb/valprint.c
index d5490898b9be706b79fd536ae21af8c9df2f8c50..d6ec64845f4be9bd3eb10664ac86cb623d5b3b42 100644 (file)
--- a/gdb/valprint.c
+++ b/gdb/valprint.c
@@ -1,6 +1,6 @@
 /* Print values for GDB, the GNU debugger.
 
 /* Print values for GDB, the GNU debugger.
 

-   Copyright (C) 1986-2020 Free Software Foundation, Inc.
+   Copyright (C) 1986-2022 Free Software Foundation, Inc.

 
    This file is part of GDB.
 
 
    This file is part of GDB.
 


@@ -30,7 +30,7 @@
 #include "target-float.h"
 #include "extension.h"
 #include "ada-lang.h"
 #include "target-float.h"
 #include "extension.h"
 #include "ada-lang.h"

-#include "gdb_obstack.h"
+#include "gdbsupport/gdb_obstack.h"

 #include "charset.h"
 #include "typeprint.h"
 #include <ctype.h>
 #include "charset.h"
 #include "typeprint.h"
 #include <ctype.h>


@@ -40,6 +40,11 @@
 #include "gdbarch.h"
 #include "cli/cli-style.h"
 #include "count-one-bits.h"
 #include "gdbarch.h"
 #include "cli/cli-style.h"
 #include "count-one-bits.h"

+#include "c-lang.h"
+#include "cp-abi.h"
+#include "inferior.h"
+#include "gdbsupport/selftest.h"
+#include "selftest-arch.h"

 
 /* Maximum number of wchars returned from wchar_iterate.  */
 #define MAX_WCHARS 4
 
 /* Maximum number of wchars returned from wchar_iterate.  */
 #define MAX_WCHARS 4


@@ -108,6 +113,7 @@ struct value_print_options user_print_options =
   10,                          /* repeat_count_threshold */
   0,                           /* output_format */
   0,                           /* format */
   10,                          /* repeat_count_threshold */
   0,                           /* output_format */
   0,                           /* format */

+  1,                           /* memory_tag_violations */

   0,                           /* stop_print_at_null */
   0,                           /* print_array_indexes */
   0,                           /* deref_ref */
   0,                           /* stop_print_at_null */
   0,                           /* print_array_indexes */
   0,                           /* deref_ref */


@@ -184,7 +190,7 @@ show_output_radix (struct ui_file *file, int from_tty,
 
 static void
 show_print_array_indexes (struct ui_file *file, int from_tty,
 
 static void
 show_print_array_indexes (struct ui_file *file, int from_tty,

-                         struct cmd_list_element *c, const char *value)
+                         struct cmd_list_element *c, const char *value)

 {
   fprintf_filtered (file, _("Printing of array indexes is %s.\n"), value);
 }
 {
   fprintf_filtered (file, _("Printing of array indexes is %s.\n"), value);
 }


@@ -201,6 +207,17 @@ show_repeat_count_threshold (struct ui_file *file, int from_tty,
                    value);
 }
 
                    value);
 }
 

+/* If nonzero, prints memory tag violations for pointers.  */
+
+static void
+show_memory_tag_violations (struct ui_file *file, int from_tty,
+                           struct cmd_list_element *c, const char *value)
+{
+  fprintf_filtered (file,
+                   _("Printing of memory tag violations is %s.\n"),
+                   value);
+}
+

 /* If nonzero, stops printing of char arrays at first null.  */
 
 static void
 /* If nonzero, stops printing of char arrays at first null.  */
 
 static void


@@ -298,10 +315,10 @@ val_print_scalar_or_string_type_p (struct type *type,
                                   const struct language_defn *language)
 {
   return (val_print_scalar_type_p (type)
                                   const struct language_defn *language)
 {
   return (val_print_scalar_type_p (type)

-         || language->la_is_string_type_p (type));
+         || language->is_string_type_p (type));

 }
 
 }
 

-/* See its definition in value.h.  */
+/* See valprint.h.  */

 
 int
 valprint_check_validity (struct ui_file *stream,
 
 int
 valprint_check_validity (struct ui_file *stream,


@@ -406,7 +423,7 @@ print_unpacked_pointer (struct type *type, struct type *elttype,
                        CORE_ADDR address, struct ui_file *stream,
                        const struct value_print_options *options)
 {
                        CORE_ADDR address, struct ui_file *stream,
                        const struct value_print_options *options)
 {

-  struct gdbarch *gdbarch = get_type_arch (type);
+  struct gdbarch *gdbarch = type->arch ();

 
   if (elttype->code () == TYPE_CODE_FUNC)
     {
 
   if (elttype->code () == TYPE_CODE_FUNC)
     {


@@ -467,7 +484,7 @@ generic_value_print_ptr (struct value *val, struct ui_file *stream,
     {
       struct type *type = check_typedef (value_type (val));
       struct type *elttype = check_typedef (TYPE_TARGET_TYPE (type));
     {
       struct type *type = check_typedef (value_type (val));
       struct type *elttype = check_typedef (TYPE_TARGET_TYPE (type));

-      const gdb_byte *valaddr = value_contents_for_printing (val);
+      const gdb_byte *valaddr = value_contents_for_printing (val).data ();

       CORE_ADDR addr = unpack_pointer (type, valaddr);
 
       print_unpacked_pointer (type, elttype, addr, stream, options);
       CORE_ADDR addr = unpack_pointer (type, valaddr);
 
       print_unpacked_pointer (type, elttype, addr, stream, options);


@@ -481,7 +498,7 @@ static void
 print_ref_address (struct type *type, const gdb_byte *address_buffer,
                  int embedded_offset, struct ui_file *stream)
 {
 print_ref_address (struct type *type, const gdb_byte *address_buffer,
                  int embedded_offset, struct ui_file *stream)
 {

-  struct gdbarch *gdbarch = get_type_arch (type);
+  struct gdbarch *gdbarch = type->arch ();

 
   if (address_buffer != NULL)
     {
 
   if (address_buffer != NULL)
     {


@@ -503,7 +520,7 @@ get_value_addr_contents (struct value *deref_val)
   gdb_assert (deref_val != NULL);
 
   if (value_lval_const (deref_val) == lval_memory)
   gdb_assert (deref_val != NULL);
 
   if (value_lval_const (deref_val) == lval_memory)

-    return value_contents_for_printing_const (value_addr (deref_val));
+    return value_contents_for_printing_const (value_addr (deref_val)).data ();

   else
     {
       /* We have a non-addressable value, such as a DW_AT_const_value.  */
   else
     {
       /* We have a non-addressable value, such as a DW_AT_const_value.  */


@@ -528,7 +545,7 @@ generic_val_print_ref (struct type *type,
   const int must_coerce_ref = ((options->addressprint && value_is_synthetic)
                               || options->deref_ref);
   const int type_is_defined = elttype->code () != TYPE_CODE_UNDEF;
   const int must_coerce_ref = ((options->addressprint && value_is_synthetic)
                               || options->deref_ref);
   const int type_is_defined = elttype->code () != TYPE_CODE_UNDEF;

-  const gdb_byte *valaddr = value_contents_for_printing (original_value);
+  const gdb_byte *valaddr = value_contents_for_printing (original_value).data ();

 
   if (must_coerce_ref && type_is_defined)
     {
 
   if (must_coerce_ref && type_is_defined)
     {


@@ -591,17 +608,17 @@ generic_val_print_enum_1 (struct type *type, LONGEST val,
   for (i = 0; i < len; i++)
     {
       QUIT;
   for (i = 0; i < len; i++)
     {
       QUIT;

-      if (val == TYPE_FIELD_ENUMVAL (type, i))
+      if (val == type->field (i).loc_enumval ())

        {
          break;
        }
     }
   if (i < len)
     {
        {
          break;
        }
     }
   if (i < len)
     {

-      fputs_styled (TYPE_FIELD_NAME (type, i), variable_name_style.style (),
+      fputs_styled (type->field (i).name (), variable_name_style.style (),

                    stream);
     }
                    stream);
     }

-  else if (TYPE_FLAG_ENUM (type))
+  else if (type->is_flag_enum ())

     {
       int first = 1;
 
     {
       int first = 1;
 


@@ -613,7 +630,7 @@ generic_val_print_enum_1 (struct type *type, LONGEST val,
        {
          QUIT;
 
        {
          QUIT;
 

-         ULONGEST enumval = TYPE_FIELD_ENUMVAL (type, i);
+         ULONGEST enumval = type->field (i).loc_enumval ();

          int nbits = count_one_bits_ll (enumval);
 
          gdb_assert (nbits == 0 || nbits == 1);
          int nbits = count_one_bits_ll (enumval);
 
          gdb_assert (nbits == 0 || nbits == 1);


@@ -628,8 +645,8 @@ generic_val_print_enum_1 (struct type *type, LONGEST val,
              else
                fputs_filtered (" | ", stream);
 
              else
                fputs_filtered (" | ", stream);
 

-             val &= ~TYPE_FIELD_ENUMVAL (type, i);
-             fputs_styled (TYPE_FIELD_NAME (type, i),
+             val &= ~type->field (i).loc_enumval ();
+             fputs_styled (type->field (i).name (),

                            variable_name_style.style (), stream);
            }
        }
                            variable_name_style.style (), stream);
            }
        }


@@ -671,12 +688,12 @@ generic_val_print_enum (struct type *type,
                        const struct value_print_options *options)
 {
   LONGEST val;
                        const struct value_print_options *options)
 {
   LONGEST val;

-  struct gdbarch *gdbarch = get_type_arch (type);
+  struct gdbarch *gdbarch = type->arch ();

   int unit_size = gdbarch_addressable_memory_unit_size (gdbarch);
 
   gdb_assert (!options->format);
 
   int unit_size = gdbarch_addressable_memory_unit_size (gdbarch);
 
   gdb_assert (!options->format);
 

-  const gdb_byte *valaddr = value_contents_for_printing (original_value);
+  const gdb_byte *valaddr = value_contents_for_printing (original_value).data ();

 
   val = unpack_long (type, valaddr + embedded_offset * unit_size);
 
 
   val = unpack_long (type, valaddr + embedded_offset * unit_size);
 


@@ -692,7 +709,7 @@ generic_val_print_func (struct type *type,
                        struct value *original_value,
                        const struct value_print_options *options)
 {
                        struct value *original_value,
                        const struct value_print_options *options)
 {

-  struct gdbarch *gdbarch = get_type_arch (type);
+  struct gdbarch *gdbarch = type->arch ();

 
   gdb_assert (!options->format);
 
 
   gdb_assert (!options->format);
 


@@ -723,7 +740,7 @@ generic_value_print_bool
     }
   else
     {
     }
   else
     {

-      const gdb_byte *valaddr = value_contents_for_printing (value);
+      const gdb_byte *valaddr = value_contents_for_printing (value).data ();

       struct type *type = check_typedef (value_type (value));
       LONGEST val = unpack_long (type, valaddr);
       if (val == 0)
       struct type *type = check_typedef (value_type (value));
       LONGEST val = unpack_long (type, valaddr);
       if (val == 0)


@@ -766,15 +783,15 @@ generic_value_print_char (struct value *value, struct ui_file *stream,
     {
       struct type *unresolved_type = value_type (value);
       struct type *type = check_typedef (unresolved_type);
     {
       struct type *unresolved_type = value_type (value);
       struct type *type = check_typedef (unresolved_type);

-      const gdb_byte *valaddr = value_contents_for_printing (value);
+      const gdb_byte *valaddr = value_contents_for_printing (value).data ();

 
       LONGEST val = unpack_long (type, valaddr);
 
       LONGEST val = unpack_long (type, valaddr);

-      if (TYPE_UNSIGNED (type))
+      if (type->is_unsigned ())

        fprintf_filtered (stream, "%u", (unsigned int) val);
       else
        fprintf_filtered (stream, "%d", (int) val);
       fputs_filtered (" ", stream);
        fprintf_filtered (stream, "%u", (unsigned int) val);
       else
        fprintf_filtered (stream, "%d", (int) val);
       fputs_filtered (" ", stream);

-      LA_PRINT_CHAR (val, unresolved_type, stream);
+      current_language->printchar (val, unresolved_type, stream);

     }
 }
 
     }
 }
 


@@ -787,11 +804,36 @@ generic_val_print_float (struct type *type, struct ui_file *stream,
 {
   gdb_assert (!options->format);
 
 {
   gdb_assert (!options->format);
 

-  const gdb_byte *valaddr = value_contents_for_printing (original_value);
+  const gdb_byte *valaddr = value_contents_for_printing (original_value).data ();

 
   print_floating (valaddr, type, stream);
 }
 
 
   print_floating (valaddr, type, stream);
 }
 

+/* generic_val_print helper for TYPE_CODE_FIXED_POINT.  */
+
+static void
+generic_val_print_fixed_point (struct value *val, struct ui_file *stream,
+                              const struct value_print_options *options)
+{
+  if (options->format)
+    value_print_scalar_formatted (val, options, 0, stream);
+  else
+    {
+      struct type *type = value_type (val);
+
+      const gdb_byte *valaddr = value_contents_for_printing (val).data ();
+      gdb_mpf f;
+
+      f.read_fixed_point (gdb::make_array_view (valaddr, TYPE_LENGTH (type)),
+                         type_byte_order (type), type->is_unsigned (),
+                         type->fixed_point_scaling_factor ());
+
+      const char *fmt = TYPE_LENGTH (type) < 4 ? "%.11Fg" : "%.17Fg";
+      std::string str = gmp_string_printf (fmt, f.val);
+      fprintf_filtered (stream, "%s", str.c_str ());
+    }
+}
+

 /* generic_value_print helper for TYPE_CODE_COMPLEX.  */
 
 static void
 /* generic_value_print helper for TYPE_CODE_COMPLEX.  */
 
 static void


@@ -811,6 +853,27 @@ generic_value_print_complex (struct value *val, struct ui_file *stream,
   fprintf_filtered (stream, "%s", decorations->complex_suffix);
 }
 
   fprintf_filtered (stream, "%s", decorations->complex_suffix);
 }
 

+/* generic_value_print helper for TYPE_CODE_MEMBERPTR.  */
+
+static void
+generic_value_print_memberptr
+  (struct value *val, struct ui_file *stream,
+   int recurse,
+   const struct value_print_options *options,
+   const struct generic_val_print_decorations *decorations)
+{
+  if (!options->format)
+    {
+      /* Member pointers are essentially specific to C++, and so if we
+        encounter one, we should print it according to C++ rules.  */
+      struct type *type = check_typedef (value_type (val));
+      const gdb_byte *valaddr = value_contents_for_printing (val).data ();
+      cp_print_class_member (valaddr, type, stream, "&");
+    }
+  else
+    generic_value_print (val, stream, recurse, options, decorations);
+}
+

 /* See valprint.h.  */
 
 void
 /* See valprint.h.  */
 
 void


@@ -821,6 +884,10 @@ generic_value_print (struct value *val, struct ui_file *stream, int recurse,
   struct type *type = value_type (val);
 
   type = check_typedef (type);
   struct type *type = value_type (val);
 
   type = check_typedef (type);

+
+  if (is_fixed_point_type (type))
+    type = type->fixed_point_type_base_type ();
+

   switch (type->code ())
     {
     case TYPE_CODE_ARRAY:
   switch (type->code ())
     {
     case TYPE_CODE_ARRAY:


@@ -828,7 +895,8 @@ generic_value_print (struct value *val, struct ui_file *stream, int recurse,
       break;
 
     case TYPE_CODE_MEMBERPTR:
       break;
 
     case TYPE_CODE_MEMBERPTR:

-      value_print_scalar_formatted (val, options, 0, stream);
+      generic_value_print_memberptr (val, stream, recurse, options,
+                                    decorations);

       break;
 
     case TYPE_CODE_PTR:
       break;
 
     case TYPE_CODE_PTR:


@@ -869,16 +937,6 @@ generic_value_print (struct value *val, struct ui_file *stream, int recurse,
       break;
 
     case TYPE_CODE_RANGE:
       break;
 
     case TYPE_CODE_RANGE:

-      /* FIXME: create_static_range_type does not set the unsigned bit in a
-         range type (I think it probably should copy it from the
-         target type), so we won't print values which are too large to
-         fit in a signed integer correctly.  */
-      /* FIXME: Doesn't handle ranges of enums correctly.  (Can't just
-         print with the target type, though, because the size of our
-         type and the target type might differ).  */
-
-      /* FALLTHROUGH */
-

     case TYPE_CODE_INT:
       generic_value_print_int (val, stream, options);
       break;
     case TYPE_CODE_INT:
       generic_value_print_int (val, stream, options);
       break;


@@ -895,6 +953,10 @@ generic_value_print (struct value *val, struct ui_file *stream, int recurse,
        generic_val_print_float (type, stream, val, options);
       break;
 
        generic_val_print_float (type, stream, val, options);
       break;
 

+    case TYPE_CODE_FIXED_POINT:
+      generic_val_print_fixed_point (val, stream, options);
+      break;
+

     case TYPE_CODE_VOID:
       fputs_filtered (decorations->void_name, stream);
       break;
     case TYPE_CODE_VOID:
       fputs_filtered (decorations->void_name, stream);
       break;


@@ -905,8 +967,8 @@ generic_value_print (struct value *val, struct ui_file *stream, int recurse,
 
     case TYPE_CODE_UNDEF:
       /* This happens (without TYPE_STUB set) on systems which don't use
 
     case TYPE_CODE_UNDEF:
       /* This happens (without TYPE_STUB set) on systems which don't use

-         dbx xrefs (NO_DBX_XREFS in gcc) if a file has a "struct foo *bar"
-         and no complete type for struct foo in that file.  */
+        dbx xrefs (NO_DBX_XREFS in gcc) if a file has a "struct foo *bar"
+        and no complete type for struct foo in that file.  */

       fprintf_styled (stream, metadata_style.style (), _("<incomplete type>"));
       break;
 
       fprintf_styled (stream, metadata_style.style (), _("<incomplete type>"));
       break;
 


@@ -914,25 +976,40 @@ generic_value_print (struct value *val, struct ui_file *stream, int recurse,
       generic_value_print_complex (val, stream, options, decorations);
       break;
 
       generic_value_print_complex (val, stream, options, decorations);
       break;
 

+    case TYPE_CODE_METHODPTR:
+      cplus_print_method_ptr (value_contents_for_printing (val).data (), type,
+                             stream);
+      break;
+

     case TYPE_CODE_UNION:
     case TYPE_CODE_STRUCT:
     case TYPE_CODE_UNION:
     case TYPE_CODE_STRUCT:

-    case TYPE_CODE_METHODPTR:

     default:
       error (_("Unhandled type code %d in symbol table."),
             type->code ());
     }
 }
 
     default:
       error (_("Unhandled type code %d in symbol table."),
             type->code ());
     }
 }
 

-/* Helper function for val_print and common_val_print that does the
-   work.  Arguments are as to val_print, but FULL_VALUE, if given, is
-   the value to be printed.  */
+/* Print using the given LANGUAGE the value VAL onto stream STREAM according
+   to OPTIONS.

 
 

-static void
-do_val_print (struct value *value, struct ui_file *stream, int recurse,
-             const struct value_print_options *options,
-             const struct language_defn *language)
+   This is a preferable interface to val_print, above, because it uses
+   GDB's value mechanism.  */
+
+void
+common_val_print (struct value *value, struct ui_file *stream, int recurse,
+                 const struct value_print_options *options,
+                 const struct language_defn *language)

 {
 {

-  int ret = 0;
+  if (language->la_language == language_ada)
+    /* The value might have a dynamic type, which would cause trouble
+       below when trying to extract the value contents (since the value
+       size is determined from the type size which is unknown).  So
+       get a fixed representation of our value.  */
+    value = ada_to_fixed_value (value);
+
+  if (value_lazy (value))
+    value_fetch_lazy (value);
+

   struct value_print_options local_opts = *options;
   struct type *type = value_type (value);
   struct type *real_type = check_typedef (type);
   struct value_print_options local_opts = *options;
   struct type *type = value_type (value);
   struct type *real_type = check_typedef (type);


@@ -947,7 +1024,7 @@ do_val_print (struct value *value, struct ui_file *stream, int recurse,
      only a stub and we can't find and substitute its complete type, then
      print appropriate string and return.  */
 
      only a stub and we can't find and substitute its complete type, then
      print appropriate string and return.  */
 

-  if (TYPE_STUB (real_type))
+  if (real_type->is_stub ())

     {
       fprintf_styled (stream, metadata_style.style (), _("<incomplete type>"));
       return;
     {
       fprintf_styled (stream, metadata_style.style (), _("<incomplete type>"));
       return;


@@ -958,9 +1035,8 @@ do_val_print (struct value *value, struct ui_file *stream, int recurse,
 
   if (!options->raw)
     {
 
   if (!options->raw)
     {

-      ret = apply_ext_lang_val_pretty_printer (value, stream, recurse, options,
-                                              language);
-      if (ret)
+      if (apply_ext_lang_val_pretty_printer (value, stream, recurse, options,
+                                            language))

        return;
     }
 
        return;
     }
 


@@ -979,12 +1055,12 @@ do_val_print (struct value *value, struct ui_file *stream, int recurse,
 
   try
     {
 
   try
     {

-      language->la_value_print_inner (value, stream, recurse, &local_opts);
+      language->value_print_inner (value, stream, recurse, &local_opts);

     }
   catch (const gdb_exception_error &except)
     {
       fprintf_styled (stream, metadata_style.style (),
     }
   catch (const gdb_exception_error &except)
     {
       fprintf_styled (stream, metadata_style.style (),

-                     _("<error reading variable>"));
+                     _("<error reading variable: %s>"), except.what ());

     }
 }
 
     }
 }
 


@@ -997,8 +1073,8 @@ val_print_check_max_depth (struct ui_file *stream, int recurse,
 {
   if (options->max_depth > -1 && recurse >= options->max_depth)
     {
 {
   if (options->max_depth > -1 && recurse >= options->max_depth)
     {

-      gdb_assert (language->la_struct_too_deep_ellipsis != NULL);
-      fputs_filtered (language->la_struct_too_deep_ellipsis, stream);
+      gdb_assert (language->struct_too_deep_ellipsis () != NULL);
+      fputs_filtered (language->struct_too_deep_ellipsis (), stream);

       return true;
     }
 
       return true;
     }
 


@@ -1061,30 +1137,6 @@ value_check_printable (struct value *val, struct ui_file *stream,
   return 1;
 }
 
   return 1;
 }
 

-/* Print using the given LANGUAGE the value VAL onto stream STREAM according
-   to OPTIONS.
-
-   This is a preferable interface to val_print, above, because it uses
-   GDB's value mechanism.  */
-
-void
-common_val_print (struct value *val, struct ui_file *stream, int recurse,
-                 const struct value_print_options *options,
-                 const struct language_defn *language)
-{
-  if (language->la_language == language_ada)
-    /* The value might have a dynamic type, which would cause trouble
-       below when trying to extract the value contents (since the value
-       size is determined from the type size which is unknown).  So
-       get a fixed representation of our value.  */
-    val = ada_to_fixed_value (val);
-
-  if (value_lazy (val))
-    value_fetch_lazy (val);
-
-  do_val_print (val, stream, recurse, options, language);
-}
-

 /* See valprint.h.  */
 
 void
 /* See valprint.h.  */
 
 void


@@ -1120,24 +1172,24 @@ value_print (struct value *val, struct ui_file *stream,
        return;
     }
 
        return;
     }
 

-  LA_VALUE_PRINT (val, stream, options);
+  current_language->value_print (val, stream, options);

 }
 
 static void
 val_print_type_code_flags (struct type *type, struct value *original_value,
                           int embedded_offset, struct ui_file *stream)
 {
 }
 
 static void
 val_print_type_code_flags (struct type *type, struct value *original_value,
                           int embedded_offset, struct ui_file *stream)
 {

-  const gdb_byte *valaddr = (value_contents_for_printing (original_value)
+  const gdb_byte *valaddr = (value_contents_for_printing (original_value).data ()

                             + embedded_offset);
   ULONGEST val = unpack_long (type, valaddr);
   int field, nfields = type->num_fields ();
                             + embedded_offset);
   ULONGEST val = unpack_long (type, valaddr);
   int field, nfields = type->num_fields ();

-  struct gdbarch *gdbarch = get_type_arch (type);
+  struct gdbarch *gdbarch = type->arch ();

   struct type *bool_type = builtin_type (gdbarch)->builtin_bool;
 
   fputs_filtered ("[", stream);
   for (field = 0; field < nfields; field++)
     {
   struct type *bool_type = builtin_type (gdbarch)->builtin_bool;
 
   fputs_filtered ("[", stream);
   for (field = 0; field < nfields; field++)
     {

-      if (TYPE_FIELD_NAME (type, field)[0] != '\0')
+      if (type->field (field).name ()[0] != '\0')

        {
          struct type *field_type = type->field (field).type ();
 
        {
          struct type *field_type = type->field (field).type ();
 


@@ -1148,23 +1200,22 @@ val_print_type_code_flags (struct type *type, struct value *original_value,
                 int.  */
              && TYPE_FIELD_BITSIZE (type, field) == 1)
            {
                 int.  */
              && TYPE_FIELD_BITSIZE (type, field) == 1)
            {

-             if (val & ((ULONGEST)1 << TYPE_FIELD_BITPOS (type, field)))
+             if (val & ((ULONGEST)1 << type->field (field).loc_bitpos ()))

                fprintf_filtered
                  (stream, " %ps",
                   styled_string (variable_name_style.style (),
                fprintf_filtered
                  (stream, " %ps",
                   styled_string (variable_name_style.style (),

-                                 TYPE_FIELD_NAME (type, field)));
+                                 type->field (field).name ()));

            }
          else
            {
              unsigned field_len = TYPE_FIELD_BITSIZE (type, field);
            }
          else
            {
              unsigned field_len = TYPE_FIELD_BITSIZE (type, field);

-             ULONGEST field_val
-               = val >> (TYPE_FIELD_BITPOS (type, field) - field_len + 1);
+             ULONGEST field_val = val >> type->field (field).loc_bitpos ();

 
              if (field_len < sizeof (ULONGEST) * TARGET_CHAR_BIT)
                field_val &= ((ULONGEST) 1 << field_len) - 1;
              fprintf_filtered (stream, " %ps=",
                                styled_string (variable_name_style.style (),
 
              if (field_len < sizeof (ULONGEST) * TARGET_CHAR_BIT)
                field_val &= ((ULONGEST) 1 << field_len) - 1;
              fprintf_filtered (stream, " %ps=",
                                styled_string (variable_name_style.style (),

-                                              TYPE_FIELD_NAME (type, field)));
+                                              type->field (field).name ()));

              if (field_type->code () == TYPE_CODE_ENUM)
                generic_val_print_enum_1 (field_type, field_val, stream);
              else
              if (field_type->code () == TYPE_CODE_ENUM)
                generic_val_print_enum_1 (field_type, field_val, stream);
              else


@@ -1202,7 +1253,7 @@ value_print_scalar_formatted (struct value *val,
   /* value_contents_for_printing fetches all VAL's contents.  They are
      needed to check whether VAL is optimized-out or unavailable
      below.  */
   /* value_contents_for_printing fetches all VAL's contents.  They are
      needed to check whether VAL is optimized-out or unavailable
      below.  */

-  const gdb_byte *valaddr = value_contents_for_printing (val);
+  const gdb_byte *valaddr = value_contents_for_printing (val).data ();

 
   /* A scalar object that does not have all bits available can't be
      printed, because all bits contribute to its representation.  */
 
   /* A scalar object that does not have all bits available can't be
      printed, because all bits contribute to its representation.  */


@@ -1659,7 +1710,7 @@ print_decimal_chars (struct ui_file *stream, const gdb_byte *valaddr,
          /* Take low nibble and bump our pointer "p".  */
 
          digits[0] += LOW_NIBBLE (*p);
          /* Take low nibble and bump our pointer "p".  */
 
          digits[0] += LOW_NIBBLE (*p);

-          if (byte_order == BFD_ENDIAN_BIG)
+         if (byte_order == BFD_ENDIAN_BIG)

            p++;
          else
            p--;
            p++;
          else
            p--;


@@ -1776,43 +1827,6 @@ print_hex_chars (struct ui_file *stream, const gdb_byte *valaddr,
     }
 }
 
     }
 }
 

-/* VALADDR points to a char integer of LEN bytes.
-   Print it out in appropriate language form on stream.
-   Omit any leading zero chars.  */
-
-void
-print_char_chars (struct ui_file *stream, struct type *type,
-                 const gdb_byte *valaddr,
-                 unsigned len, enum bfd_endian byte_order)
-{
-  const gdb_byte *p;
-
-  if (byte_order == BFD_ENDIAN_BIG)
-    {
-      p = valaddr;
-      while (p < valaddr + len - 1 && *p == 0)
-       ++p;
-
-      while (p < valaddr + len)
-       {
-         LA_EMIT_CHAR (*p, type, stream, '\'');
-         ++p;
-       }
-    }
-  else
-    {
-      p = valaddr + len - 1;
-      while (p > valaddr && *p == 0)
-       --p;
-
-      while (p >= valaddr)
-       {
-         LA_EMIT_CHAR (*p, type, stream, '\'');
-         --p;
-       }
-    }
-}
-

 /* Print function pointer with inferior address ADDRESS onto stdio
    stream STREAM.  */
 
 /* Print function pointer with inferior address ADDRESS onto stdio
    stream STREAM.  */
 


@@ -1822,9 +1836,8 @@ print_function_pointer_address (const struct value_print_options *options,
                                CORE_ADDR address,
                                struct ui_file *stream)
 {
                                CORE_ADDR address,
                                struct ui_file *stream)
 {

-  CORE_ADDR func_addr
-    = gdbarch_convert_from_func_ptr_addr (gdbarch, address,
-                                         current_top_target ());
+  CORE_ADDR func_addr = gdbarch_convert_from_func_ptr_addr
+    (gdbarch, address, current_inferior ()->top_target ());

 
   /* If the function pointer is represented by a description, print
      the address of the description.  */
 
   /* If the function pointer is represented by a description, print
      the address of the description.  */


@@ -1843,13 +1856,13 @@ print_function_pointer_address (const struct value_print_options *options,
     
 void  
 maybe_print_array_index (struct type *index_type, LONGEST index,
     
 void  
 maybe_print_array_index (struct type *index_type, LONGEST index,

-                         struct ui_file *stream,
+                        struct ui_file *stream,

                         const struct value_print_options *options)
 {
   if (!options->print_array_indexes)
     return; 
                         const struct value_print_options *options)
 {
   if (!options->print_array_indexes)
     return; 

-    
-  LA_PRINT_ARRAY_INDEX (index_type, index, stream, options);
+
+  current_language->print_array_index (index_type, index, stream, options);

 }
 
 /* See valprint.h.  */
 }
 
 /* See valprint.h.  */


@@ -1882,10 +1895,10 @@ value_print_array_elements (struct value *val, struct ui_file *stream,
   if (get_array_bounds (type, &low_bound, &high_bound))
     {
       /* The array length should normally be HIGH_BOUND - LOW_BOUND +
   if (get_array_bounds (type, &low_bound, &high_bound))
     {
       /* The array length should normally be HIGH_BOUND - LOW_BOUND +

-         1.  But we have to be a little extra careful, because some
-         languages such as Ada allow LOW_BOUND to be greater than
-         HIGH_BOUND for empty arrays.  In that situation, the array
-         length is just zero, not negative!  */
+        1.  But we have to be a little extra careful, because some
+        languages such as Ada allow LOW_BOUND to be greater than
+        HIGH_BOUND for empty arrays.  In that situation, the array
+        length is just zero, not negative!  */

       if (low_bound > high_bound)
        len = 0;
       else
       if (low_bound > high_bound)
        len = 0;
       else


@@ -1919,9 +1932,9 @@ value_print_array_elements (struct value *val, struct ui_file *stream,
          fprintf_filtered (stream, "\n");
          print_spaces_filtered (2 + 2 * recurse, stream);
        }
          fprintf_filtered (stream, "\n");
          print_spaces_filtered (2 + 2 * recurse, stream);
        }

-      wrap_here (n_spaces (2 + 2 * recurse));
+      stream->wrap_here (2 + 2 * recurse);

       maybe_print_array_index (index_type, i + low_bound,
       maybe_print_array_index (index_type, i + low_bound,

-                               stream, options);
+                              stream, options);

 
       rep1 = i + 1;
       reps = 1;
 
       rep1 = i + 1;
       reps = 1;


@@ -2027,13 +2040,7 @@ partial_memory_read (CORE_ADDR memaddr, gdb_byte *myaddr,
 
    Unless an exception is thrown, BUFFER will always be allocated, even on
    failure.  In this case, some characters might have been read before the
 
    Unless an exception is thrown, BUFFER will always be allocated, even on
    failure.  In this case, some characters might have been read before the

-   failure happened.  Check BYTES_READ to recognize this situation.
-
-   Note: There was a FIXME asking to make this code use target_read_string,
-   but this function is more general (can read past null characters, up to
-   given LEN).  Besides, it is used much more often than target_read_string
-   so it is more tested.  Perhaps callers of target_read_string should use
-   this function instead?  */
+   failure happened.  Check BYTES_READ to recognize this situation.  */

 
 int
 read_string (CORE_ADDR addr, int len, int width, unsigned int fetchlimit,
 
 int
 read_string (CORE_ADDR addr, int len, int width, unsigned int fetchlimit,


@@ -2705,7 +2712,7 @@ val_print_string (struct type *elttype, const char *encoding,
   unsigned int fetchlimit;     /* Maximum number of chars to print.  */
   int bytes_read;
   gdb::unique_xmalloc_ptr<gdb_byte> buffer;    /* Dynamically growable fetch buffer.  */
   unsigned int fetchlimit;     /* Maximum number of chars to print.  */
   int bytes_read;
   gdb::unique_xmalloc_ptr<gdb_byte> buffer;    /* Dynamically growable fetch buffer.  */

-  struct gdbarch *gdbarch = get_type_arch (elttype);
+  struct gdbarch *gdbarch = elttype->arch ();

   enum bfd_endian byte_order = type_byte_order (elttype);
   int width = TYPE_LENGTH (elttype);
 
   enum bfd_endian byte_order = type_byte_order (elttype);
   int width = TYPE_LENGTH (elttype);
 


@@ -2739,8 +2746,8 @@ val_print_string (struct type *elttype, const char *encoding,
       gdb_byte *peekbuf;
 
       /* We didn't find a NUL terminator we were looking for.  Attempt
       gdb_byte *peekbuf;
 
       /* We didn't find a NUL terminator we were looking for.  Attempt

-         to peek at the next character.  If not successful, or it is not
-         a null byte, then force ellipsis to be printed.  */
+        to peek at the next character.  If not successful, or it is not
+        a null byte, then force ellipsis to be printed.  */

 
       peekbuf = (gdb_byte *) alloca (width);
 
 
       peekbuf = (gdb_byte *) alloca (width);
 


@@ -2751,8 +2758,8 @@ val_print_string (struct type *elttype, const char *encoding,
   else if ((len >= 0 && err != 0) || (len > bytes_read / width))
     {
       /* Getting an error when we have a requested length, or fetching less
   else if ((len >= 0 && err != 0) || (len > bytes_read / width))
     {
       /* Getting an error when we have a requested length, or fetching less

-         than the number of characters actually requested, always make us
-         print ellipsis.  */
+        than the number of characters actually requested, always make us
+        print ellipsis.  */

       force_ellipsis = 1;
     }
 
       force_ellipsis = 1;
     }
 


@@ -2760,10 +2767,9 @@ val_print_string (struct type *elttype, const char *encoding,
      But if we fetch something and then get an error, print the string
      and then the error message.  */
   if (err == 0 || bytes_read > 0)
      But if we fetch something and then get an error, print the string
      and then the error message.  */
   if (err == 0 || bytes_read > 0)

-    {
-      LA_PRINT_STRING (stream, elttype, buffer.get (), bytes_read / width,
-                      encoding, force_ellipsis, options);
-    }
+    current_language->printstr (stream, elttype, buffer.get (),
+                               bytes_read / width,
+                               encoding, force_ellipsis, options);

 
   if (err != 0)
     {
 
   if (err != 0)
     {


@@ -3015,6 +3021,17 @@ will be replaced with either '{...}' or '(...)' depending on the language.\n\
 Use \"unlimited\" to print the complete structure.")
   },
 
 Use \"unlimited\" to print the complete structure.")
   },
 

+  boolean_option_def {
+    "memory-tag-violations",
+    [] (value_print_options *opt) { return &opt->memory_tag_violations; },
+    show_memory_tag_violations, /* show_cmd_cb */
+    N_("Set printing of memory tag violations for pointers."),
+    N_("Show printing of memory tag violations for pointers."),
+    N_("Issue a warning when the printed value is a pointer\n\
+whose logical tag doesn't match the allocation tag of the memory\n\
+location it points to."),
+  },
+

   boolean_option_def {
     "null-stop",
     [] (value_print_options *opt) { return &opt->stop_print_at_null; },
   boolean_option_def {
     "null-stop",
     [] (value_print_options *opt) { return &opt->stop_print_at_null; },


@@ -3106,37 +3123,61 @@ make_value_print_options_def_group (value_print_options *opts)
   return {{value_print_option_defs}, opts};
 }
 
   return {{value_print_option_defs}, opts};
 }
 

+#if GDB_SELF_TEST
+
+/* Test printing of TYPE_CODE_FLAGS values.  */
+
+static void
+test_print_flags (gdbarch *arch)
+{
+  type *flags_type = arch_flags_type (arch, "test_type", 32);
+  type *field_type = builtin_type (arch)->builtin_uint32;
+
+  /* Value:  1010 1010
+     Fields: CCCB BAAA */
+  append_flags_type_field (flags_type, 0, 3, field_type, "A");
+  append_flags_type_field (flags_type, 3, 2, field_type, "B");
+  append_flags_type_field (flags_type, 5, 3, field_type, "C");
+
+  value *val = allocate_value (flags_type);
+  gdb_byte *contents = value_contents_writeable (val).data ();
+  store_unsigned_integer (contents, 4, gdbarch_byte_order (arch), 0xaa);
+
+  string_file out;
+  val_print_type_code_flags (flags_type, val, 0, &out);
+  SELF_CHECK (out.string () == "[ A=2 B=1 C=5 ]");
+}
+
+#endif
+

 void _initialize_valprint ();
 void
 _initialize_valprint ()
 {
 void _initialize_valprint ();
 void
 _initialize_valprint ()
 {

-  cmd_list_element *cmd;
-
-  add_basic_prefix_cmd ("print", no_class,
-                       _("Generic command for setting how things print."),
-                       &setprintlist, "set print ", 0, &setlist);
-  add_alias_cmd ("p", "print", no_class, 1, &setlist);
+#if GDB_SELF_TEST
+  selftests::register_test_foreach_arch ("print-flags", test_print_flags);
+#endif
+
+  set_show_commands setshow_print_cmds
+    = add_setshow_prefix_cmd ("print", no_class,
+                             _("Generic command for setting how things print."),
+                             _("Generic command for showing print settings."),
+                             &setprintlist, &showprintlist,
+                             &setlist, &showlist);
+  add_alias_cmd ("p", setshow_print_cmds.set, no_class, 1, &setlist);

   /* Prefer set print to set prompt.  */
   /* Prefer set print to set prompt.  */

-  add_alias_cmd ("pr", "print", no_class, 1, &setlist);
-
-  add_show_prefix_cmd ("print", no_class,
-                      _("Generic command for showing print settings."),
-                      &showprintlist, "show print ", 0, &showlist);
-  add_alias_cmd ("p", "print", no_class, 1, &showlist);
-  add_alias_cmd ("pr", "print", no_class, 1, &showlist);
-
-  cmd = add_basic_prefix_cmd ("raw", no_class,
-                             _("\
-Generic command for setting what things to print in \"raw\" mode."),
-                             &setprintrawlist, "set print raw ", 0,
-                             &setprintlist);
-  deprecate_cmd (cmd, nullptr);
-
-  cmd = add_show_prefix_cmd ("raw", no_class,
-                            _("Generic command for showing \"print raw\" settings."),
-                            &showprintrawlist, "show print raw ", 0,
-                            &showprintlist);
-  deprecate_cmd (cmd, nullptr);
+  add_alias_cmd ("pr", setshow_print_cmds.set, no_class, 1, &setlist);
+  add_alias_cmd ("p", setshow_print_cmds.show, no_class, 1, &showlist);
+  add_alias_cmd ("pr", setshow_print_cmds.show, no_class, 1, &showlist);
+
+  set_show_commands setshow_print_raw_cmds
+    = add_setshow_prefix_cmd
+       ("raw", no_class,
+        _("Generic command for setting what things to print in \"raw\" mode."),
+        _("Generic command for showing \"print raw\" settings."),
+        &setprintrawlist, &showprintrawlist, &setprintlist, &showprintlist);
+  deprecate_cmd (setshow_print_raw_cmds.set, nullptr);
+  deprecate_cmd (setshow_print_raw_cmds.show, nullptr);

 
   gdb::option::add_setshow_cmds_for_options
     (class_support, &user_print_options, value_print_option_defs,
 
   gdb::option::add_setshow_cmds_for_options
     (class_support, &user_print_options, value_print_option_defs,