+2020-03-13  Tom Tromey  <tom@tromey.com>
+
+       * valprint.c (do_val_print): Update.
+       * python/python-internal.h (gdbpy_apply_val_pretty_printer): Take
+       a struct value.
+       (value_to_value_object_no_release): Declare.
+       * python/py-value.c (value_to_value_object_no_release): New
+       function.
+       * python/py-prettyprint.c (gdbpy_apply_val_pretty_printer): Take a
+       struct value.
+       * guile/scm-value.c (vlscm_scm_from_value_no_release): New
+       function.
+       * guile/scm-pretty-print.c (gdbscm_apply_val_pretty_printer): Take
+       a struct value.
+       * guile/guile-internal.h (vlscm_scm_from_value_no_release):
+       Declare.
+       (gdbscm_apply_val_pretty_printer): Take a struct value.
+       * extension.h (apply_ext_lang_val_pretty_printer): Take a struct
+       value.
+       * extension.c (apply_ext_lang_val_pretty_printer): Take a struct
+       value.
+       * extension-priv.h (struct extension_language_ops)
+       <apply_val_pretty_printer>: Take a struct value.
+       * cp-valprint.c (cp_print_value): Create a struct value.
+       (cp_print_value): Update.
+
 2020-03-13  Tom Tromey  <tom@tromey.com>
 
        * ada-valprint.c (print_field_values): Call common_val_print.
 
              /* Attempt to run an extension language pretty-printer on the
                 baseclass if possible.  */
              if (!options->raw)
