rewrite ada_val_print_ref to reduce if/else block nesting depth

The logic as currently implemented in this function was a little
difficult to follow, due to the nested of if/else conditions,
but most of the time, the "else" block was very simple. So this
patch re-organizes the code to use fewer levels of nesting by
using return statements, and writing the code as a sequence of
"if something simple, then handle it and return" blocks.

While touching this code, this patch changes the cryptic "???"
printed when trying to print a reference pointing to an undefined
type. This should only ever happen if the debugging information
was corrupted or improperly read. But in case that happens, we now
print "<ref to undefined type>" instead. This is more in line
with how we print other conditions such as optimized out pieces,
or synthetic pointers.

gdb/ChangeLog:

        * ada-valprint.c (ada_val_print_ref): Rewrite by mostly
        re-organizing the code. Change the "???" message printed
        when target type is a TYPE_CODE_UNDEF into
        "<ref to undefined type>".

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 4c1978c898d5e5f96964a36ee7a11f7fd85bc4a0..ece68cc26b844149b0a7f511c0c6046bddab0f23 100644 (file)
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,10 @@
+2014-01-07  Joel Brobecker  <brobecker@adacore.com>
+
+       * ada-valprint.c (ada_val_print_ref): Rewrite by mostly
+       re-organizing the code. Change the "???" message printed
+       when target type is a TYPE_CODE_UNDEF into
+       "<ref to undefined type>".
+
 2014-01-07  Joel Brobecker  <brobecker@adacore.com>
 
        * ada-valprint.c (print_record): Delete, implementation inlined...

diff --git a/gdb/ada-valprint.c b/gdb/ada-valprint.c
index 22ec9c0040db60fed162fdd0762ba17ffee0c97d..12c84daa48ac9853d5898c36c5d4ca7e4257ca49 100644 (file)
--- a/gdb/ada-valprint.c
+++ b/gdb/ada-valprint.c
@@ -1015,45 +1015,44 @@ ada_val_print_ref (struct type *type, const gdb_byte *valaddr,
      So, for Ada values, we print the actual dereferenced value
      regardless.  */
   struct type *elttype = check_typedef (TYPE_TARGET_TYPE (type));
+  struct value *deref_val;
+  CORE_ADDR deref_val_int;
 
-  if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF)
+  if (TYPE_CODE (elttype) == TYPE_CODE_UNDEF)
     {
-      CORE_ADDR deref_val_int;
-      struct value *deref_val;
+      fputs_filtered ("<ref to undefined type>", stream);
+      return;
+    }
 
-      deref_val = coerce_ref_if_computed (original_value);
-      if (deref_val)
-       {
-         if (ada_is_tagged_type (value_type (deref_val), 1))
-           deref_val = ada_tag_value_at_base_address (deref_val);
+  deref_val = coerce_ref_if_computed (original_value);
+  if (deref_val)
+    {
+      if (ada_is_tagged_type (value_type (deref_val), 1))
+       deref_val = ada_tag_value_at_base_address (deref_val);
 
-         common_val_print (deref_val, stream, recurse + 1, options,
-                           current_language);
-         return;
-       }
+      common_val_print (deref_val, stream, recurse + 1, options,
+                       language);
+      return;
+    }
 
-      deref_val_int = unpack_pointer (type, valaddr + offset_aligned);
-      if (deref_val_int != 0)
-       {
-         deref_val =
-           ada_value_ind (value_from_pointer
-                          (lookup_pointer_type (elttype),
-                           deref_val_int));
-
-         if (ada_is_tagged_type (value_type (deref_val), 1))
-           deref_val = ada_tag_value_at_base_address (deref_val);
-
-         val_print (value_type (deref_val),
-                    value_contents_for_printing (deref_val),
-                    value_embedded_offset (deref_val),
-                    value_address (deref_val), stream, recurse + 1,
-                    deref_val, options, current_language);
-       }
-      else
-       fputs_filtered ("(null)", stream);
+  deref_val_int = unpack_pointer (type, valaddr + offset_aligned);
+  if (deref_val_int == 0)
+    {
+      fputs_filtered ("(null)", stream);
+      return;
     }
-  else
-    fputs_filtered ("???", stream);
+
+  deref_val
+    = ada_value_ind (value_from_pointer (lookup_pointer_type (elttype),
+                                        deref_val_int));
+  if (ada_is_tagged_type (value_type (deref_val), 1))
+    deref_val = ada_tag_value_at_base_address (deref_val);
+
+  val_print (value_type (deref_val),
+            value_contents_for_printing (deref_val),
+            value_embedded_offset (deref_val),
+            value_address (deref_val), stream, recurse + 1,
+            deref_val, options, language);
 }
 
 /* See the comment on ada_val_print.  This function differs in that it