abg-ir: elf_symbol: add is_in_ksymtab field

Being exported through a ksymtab (in case of Linux Kernel binaries) is
actually a property of the Elf symbol itself and we can therefore track
it along with the symbol that we collect from symtab. While tracking is
currently done by keeping separate symbol lists and maps for symtab and
ksymtab symbols, they can be consolidated having a property to indicate
whether this symbol also appeared as a ksymtab entry.

Hence, and for future changes in this area, add this property and update
all references. The flag is false initially unless otherwise specified.

	* include/abg-ir.h (elf_symbol::elf_symbol): Add is_in_ksymtab
	parameter.
	(elf_symbol::create): Likewise.
	(elf_symbol::is_in_ksymtab): New getter declaration.
	(elf_symbol::set_is_in_ksymtab): New setter declaration.
	* src/abg-ir.cc (elf_symbol::priv::priv): Add is_in_ksymtab
	parameter.
	(elf_symbol::priv::is_in_ksymtab_): New field.
	(elf_symbol::elf_symbol): Add is_in_ksymtab parameter.
	(elf_symbol::create): Likewise.
	(elf_symbol::is_in_ksymtab): New getter implementation.
	(elf_symbol::set_is_in_ksymtab): New setter implementation.

Reviewed-by: Giuliano Procida <gprocida@google.com>
Signed-off-by: Matthias Maennich <maennich@google.com>
Signed-off-by: Dodji Seketeli <dodji@redhat.com>

diff --git a/include/abg-ir.h b/include/abg-ir.h
index 521763d88b8946146dd5eda2448121144eb7d6a4..c8c8db9e884e3fc4652d5c6a58bcbdfd6185b0f9 100644 (file)
--- a/include/abg-ir.h
+++ b/include/abg-ir.h
@@ -841,8 +841,9 @@ private:
             bool               d,
             bool               c,
             const version&     ve,
-            visibility vi,
-            bool               is_linux_string_cst = false);
+            visibility         vi,
+            bool               is_linux_string_cst = false,
+            bool               is_in_ksymtab = false);
 
   elf_symbol(const elf_symbol&);
 
@@ -855,17 +856,18 @@ public:
   create();
 
   static elf_symbol_sptr
-  create(const environment*    e,
-        size_t         i,
-        size_t         s,
-        const string&          n,
-        type                   t,
-        binding                b,
-        bool                   d,
-        bool                   c,
-        const version& ve,
-        visibility             vi,
-        bool                   is_linux_string_cst = false);
+  create(const environment* e,
+        size_t             i,
+        size_t             s,
+        const string&      n,
+        type               t,
+        binding            b,
+        bool               d,
+        bool               c,
+        const version&     ve,
+        visibility         vi,
+        bool               is_linux_string_cst = false,
+        bool               is_in_ksymtab = false);
 
   const environment*
   get_environment() const;
@@ -933,6 +935,12 @@ public:
   bool
   is_variable() const;
 
+  bool
+  is_in_ksymtab() const;
+
+  void
+  set_is_in_ksymtab(bool is_in_ksymtab);
+
   const elf_symbol_sptr
   get_main_symbol() const;
 

diff --git a/src/abg-ir.cc b/src/abg-ir.cc
index 41f78d84fd785b8b303e462ea83ee46462e8760d..030541cf1f3568b4589ae4d5f38143f66439246e 100644 (file)
--- a/src/abg-ir.cc
+++ b/src/abg-ir.cc
@@ -1316,6 +1316,7 @@ struct elf_symbol::priv
   //     STT_COMMON definition of that name that has the largest size.
   bool                 is_common_;
   bool                 is_linux_string_cst_;
+  bool                 is_in_ksymtab_;
   elf_symbol_wptr      main_symbol_;
   elf_symbol_wptr      next_alias_;
   elf_symbol_wptr      next_common_instance_;
@@ -1330,20 +1331,22 @@ struct elf_symbol::priv
       visibility_(elf_symbol::DEFAULT_VISIBILITY),
       is_defined_(false),
       is_common_(false),
-      is_linux_string_cst_(false)
+      is_linux_string_cst_(false),
+      is_in_ksymtab_(false)
   {}
 
