gdb: inline address_space_{name,type_instance_flags}_to_{type_instance_flags,name}

This is yet another refactoring step to treat Harvard address space
ids and address class ids separately and transparently from the fact
that they are stored in type instance flags.

The function 'address_space_name_to_type_instance_flags' converts
address space and address class names to type instance flags.  It
deals with the Harvard address space names "code" and "data" as well
as architecture specific address class names.  As a result, it may
produce type instance flags where either the Harvard address space
bits or the address class bits are set.  The function
'address_space_type_instance_flags_to_name' does the conversion in the
opposite direction.

Inline the functions and remove them.  This is a step towards
separating the handling of two concepts.

In type-stack.c, which is used by the parser to convert user inputs
into types, "@code" and "@data" and architecture-specific address
class names are treated the same, too, blurring the difference and
their storage in type instance flags.  While we inline the use of
address_space_name_to_type_instance_flags there, we also separate the
two topics by defining different tokens.  The patch still pushes type
instance flags into the type stack.  The subsequent patch will further
clean this up to store address class and address space ids.

A hardcoded shift operation will go away in a future patch.

Approved-By: Tom Tromey <tom@tromey.com>

diff --git a/gdb/c-typeprint.c b/gdb/c-typeprint.c
index 1168464a9f9f71cc5aa3a9c05509dd253b79fa52..db3bc29475f8ef5c4fbefb37b701f2cdbea6e966 100644 (file)
--- a/gdb/c-typeprint.c
+++ b/gdb/c-typeprint.c
@@ -19,6 +19,7 @@
 #include "event-top.h"
 #include "bfd.h"
 #include "symtab.h"
+#include "gdbarch.h"
 #include "gdbtypes.h"
 #include "expression.h"
 #include "value.h"
@@ -482,10 +483,18 @@ c_type_print_modifier (struct type *type, struct ui_file *stream,
       did_print_modifier = 1;
     }
 
