Add type checking overloads that ease their calling from GDB

	* include/abg-fwd.h (is_class_type, is_pointer, is_reference_type)
	(is_qualified_type): Declare overloads that take naked (non-smart)
	pointers.
	* src/abg-ir.cc (is_class_type, is_pointer, is_reference_type)
	(is_qualified_type): Define overloads that take naked (non-smart)
	pointers.

Signed-off-by: Dodji Seketeli <dodji@redhat.com>

diff --git a/include/abg-fwd.h b/include/abg-fwd.h
index 44011ca22d3c75910a41d689d39be8421ac56065..8807e3c4cd62a5c301c242f2c42968e8e18651ad 100644 (file)
--- a/include/abg-fwd.h
+++ b/include/abg-fwd.h
@@ -197,6 +197,9 @@ is_enum_type(const shared_ptr<decl_base>&);
 bool
 is_class_type(decl_base*);
 
+class_decl*
+is_class_type(type_base*);
+
 shared_ptr<class_decl>
 is_class_type(const shared_ptr<type_base>);
 
@@ -206,12 +209,21 @@ is_class_type(const shared_ptr<decl_base>);
 shared_ptr<class_decl>
 is_compatible_with_class_type(const shared_ptr<type_base>);
 
+pointer_type_def*
+is_pointer_type(type_base*);
+
 shared_ptr<pointer_type_def>
 is_pointer_type(const shared_ptr<type_base>);
 
+reference_type_def*
+is_reference_type(type_base*);
+
 shared_ptr<reference_type_def>
 is_reference_type(const shared_ptr<type_base>);
 
+qualified_type_def*
+is_qualified_type(type_base*);
+
 shared_ptr<qualified_type_def>
 is_qualified_type(const shared_ptr<type_base>);
 

diff --git a/src/abg-ir.cc b/src/abg-ir.cc
index 01246fa6cf074c30ebe26c4c6c4807e04127bed2..7a67d746044a19595e5422ef47032096d4836e64 100644 (file)
--- a/src/abg-ir.cc
+++ b/src/abg-ir.cc
@@ -3205,6 +3205,15 @@ is_compatible_with_class_type(const type_base_sptr t)
   return is_class_type(ty);
 }
 
+/// Test whether a type is a class.
+///
+/// @parm t the type to consider.
+///
+/// @return the class_decl if @p t is a class_decl or null otherwise.
+class_decl*
+is_class_type(type_base* t)
+{return dynamic_cast<class_decl*>(t);}
+
 /// Test whether a type is a class.
 ///
 /// @parm t the type to consider.
@@ -3246,6 +3255,16 @@ class_decl_sptr
 is_class_type(const decl_base_sptr d)
 {return is_class_type(is_type(d));}
 
+/// Test whether a type is a pointer_type_def.
+///
+/// @param t the type to test.
+///
+/// @return the @ref pointer_type_def_sptr if @p t is a
+/// pointer_type_def, null otherwise.
+pointer_type_def*
+is_pointer_type(type_base* t)
+{return dynamic_cast<pointer_type_def*>(t);}
+
 /// Test whether a type is a pointer_type_def.
 ///
 /// @param t the type to test.
@@ -3256,6 +3275,10 @@ pointer_type_def_sptr
 is_pointer_type(const type_base_sptr t)
 {return dynamic_pointer_cast<pointer_type_def>(t);}
 
+reference_type_def*
+is_reference_type(type_base* t)
+{return dynamic_cast<reference_type_def*>(t);}
+
 /// Test whether a type is a reference_type_def.
 ///
 /// @param t the type to test.
@@ -3266,6 +3289,16 @@ reference_type_def_sptr
 is_reference_type(const type_base_sptr t)
 {return dynamic_pointer_cast<reference_type_def>(t);}
 
+/// Test whether a type is a reference_type_def.
+///
+/// @param t the type to test.
+///
+/// @return the @ref reference_type_def_sptr if @p t is a
+/// reference_type_def, null otherwise.
+qualified_type_def*
+is_qualified_type(type_base* t)
+{return dynamic_cast<qualified_type_def*>(t);}
+
 /// Test whether a type is a qualified_type_def.
 ///
 /// @param t the type to test.