-  priv(const environment*              e,
-       size_t                          i,
-       size_t                          s,
-       const string&                   n,
-       elf_symbol::type                t,
-       elf_symbol::binding             b,
-       bool                            d,
-       bool                            c,
-       const elf_symbol::version&      ve,
-       elf_symbol::visibility          vi,
-       bool                            is_linux_string_cst)
+  priv(const environment*        e,
+       size_t                    i,
+       size_t                    s,
+       const string&             n,
+       elf_symbol::type                  t,
+       elf_symbol::binding       b,
+       bool                      d,
+       bool                      c,
+       const elf_symbol::version& ve,
+       elf_symbol::visibility    vi,
+       bool                      is_linux_string_cst,
+       bool                      is_in_ksymtab)
     : env_(e),
       index_(i),
       size_(s),
@@ -1354,7 +1357,8 @@ struct elf_symbol::priv
       visibility_(vi),
       is_defined_(d),
       is_common_(c),
-      is_linux_string_cst_(is_linux_string_cst)
+      is_linux_string_cst_(is_linux_string_cst),
+      is_in_ksymtab_(is_in_ksymtab)
   {
     if (!is_common_)
       is_common_ = type_ == COMMON_TYPE;
@@ -1400,19 +1404,30 @@ elf_symbol::elf_symbol()
 ///
 /// @param is_linux_string_cst true if the symbol is a Linux Kernel
 /// string constant defined in the __ksymtab_strings section.
-elf_symbol::elf_symbol(const environment*      e,
-                      size_t                   i,
-                      size_t                   s,
-                      const string&            n,
-                      type                     t,
-                      binding                  b,
-                      bool                     d,
-                      bool                     c,
-                      const version&           ve,
-                      visibility               vi,
-                      bool                     is_linux_string_cst)
-  : priv_(new priv(e, i, s, n, t, b, d,
-                  c, ve, vi, is_linux_string_cst))
+elf_symbol::elf_symbol(const environment* e,
+                      size_t             i,
+                      size_t             s,
+                      const string&      n,
+                      type               t,
+                      binding            b,
+                      bool               d,
+                      bool               c,
+                      const version&     ve,
+                      visibility         vi,
+                      bool               is_linux_string_cst,
+                      bool               is_in_ksymtab)
+  : priv_(new priv(e,
+                  i,
+                  s,
+                  n,
+                  t,
+                  b,
+                  d,
+                  c,
+                  ve,
+                  vi,
+                  is_linux_string_cst,
+                  is_in_ksymtab))
 {}
 
 /// Factory of instances of @ref elf_symbol.
@@ -1459,20 +1474,22 @@ elf_symbol::create()
 /// @return a (smart) pointer to a newly created instance of @ref
 /// elf_symbol.
 elf_symbol_sptr
-elf_symbol::create(const environment*  e,
-                  size_t               i,
-                  size_t               s,
-                  const string&        n,
-                  type         t,
-                  binding              b,
-                  bool         d,
-                  bool         c,
-                  const version&       ve,
-                  visibility           vi,
-                  bool         is_linux_string_cst)
-{
-  elf_symbol_sptr sym(new elf_symbol(e, i, s, n, t, b, d, c, ve,
-                                    vi, is_linux_string_cst));
+elf_symbol::create(const environment* e,
+                  size_t             i,
+                  size_t             s,
+                  const string&      n,
+                  type               t,
+                  binding            b,
+                  bool               d,
+                  bool               c,
+                  const version&     ve,
+                  visibility         vi,
+                  bool               is_linux_string_cst,
+                  bool               is_in_ksymtab)
+{
+  elf_symbol_sptr sym(new elf_symbol(e, i, s, n, t, b, d, c, ve, vi,
+                                    is_linux_string_cst,
+                                    is_in_ksymtab));
   sym->priv_->main_symbol_ = sym;
   return sym;
 }
@@ -1692,6 +1709,22 @@ bool
 elf_symbol::is_variable() const
 {return get_type() == OBJECT_TYPE || get_type() == TLS_TYPE;}
 
+/// Getter of the 'is-in-ksymtab' property.
+///
+/// @return true iff the current symbol is in the Linux Kernel
+/// specific 'ksymtab' symbol table.
+bool
+elf_symbol::is_in_ksymtab() const
+{return priv_->is_in_ksymtab_;}
+
+/// Setter of the 'is-in-ksymtab' property.
+///
+/// @p is_in_ksymtab this is true iff the current symbol is in the
+/// Linux Kernel specific 'ksymtab' symbol table.
+void
+elf_symbol::set_is_in_ksymtab(bool is_in_ksymtab)
+{priv_->is_in_ksymtab_ = is_in_ksymtab;}
+
 /// @name Elf symbol aliases
 ///
 /// An alias A for an elf symbol S is a symbol that is defined at the