-  address_space_id
-    = address_space_type_instance_flags_to_name (type->arch (),
-                                                type->instance_flags ());
-  if (address_space_id)
+  address_space_id = nullptr;
+
+  if (TYPE_CODE_SPACE (type))
+    address_space_id = "code";
+  else if (TYPE_DATA_SPACE (type))
+    address_space_id = "data";
+  else if (gdbarch_address_class_id_to_name_p (type->arch ()))
+    address_space_id
+      = gdbarch_address_class_id_to_name (type->arch (),
+                                         TYPE_ADDRESS_CLASS (type));
+
+  if (address_space_id != nullptr)
     {
       if (did_print_modifier || need_pre_space)
        gdb_printf (stream, " ");

diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c
index 87cc7d15d0df92ab39dc03f23b4efa3696ad66aa..97f1b3e1417bd6495b6938c50f18721fef687d33 100644 (file)
--- a/gdb/gdbtypes.c
+++ b/gdb/gdbtypes.c
@@ -536,51 +536,6 @@ lookup_function_type_with_arguments (struct type *return_type,
   return create_function_type (return_type, nparams, param_types);
 }
 
-/* Identify address space identifier by name -- return a
-   type_instance_flags.  */
-
-type_instance_flags
-address_space_name_to_type_instance_flags (struct gdbarch *gdbarch,
-                                          const char *space_identifier)
-{
-  /* Check for known address space delimiters.  */
-  if (streq (space_identifier, "code"))
-    return TYPE_INSTANCE_FLAG_CODE_SPACE;
-  else if (streq (space_identifier, "data"))
-    return TYPE_INSTANCE_FLAG_DATA_SPACE;
-
-  unsigned int aclass;
-  if (gdbarch_address_class_name_to_id_p (gdbarch)
-      && gdbarch_address_class_name_to_id (gdbarch,
-                                          space_identifier,
-                                          aclass))
-    {
-      return (enum type_instance_flag_value) (aclass << 4);
-    }
-  else
-    error (_("Unknown address space specifier: \"%s\""), space_identifier);
-}
-
-/* Identify address space identifier by type_instance_flags and return
-   the string version of the address space name.  */
-
-const char *
-address_space_type_instance_flags_to_name (struct gdbarch *gdbarch,
-                                          type_instance_flags space_flag)
-{
-  if (space_flag & TYPE_INSTANCE_FLAG_CODE_SPACE)
-    return "code";
-  else if (space_flag & TYPE_INSTANCE_FLAG_DATA_SPACE)
-    return "data";
-
-  unsigned int aclass = TYPE_ADDRESS_CLASS_FROM_INSTANCE_FLAGS (space_flag);
-
-  if (gdbarch_address_class_id_to_name_p (gdbarch))
-    return gdbarch_address_class_id_to_name (gdbarch, aclass);
-  else
-    return NULL;
-}
-
 /* Create a new type with instance flags NEW_FLAGS, based on TYPE.
 
    If STORAGE is non-NULL, create the new type instance there.

diff --git a/gdb/gdbtypes.h b/gdb/gdbtypes.h
index 3c21d4ad214eaeda31f5dbf385251856e59bb3b3..1d5c96ab2c143669a6ae9f4f2859dc2d41fc19fe 100644 (file)
--- a/gdb/gdbtypes.h
+++ b/gdb/gdbtypes.h
@@ -2420,12 +2420,6 @@ extern struct type *make_atomic_type (struct type *);
 
 extern void replace_type (struct type *, struct type *);
 
-extern type_instance_flags address_space_name_to_type_instance_flags
-  (struct gdbarch *, const char *);
-
-extern const char *address_space_type_instance_flags_to_name
-  (struct gdbarch *, type_instance_flags);
-
 extern struct type *make_type_with_address_space
   (struct type *type, type_instance_flags space_identifier);
 

diff --git a/gdb/testsuite/gdb.base/address_space_qualifier.exp b/gdb/testsuite/gdb.base/address_space_qualifier.exp
index 49437dad60dc90f8042e77b681c457af5a992738..3e94e895493ac81f3f42c390b7d5aefdf45abbec 100644 (file)
--- a/gdb/testsuite/gdb.base/address_space_qualifier.exp
+++ b/gdb/testsuite/gdb.base/address_space_qualifier.exp
@@ -22,12 +22,12 @@ gdb_test_no_output "set language c"
 
 with_test_prefix "C" {
        gdb_test "p *(@somerandomqualifiername int *) 0x12345678" \
-               "Unknown address space specifier: \"somerandomqualifiername\""
+               "Unknown address space/class specifier: \"somerandomqualifiername\""
 }
 
 gdb_test_no_output "set language c++"
 
 with_test_prefix "C++" {
        gdb_test "p *(@somerandomqualifiername int *) 0x12345678" \
-               "Unknown address space specifier: \"somerandomqualifiername\""
+               "Unknown address space/class specifier: \"somerandomqualifiername\""
 }

diff --git a/gdb/type-stack.c b/gdb/type-stack.c
index d19854363a2407cfd47bf1e5729d7dca0b30411a..dce1a138e36e0af971aef669318c6f7f55c0f28f 100644 (file)
--- a/gdb/type-stack.c
+++ b/gdb/type-stack.c
@@ -20,6 +20,7 @@
 #include "type-stack.h"
 
 #include "gdbtypes.h"
+#include "gdbarch.h"
 
 /* See type-stack.h.  */
 
@@ -51,10 +52,29 @@ type_stack::insert (struct gdbarch *gdbarch, const char *string)
      Otherwise, simply push this on the top of the stack.  */
   int slot = (!m_elements.empty ()) ? 1 : 0;
 
-  insert_into (slot, tp_space_identifier);
-  insert_into (slot,
-              address_space_name_to_type_instance_flags (gdbarch,
-                                                         string));
+  /* Check for Harvard address space delimiters and
+     architecture-specific address classes.  */
+  if (streq (string, "code"))
+    {
+      insert_into (slot, tp_harvard_aspace_identifier);
+      insert_into (slot, TYPE_INSTANCE_FLAG_CODE_SPACE);
+    }
+  else if (streq (string, "data"))
+    {
+      insert_into (slot, tp_harvard_aspace_identifier);
+      insert_into (slot, TYPE_INSTANCE_FLAG_DATA_SPACE);
+    }
+  else if (unsigned int aclass = 0;
+          gdbarch_address_class_name_to_id_p (gdbarch)
+          && gdbarch_address_class_name_to_id (gdbarch,
+                                               string,
+                                               aclass))
+    {
+      insert_into (slot, tp_aclass_identifier);
+      insert_into (slot, (enum type_instance_flag_value) (aclass << 4));
+    }
+  else
+    error (_("Unknown address space/class specifier: \"%s\""), string);
 }
 
 /* See type-stack.h.  */