-               result
-                 = apply_ext_lang_val_pretty_printer (baseclass,
-                                                      thisoffset + boffset,
-                                                      value_address (base_val),
-                                                      stream, recurse,
-                                                      base_val, options,
-                                                      current_language);
+               {
+                 struct value *v
+                   = value_from_component (base_val, baseclass,
+                                           thisoffset + boffset);
+                 result
+                   = apply_ext_lang_val_pretty_printer (v, stream, recurse,
+                                                        options,
+                                                        current_language);
+               }
 
              if (!result)
                cp_print_value_fields (baseclass, thistype,
            }
          else
            {
+             struct value *baseclass_val = value_primitive_field (val, 0,
+                                                                  i, type);
+
              /* Attempt to run an extension language pretty-printer on the
                 baseclass if possible.  */
              if (!options->raw)
                result
-                 = apply_ext_lang_val_pretty_printer (baseclass, boffset,
-                                                      value_address (base_val),
-                                                      stream, recurse,
-                                                      base_val, options,
+                 = apply_ext_lang_val_pretty_printer (baseclass_val, stream,
+                                                      recurse, options,
                                                       current_language);
 
              if (!result)
-               cp_print_value_fields (value_primitive_field (val, 0, i, type),
-                                      stream, recurse, options,
+               cp_print_value_fields (baseclass_val, stream, recurse, options,
                                       ((struct type **)
                                        obstack_base (&dont_print_vb_obstack)),
                                       0);
 
   void (*free_type_printers) (const struct extension_language_defn *,
                              struct ext_lang_type_printers *);
 
-  /* Try to pretty-print a value of type TYPE located at VAL's contents
-     buffer + EMBEDDED_OFFSET, which came from the inferior at address
-     ADDRESS + EMBEDDED_OFFSET, onto stdio stream STREAM according to
-     OPTIONS.
-     VAL is the whole object that came from ADDRESS.
-     Returns EXT_LANG_RC_OK upon success, EXT_LANG_RC_NOP if the value
-     is not recognized, and EXT_LANG_RC_ERROR if an error was encountered.  */
+  /* Try to pretty-print a value, onto stdio stream STREAM according
+     to OPTIONS.  VAL is the object to print.  Returns EXT_LANG_RC_OK
+     upon success, EXT_LANG_RC_NOP if the value is not recognized, and
+     EXT_LANG_RC_ERROR if an error was encountered.  */
   enum ext_lang_rc (*apply_val_pretty_printer)
     (const struct extension_language_defn *,
-     struct type *type,
-     LONGEST embedded_offset, CORE_ADDR address,
-     struct ui_file *stream, int recurse,
-     struct value *val, const struct value_print_options *options,
+     struct value *val, struct ui_file *stream, int recurse,
+     const struct value_print_options *options,
      const struct language_defn *language);
 
   /* GDB access to the "frame filter" feature.
 
     }
 }
 \f
-/* Try to pretty-print a value of type TYPE located at VAL's contents
-   buffer + EMBEDDED_OFFSET, which came from the inferior at address
-   ADDRESS + EMBEDDED_OFFSET, onto stdio stream STREAM according to
-   OPTIONS.
-   VAL is the whole object that came from ADDRESS.
-   Returns non-zero if the value was successfully pretty-printed.
+/* Try to pretty-print a value onto stdio stream STREAM according to
+   OPTIONS.  VAL is the object to print.  Returns non-zero if the
+   value was successfully pretty-printed.
 
    Extension languages are tried in the order specified by
    extension_languages.  The first one to provide a pretty-printed
    errors that trigger an exception in the extension language.  */
 
 int
-apply_ext_lang_val_pretty_printer (struct type *type,
-                                  LONGEST embedded_offset, CORE_ADDR address,
+apply_ext_lang_val_pretty_printer (struct value *val,
                                   struct ui_file *stream, int recurse,
-                                  struct value *val,
                                   const struct value_print_options *options,
                                   const struct language_defn *language)
 {
 
       if (extlang->ops->apply_val_pretty_printer == NULL)
        continue;
-      rc = extlang->ops->apply_val_pretty_printer (extlang, type,
-                                                  embedded_offset, address,
-                                                  stream, recurse, val,
-                                                  options, language);
+      rc = extlang->ops->apply_val_pretty_printer (extlang, val, stream,
+                                                  recurse, options, language);
       switch (rc)
        {
        case EXT_LANG_RC_OK:
 
                                           struct type *);
 
 extern int apply_ext_lang_val_pretty_printer
-  (struct type *type,
-   LONGEST embedded_offset, CORE_ADDR address,
-   struct ui_file *stream, int recurse,
-   struct value *val, const struct value_print_options *options,
+  (struct value *value, struct ui_file *stream, int recurse,
+   const struct value_print_options *options,
    const struct language_defn *language);
 
 extern enum ext_lang_bt_status apply_ext_lang_frame_filter
 
 extern int vlscm_is_value (SCM scm);
 
 extern SCM vlscm_scm_from_value (struct value *value);
+extern SCM vlscm_scm_from_value_no_release (struct value *value);
 
 extern struct value *vlscm_convert_typed_value_from_scheme
   (const char *func_name, int obj_arg_pos, SCM obj,
 
 extern enum ext_lang_rc gdbscm_apply_val_pretty_printer
   (const struct extension_language_defn *,
-   struct type *type,
-   LONGEST embedded_offset, CORE_ADDR address,
-   struct ui_file *stream, int recurse,
    struct value *val,
+   struct ui_file *stream, int recurse,
    const struct value_print_options *options,
    const struct language_defn *language);
 
 
 
 enum ext_lang_rc
 gdbscm_apply_val_pretty_printer (const struct extension_language_defn *extlang,
-                                struct type *type,
-                                LONGEST embedded_offset, CORE_ADDR address,
+                                struct value *value,
                                 struct ui_file *stream, int recurse,
-                                struct value *val,
                                 const struct value_print_options *options,
                                 const struct language_defn *language)
 {
+  struct type *type = value_type (value);
   struct gdbarch *gdbarch = get_type_arch (type);
   SCM exception = SCM_BOOL_F;
   SCM printer = SCM_BOOL_F;
   SCM val_obj = SCM_BOOL_F;
-  struct value *value;
   enum display_hint hint;
   enum ext_lang_rc result = EXT_LANG_RC_NOP;
   enum string_repr_result print_result;
 
-  if (value_lazy (val))
-    value_fetch_lazy (val);
+  if (value_lazy (value))
+    value_fetch_lazy (value);
 
   /* No pretty-printer support for unavailable values.  */
-  if (!value_bytes_available (val, embedded_offset, TYPE_LENGTH (type)))
+  if (!value_bytes_available (value, 0, TYPE_LENGTH (type)))
     return EXT_LANG_RC_NOP;
 
   if (!gdb_scheme_initialized)
     return EXT_LANG_RC_NOP;
 
   /* Instantiate the printer.  */
-  value = value_from_component (val, type, embedded_offset);
-
-  val_obj = vlscm_scm_from_value (value);
+  val_obj = vlscm_scm_from_value_no_release (value);
   if (gdbscm_is_exception (val_obj))
     {
       exception = val_obj;
 
   return v_scm;
 }
 
+/* Create a new <gdb:value> object that encapsulates VALUE.
+   The value is not released from the all_values chain.  */
+
+SCM
+vlscm_scm_from_value_no_release (struct value *value)
+{
+  /* N.B. It's important to not cause any side-effects until we know the
+     conversion worked.  */
+  SCM v_scm = vlscm_make_value_smob ();
+  value_smob *v_smob = (value_smob *) SCM_SMOB_DATA (v_scm);
+
+  value_incref (value);
+  v_smob->value = value;
+  vlscm_remember_scheme_value (v_smob);
+
+  return v_scm;
+}
+
 /* Returns the <gdb:value> object in SELF.
    Throws an exception if SELF is not a <gdb:value> object.  */
 
 
 
 enum ext_lang_rc
 gdbpy_apply_val_pretty_printer (const struct extension_language_defn *extlang,
-                               struct type *type,
-                               LONGEST embedded_offset, CORE_ADDR address,
+                               struct value *value,
                                struct ui_file *stream, int recurse,
-                               struct value *val,
                                const struct value_print_options *options,
                                const struct language_defn *language)
 {
+  struct type *type = value_type (value);
   struct gdbarch *gdbarch = get_type_arch (type);
-  struct value *value;
   enum string_repr_result print_result;
 
-  if (value_lazy (val))
-    value_fetch_lazy (val);
+  if (value_lazy (value))
+    value_fetch_lazy (value);
 
   /* No pretty-printer support for unavailable values.  */
-  if (!value_bytes_available (val, embedded_offset, TYPE_LENGTH (type)))
+  if (!value_bytes_available (value, 0, TYPE_LENGTH (type)))
     return EXT_LANG_RC_NOP;
 
   if (!gdb_python_initialized)
 
   gdbpy_enter enter_py (gdbarch, language);
 
-  /* Instantiate the printer.  */
-  value = value_from_component (val, type, embedded_offset);
-
-  gdbpy_ref<> val_obj (value_to_value_object (value));
+  gdbpy_ref<> val_obj (value_to_value_object_no_release (value));
   if (val_obj == NULL)
     {
       print_stack_unless_memory_error (stream);
 
   return (PyObject *) val_obj;
 }
 
+/* Returns an object for a value, but without releasing it from the
+   all_values chain.  */
+PyObject *
+value_to_value_object_no_release (struct value *val)
+{
+  value_object *val_obj;
+
+  val_obj = PyObject_New (value_object, &value_object_type);
+  if (val_obj != NULL)
+    {
+      value_incref (val);
+      val_obj->value = val;
+      val_obj->address = NULL;
+      val_obj->type = NULL;
+      val_obj->dynamic_type = NULL;
+      note_value (val_obj);
+    }
+
+  return (PyObject *) val_obj;
+}
+
 /* Returns a borrowed reference to the struct value corresponding to
    the given value object.  */
 struct value *
 
 
 extern enum ext_lang_rc gdbpy_apply_val_pretty_printer
   (const struct extension_language_defn *,
-   struct type *type,
-   LONGEST embedded_offset, CORE_ADDR address,
+   struct value *value,
    struct ui_file *stream, int recurse,
-   struct value *val,
    const struct value_print_options *options,
    const struct language_defn *language);
 extern enum ext_lang_bt_status gdbpy_apply_frame_filter
 PyObject *block_to_block_object (const struct block *block,
                                 struct objfile *objfile);
 PyObject *value_to_value_object (struct value *v);
+PyObject *value_to_value_object_no_release (struct value *v);
 PyObject *type_to_type_object (struct type *);
 PyObject *frame_info_to_frame_object (struct frame_info *frame);
 PyObject *symtab_to_linetable_object (PyObject *symtab);
 
 
   if (!options->raw)
     {
-      ret = apply_ext_lang_val_pretty_printer (type, embedded_offset,
-                                              address, stream, recurse,
-                                              val, options, language);
+      struct value *v = full_value;
+
+      if (v == nullptr)
+       v = value_from_component (val, type, embedded_offset);
+
+      ret = apply_ext_lang_val_pretty_printer (v, stream, recurse, options,
+                                              language);
       if (ret)
        return;
     }
   if (!options->raw)
     {
       int r
-       = apply_ext_lang_val_pretty_printer (value_type (val),
-                                            value_embedded_offset (val),
-                                            value_address (val),
-                                            stream, 0,
-                                            val, options, current_language);
+       = apply_ext_lang_val_pretty_printer (val, stream, 0, options,
+                                            current_language);
 
       if (r)
        return;