From 16692f69f3ce5e533c835b553bd00e149191fd9c Mon Sep 17 00:00:00 2001 From: Boris Kolpackov Date: Mon, 29 Mar 2010 11:40:32 +0200 Subject: Assign tree nodes to graph type nodes --- odb/plugin.cxx | 45 ++++++++++++++++++------------- odb/semantics/class-template.hxx | 7 +++-- odb/semantics/class.hxx | 4 +-- odb/semantics/derived.hxx | 28 ++++++++++--------- odb/semantics/elements.hxx | 30 ++++++++++++++------- odb/semantics/enum.hxx | 4 +-- odb/semantics/fundamental.hxx | 58 +++++++++++++++++++++++++++------------- odb/semantics/union-template.hxx | 7 +++-- odb/semantics/union.hxx | 4 +-- odb/semantics/unit.hxx | 20 +++++++------- 10 files changed, 128 insertions(+), 79 deletions(-) (limited to 'odb') diff --git a/odb/plugin.cxx b/odb/plugin.cxx index 15350f3..35e6ab6 100644 --- a/odb/plugin.cxx +++ b/odb/plugin.cxx @@ -261,9 +261,10 @@ private: // if (TYPE_PTRMEMFUNC_P (t)) { + t = TYPE_MAIN_VARIANT (t); node = &unit_->new_node ( - file, line, clmn, "pointer_to_member_function_type"); - unit_->insert (TYPE_MAIN_VARIANT (t), *node); + file, line, clmn, t, "pointer_to_member_function_type"); + unit_->insert (t, *node); } else { @@ -558,7 +559,7 @@ private: } else { - c_node = &unit_->new_node (file, line, clmn); + c_node = &unit_->new_node (file, line, clmn, c); unit_->insert (c, *c_node); } @@ -747,7 +748,7 @@ private: } else { - u_node = &unit_->new_node (file, line, clmn); + u_node = &unit_->new_node (file, line, clmn, u); unit_->insert (u, *u_node); } @@ -859,7 +860,7 @@ private: } else { - e_node = &unit_->new_node (file, line, clmn); + e_node = &unit_->new_node (file, line, clmn, e); unit_->insert (e, *e_node); } @@ -936,9 +937,10 @@ private: } } - // No such variant yet. Create a new one. + // No such variant yet. Create a new one. Qualified types are not + // unique in the tree so don't add this node to the map. // - qualifier& q (unit_->new_node (file, line, clmn, qc, qv, qr)); + qualifier& q (unit_->new_node (file, line, clmn, t, qc, qv, qr)); unit_->new_edge (q, r); return q; } @@ -983,7 +985,7 @@ private: if (TYPE_PTRMEMFUNC_P (t)) { r = &unit_->new_node ( - file, line, clmn, "pointer_to_member_function_type"); + file, line, clmn, t, "pointer_to_member_function_type"); unit_->insert (t, *r); } else @@ -1154,18 +1156,20 @@ private: } type& bt (emit_type (TREE_TYPE (t), file, line, clmn)); - array& a (unit_->new_node (file, line, clmn, size)); + t = TYPE_MAIN_VARIANT (t); + array& a (unit_->new_node (file, line, clmn, t, size)); + unit_->insert (t, a); unit_->new_edge (a, bt); - unit_->insert (TYPE_MAIN_VARIANT (t), a); r = &a; break; } case REFERENCE_TYPE: { type& bt (emit_type (TREE_TYPE (t), file, line, clmn)); - reference& ref (unit_->new_node (file, line, clmn)); + t = TYPE_MAIN_VARIANT (t); + reference& ref (unit_->new_node (file, line, clmn, t)); + unit_->insert (t, ref); unit_->new_edge (ref, bt); - unit_->insert (TYPE_MAIN_VARIANT (t), ref); r = &ref; break; } @@ -1174,16 +1178,18 @@ private: if (!TYPE_PTRMEM_P (t)) { type& bt (emit_type (TREE_TYPE (t), file, line, clmn)); - pointer& p (unit_->new_node (file, line, clmn)); + t = TYPE_MAIN_VARIANT (t); + pointer& p (unit_->new_node (file, line, clmn, t)); + unit_->insert (t, p); unit_->new_edge (p, bt); - unit_->insert (TYPE_MAIN_VARIANT (t), p); r = &p; } else { + t = TYPE_MAIN_VARIANT (t); r = &unit_->new_node ( - file, line, clmn, "pointer_to_data_member_type"); - unit_->insert (TYPE_MAIN_VARIANT (t), *r); + file, line, clmn, t, "pointer_to_data_member_type"); + unit_->insert (t, *r); if (trace) ts << "unsupported pointer_to_data_member_type (" << r << ")" @@ -1193,9 +1199,10 @@ private: } default: { + t = TYPE_MAIN_VARIANT (t); r = &unit_->new_node ( - file, line, clmn, tree_code_name[tc]); - unit_->insert (TYPE_MAIN_VARIANT (t), *r); + file, line, clmn, t, tree_code_name[tc]); + unit_->insert (t, *r); if (trace) ts << "unsupported " << tree_code_name[tc] << " (" << r << ")" @@ -1441,7 +1448,7 @@ private: t = TYPE_MAIN_VARIANT (t); char const* name (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (t)))); - T& node (unit_->new_fund_node ()); + T& node (unit_->new_fund_node (t)); unit_->new_edge (*scope_, node, name); unit_->insert (t, node); } diff --git a/odb/semantics/class-template.hxx b/odb/semantics/class-template.hxx index 6443a19..68a6151 100644 --- a/odb/semantics/class-template.hxx +++ b/odb/semantics/class-template.hxx @@ -63,8 +63,11 @@ namespace semantics class class_instantiation: public class_, public type_instantiation { public: - class_instantiation (path const& file, size_t line, size_t column) - : node (file, line, column) + class_instantiation (path const& file, + size_t line, + size_t column, + tree tn) + : node (file, line, column), type (tn) { } diff --git a/odb/semantics/class.hxx b/odb/semantics/class.hxx index bbe4687..348fbdf 100644 --- a/odb/semantics/class.hxx +++ b/odb/semantics/class.hxx @@ -91,8 +91,8 @@ namespace semantics } public: - class_ (path const& file, size_t line, size_t column) - : node (file, line, column) + class_ (path const& file, size_t line, size_t column, tree tn) + : node (file, line, column), type (tn) { } diff --git a/odb/semantics/derived.hxx b/odb/semantics/derived.hxx index 01dd79c..00ab18a 100644 --- a/odb/semantics/derived.hxx +++ b/odb/semantics/derived.hxx @@ -19,6 +19,12 @@ namespace semantics public: virtual type& base_type () const = 0; + + protected: + derived_type (tree tn) + : type (tn) + { + } }; // @@ -104,17 +110,17 @@ namespace semantics qualifier (path const& file, size_t line, size_t column, + tree tn, bool c, bool v, bool r) - : node (file, line, column), c_ (c), v_ (v), r_ (r), qualifies_ (0) + : node (file, line, column), derived_type (tn), c_ (c), v_ (v), r_ (r) { } void add_edge_left (qualifies_type& e) { - assert (qualifies_ == 0); qualifies_ = &e; } @@ -167,7 +173,7 @@ namespace semantics pointer_type* pointer_; }; - class pointer: public type + class pointer: public derived_type { public: typedef semantics::points points_type; @@ -185,15 +191,14 @@ namespace semantics } public: - pointer (path const& file, size_t line, size_t column) - : node (file, line, column), points_ (0) + pointer (path const& file, size_t line, size_t column, tree tn) + : node (file, line, column), derived_type (tn) { } void add_edge_left (points_type& e) { - assert (points_ == 0); points_ = &e; } @@ -246,7 +251,7 @@ namespace semantics reference_type* reference_; }; - class reference: public type + class reference: public derived_type { public: typedef semantics::references references_type; @@ -264,15 +269,14 @@ namespace semantics } public: - reference (path const& file, size_t line, size_t column) - : node (file, line, column), references_ (0) + reference (path const& file, size_t line, size_t column, tree tn) + : node (file, line, column), derived_type (tn) { } void add_edge_left (references_type& e) { - assert (references_ == 0); references_ = &e; } @@ -355,15 +359,15 @@ namespace semantics array (path const& file, size_t line, size_t column, + tree tn, unsigned long long size) - : node (file, line, column), contains_ (0), size_ (size) + : node (file, line, column), derived_type (tn), size_ (size) { } void add_edge_left (contains_type& e) { - assert (contains_ == 0); contains_ = &e; } diff --git a/odb/semantics/elements.hxx b/odb/semantics/elements.hxx index 97f386f..969f33a 100644 --- a/odb/semantics/elements.hxx +++ b/odb/semantics/elements.hxx @@ -36,10 +36,6 @@ namespace semantics using compiler::context; - // GCC parse tree node. - // - typedef ::tree gcc_tree; - // // using fs::path; @@ -422,6 +418,13 @@ namespace semantics typedef std::vector qualified; public: + tree + tree_node () const + { + return tree_node_; + } + + public: typedef pointer_iterator qualified_iterator; qualified_iterator @@ -437,11 +440,6 @@ namespace semantics } public: - type (path const& file, size_t line, size_t column) - : node (file, line, column) - { - } - void add_edge_right (belongs&) { @@ -456,11 +454,22 @@ namespace semantics using nameable::add_edge_right; protected: + type (tree tn) + : tree_node_ (tn) + { + } + + // For virtual inheritance. Should never be actually called. + // type () { + // GCC plugin machinery #define's abort as a macro. + // + abort (); } private: + tree tree_node_; qualified qualified_; }; @@ -570,8 +579,9 @@ namespace semantics unsupported_type (path const& file, size_t line, size_t column, + tree tn, string const& type_name) - : node (file, line, column), type_name_ (type_name) + : node (file, line, column), type (tn), type_name_ (type_name) { } diff --git a/odb/semantics/enum.hxx b/odb/semantics/enum.hxx index e628ad9..5ef369c 100644 --- a/odb/semantics/enum.hxx +++ b/odb/semantics/enum.hxx @@ -114,8 +114,8 @@ namespace semantics } public: - enum_ (path const& file, size_t line, size_t column) - : node (file, line, column) + enum_ (path const& file, size_t line, size_t column, tree tn) + : node (file, line, column), type (tn) { } diff --git a/odb/semantics/fundamental.hxx b/odb/semantics/fundamental.hxx index aa8225a..eea49a8 100644 --- a/odb/semantics/fundamental.hxx +++ b/odb/semantics/fundamental.hxx @@ -14,16 +14,23 @@ namespace semantics // Fundamental C++ types. // - class fund_type: public type {}; + class fund_type: public type + { + protected: + fund_type (tree tn) + : type (tn) {} + }; struct fund_void: fund_type { - fund_void (): node (path (""), 0, 0) {} + fund_void (tree tn) + : node (path (""), 0, 0), fund_type (tn) {} }; struct fund_bool: fund_type { - fund_bool (): node (path (""), 0, 0) {} + fund_bool (tree tn) + : node (path (""), 0, 0), fund_type (tn) {} }; // @@ -32,62 +39,74 @@ namespace semantics struct fund_char: fund_type { - fund_char (): node (path (""), 0, 0) {} + fund_char (tree tn) + : node (path (""), 0, 0), fund_type (tn) {} }; struct fund_wchar: fund_type { - fund_wchar (): node (path (""), 0, 0) {} + fund_wchar (tree tn) + : node (path (""), 0, 0), fund_type (tn) {} }; struct fund_signed_char: fund_type { - fund_signed_char (): node (path (""), 0, 0) {} + fund_signed_char (tree tn) + : node (path (""), 0, 0), fund_type (tn) {} }; struct fund_unsigned_char: fund_type { - fund_unsigned_char (): node (path (""), 0, 0) {} + fund_unsigned_char (tree tn) + : node (path (""), 0, 0), fund_type (tn) {} }; struct fund_short: fund_type { - fund_short (): node (path (""), 0, 0) {} + fund_short (tree tn) + : node (path (""), 0, 0), fund_type (tn) {} }; struct fund_unsigned_short: fund_type { - fund_unsigned_short (): node (path (""), 0, 0) {} + fund_unsigned_short (tree tn) + : node (path (""), 0, 0), fund_type (tn) {} }; struct fund_int: fund_type { - fund_int (): node (path (""), 0, 0) {} + fund_int (tree tn) + : node (path (""), 0, 0), fund_type (tn) {} }; struct fund_unsigned_int: fund_type { - fund_unsigned_int (): node (path (""), 0, 0) {} + fund_unsigned_int (tree tn) + : node (path (""), 0, 0), fund_type (tn) {} }; struct fund_long: fund_type { - fund_long (): node (path (""), 0, 0) {} + fund_long (tree tn) + : node (path (""), 0, 0), fund_type (tn) {} }; struct fund_unsigned_long: fund_type { - fund_unsigned_long (): node (path (""), 0, 0) {} + fund_unsigned_long (tree tn) + : node (path (""), 0, 0), fund_type (tn) {} }; struct fund_long_long: fund_type { - fund_long_long (): node (path (""), 0, 0) {} + fund_long_long (tree tn) + : node (path (""), 0, 0), fund_type (tn) {} }; struct fund_unsigned_long_long: fund_type { - fund_unsigned_long_long (): node (path (""), 0, 0) {} + fund_unsigned_long_long (tree tn) + : node (path (""), 0, 0), fund_type (tn) {} }; // @@ -96,17 +115,20 @@ namespace semantics struct fund_float: fund_type { - fund_float (): node (path (""), 0, 0) {} + fund_float (tree tn) + : node (path (""), 0, 0), fund_type (tn) {} }; struct fund_double: fund_type { - fund_double (): node (path (""), 0, 0) {} + fund_double (tree tn) + : node (path (""), 0, 0), fund_type (tn) {} }; struct fund_long_double: fund_type { - fund_long_double (): node (path (""), 0, 0) {} + fund_long_double (tree tn) + : node (path (""), 0, 0), fund_type (tn) {} }; } diff --git a/odb/semantics/union-template.hxx b/odb/semantics/union-template.hxx index 1aaadb7..8e74e6e 100644 --- a/odb/semantics/union-template.hxx +++ b/odb/semantics/union-template.hxx @@ -28,8 +28,11 @@ namespace semantics class union_instantiation: public union_, public type_instantiation { public: - union_instantiation (path const& file, size_t line, size_t column) - : node (file, line, column) + union_instantiation (path const& file, + size_t line, + size_t column, + tree tn) + : node (file, line, column), type (tn) { } diff --git a/odb/semantics/union.hxx b/odb/semantics/union.hxx index 2873d97..e4b93a9 100644 --- a/odb/semantics/union.hxx +++ b/odb/semantics/union.hxx @@ -13,8 +13,8 @@ namespace semantics class union_: public virtual type, public scope { public: - union_ (path const& file, size_t line, size_t column) - : node (file, line, column) + union_ (path const& file, size_t line, size_t column, tree tn) + : node (file, line, column), type (tn) { } diff --git a/odb/semantics/unit.hxx b/odb/semantics/unit.hxx index c208876..05eec7f 100644 --- a/odb/semantics/unit.hxx +++ b/odb/semantics/unit.hxx @@ -25,20 +25,20 @@ namespace semantics new_edge (*this, *this); } - // Mapping from GCC tree node to semantic graph node. + // Mapping from tree nodes to semantic graph nodes. // public: node* - find (gcc_tree key) const + find (tree key) const { - gcc_tree_node_map::const_iterator i (gcc_tree_node_map_.find (key)); - return i != gcc_tree_node_map_.end () ? i->second : 0; + tree_node_map::const_iterator i (tree_node_map_.find (key)); + return i != tree_node_map_.end () ? i->second : 0; } void - insert (gcc_tree key, node& value) + insert (tree key, node& value) { - gcc_tree_node_map_[key] = &value; + tree_node_map_[key] = &value; } public: @@ -84,9 +84,9 @@ namespace semantics // template T& - new_fund_node () + new_fund_node (tree tn) { - return graph_.new_node (); + return graph_.new_node (tn); } protected: @@ -134,8 +134,8 @@ namespace semantics private: graph& graph_; - typedef std::map gcc_tree_node_map; - gcc_tree_node_map gcc_tree_node_map_; + typedef std::map tree_node_map; + tree_node_map tree_node_map_; }; } -- cgit v1.1