@@ -112,7 +132,10 @@ type_stack::follow_types (struct type *follow_type)
       case tp_volatile:
        make_volatile = 1;
        break;
-      case tp_space_identifier:
+      case tp_harvard_aspace_identifier:
+       make_addr_space = (enum type_instance_flag_value) pop_int ();
+       break;
+      case tp_aclass_identifier:
        make_addr_space = (enum type_instance_flag_value) pop_int ();
        break;
       case tp_atomic:

diff --git a/gdb/type-stack.h b/gdb/type-stack.h
index 1be6d569d8e47cd1854fd3c05bb8e6a4452f6ff7..19199afd432aceeea0a9a2e66e591b03f55ce29b 100644 (file)
--- a/gdb/type-stack.h
+++ b/gdb/type-stack.h
@@ -45,9 +45,12 @@ enum type_pieces
   tp_function_with_arguments,
   tp_const,
   tp_volatile,
-  /* An address space identifier.  The address space is also pushed on
+  /* An Harvard address space identifier (i.e. "code" or "data").  The
+     address space is also pushed on the stack.  */
+  tp_harvard_aspace_identifier,
+  /* An address class identifier.  The address class is also pushed on
      the stack.  */
-  tp_space_identifier,
+  tp_aclass_identifier,
   tp_atomic,
   tp_restrict,
   /* A separate type stack, which is also pushed onto this type
@@ -114,7 +117,8 @@ public:
      accept an integer argument are allowed.  */
   void push (enum type_pieces tp, int n)
   {
-    gdb_assert (tp == tp_array || tp == tp_space_identifier || tp == tp_kind);
+    gdb_assert (tp == tp_array || tp == tp_harvard_aspace_identifier
+               || tp == tp_aclass_identifier || tp == tp_kind);
     type_stack_elt elt;
     elt.int_val = n;
     m_elements.push_back (elt);
@@ -172,7 +176,8 @@ public:
     type_stack_elt elt = m_elements.back ();
     m_elements.pop_back ();
     type_pieces tp = elt.piece;
-    gdb_assert (tp == tp_array || tp == tp_space_identifier || tp == tp_kind);
+    gdb_assert (tp == tp_array || tp == tp_harvard_aspace_identifier
+               || tp == tp_aclass_identifier || tp == tp_kind);
     elt = m_elements.back ();
     m_elements.pop_back ();
     return elt.int_val;
@@ -204,13 +209,14 @@ public:
     return elt.stack_val;
   }
 
-  /* Insert a tp_space_identifier and the corresponding address space
-     value into the stack.  STRING is the name of an address space, as
-     recognized by address_space_name_to_type_instance_flags.  If the
-     stack is empty, the new elements are simply pushed.  If the stack
-     is not empty, this function assumes that the first item on the
-     stack is a tp_pointer, and the new values are inserted above the
-     first item.  */
+  /* Insert an address space or address class identifier and the
+     corresponding id value into the stack.  STRING is the name of a
+     Harvard address space ("code" or "data"), or the name of an
+     address class as recognized by gdbarch_address_class_name_to_id.
+     If the stack is empty, the new elements are simply pushed.  If
+     the stack is not empty, this function assumes that the first item
+     on the stack is a tp_pointer, and the new values are inserted
+     above the first item.  */
 
   void insert (struct gdbarch *gdbarch, const char *string);
 
@@ -266,7 +272,8 @@ private:
   {
     return (tp == tp_array || tp == tp_kind || tp == tp_type_stack
            || tp == tp_function_with_arguments
-           || tp == tp_space_identifier);
+           || tp == tp_harvard_aspace_identifier
+           || tp == tp_aclass_identifier);
   }