2006-08-28 David Smith <dsmith@redhat.com>

	* translate.cxx: Added inclusion of session.h.
	(translate_pass): Instead of asking each probe to emit itself, we
	ask the session's probes member variable to emit all the probes.
	* tapsets.cxx: Added inclusion of session.h.  Added a
	register_probe member function to all derived_probe based
	classes.  Added a derived_probe_group derived class for all probe
	types:
	(be_derived_probe_group): New class.
	(never_derived_probe_group): New class.
	(dwarf_derived_probe_group): New class.
	(timer_derived_probe_group): New class.
	(profile_derived_probe_group): New class.
	(mark_derived_probe_group): New class.
	(hrtimer_derived_probe_group): New class
	(derived_probe_group_container): New class.
	* elaborate.h: Removed inclusion of session.h since session.h now
	includes elaborate.h.
	(derived_probe): Added register_probe member function.
	(derived_probe_group): Added class definition.  This is the base
	class of all of the derived probe groups - dwarf, timer, etc.
	(derived_probe_group_container): Added class definition.  An
	instance of this class will be stored in the session and contain
	all the other probe groups.
	* elaborate.cxx (derived_probe_group::register_probe): Added
	derived_probe_group::register_probe stubs.
	(alias_derived_probe::register_probe): Added register_probe member
	function.
	(semantic_pass_symbols): After deriving a probe, the probes now
	register themselves with the session.
	* session.h: Includes elaborate.h to get
	derived_probe_group_container definition. systemtap_session class
	'probes' member variable switched from a vector of derived probes
	to a derived_probe_group_container.
	* buildrun.cxx: Added inclusion of session.h since it was removed
	from elaborate.h.
	* main.cxx: Added inclusion of session.h since it was removed
	from elaborate.h.
	* parse.h: Added forward struct declarations.
	* staptree.h: Removed inclusion of session.h.

1 files changed, 342 insertions, 0 deletions

diff --git a/tapsets.cxx b/tapsets.cxx
index 2aa5e1b7..1d491cc2 100644
--- a/tapsets.cxx
+++ b/tapsets.cxx
@@ -12,6 +12,7 @@
 #include "elaborate.h"
 #include "tapsets.h"
 #include "translate.h"
+#include "session.h"
 
 #include <deque>
 #include <iostream>
@@ -198,12 +199,27 @@ struct be_derived_probe: public derived_probe
   be_derived_probe (probe* p, probe_point* l, bool b):
     derived_probe (p, l), begin (b) {}
 
+  void register_probe (systemtap_session& s);
+
   void emit_registrations (translator_output* o);
   void emit_deregistrations (translator_output* o);
   void emit_probe_entries (translator_output* o);
 };
 
 
+struct be_derived_probe_group: public derived_probe_group
+{
+private:
+  vector<be_derived_probe*> probes;
+
+public:
+  virtual void register_probe(be_derived_probe* p) { probes.push_back (p); }
+  virtual size_t size () { return probes.size (); }
+
+  virtual void emit_probes (translator_output* op, unparser* up);
+};
+
+
 struct be_builder: public derived_probe_builder
 {
   bool begin;
@@ -220,6 +236,13 @@ struct be_builder: public derived_probe_builder
 
 
 void
+be_derived_probe::register_probe(systemtap_session& s)
+{
+  s.probes.register_probe(this);
+}
+
+
+void
 be_derived_probe::emit_registrations (translator_output* o)
 {
   if (begin)
@@ -270,6 +293,17 @@ be_derived_probe::emit_probe_entries (translator_output* o)
 }
 
 
+void
+be_derived_probe_group::emit_probes (translator_output* op, unparser* up)
+{
+  for (unsigned i=0; i < probes.size(); i++)
+    {
+      op->newline ();
+      up->emit_probe (probes[i]);
+    }
+}
+
+
 // ------------------------------------------------------------------------
 // never probes are never run
 // ------------------------------------------------------------------------
@@ -279,12 +313,34 @@ struct never_derived_probe: public derived_probe
   never_derived_probe (probe* p): derived_probe (p) {}
   never_derived_probe (probe* p, probe_point* l): derived_probe (p, l) {}
 
+  void register_probe (systemtap_session& s);
+
   void emit_registrations (translator_output* o);
   void emit_deregistrations (translator_output* o);
   void emit_probe_entries (translator_output* o);
 };
 
 
+struct never_derived_probe_group: public derived_probe_group
+{
+private:
+  vector<never_derived_probe*> probes;
+
+public:
+  virtual void register_probe(never_derived_probe* p) { probes.push_back (p); }
+  virtual size_t size () { return probes.size (); }
+
+  virtual void emit_probes (translator_output* op, unparser* up);
+};
+
+
+void
+never_derived_probe::register_probe(systemtap_session& s)
+{
+  s.probes.register_probe(this);
+}
+
+
 struct never_builder: public derived_probe_builder
 {
   never_builder() {}
@@ -317,6 +373,15 @@ never_derived_probe::emit_probe_entries (translator_output* o)
 }
 
 
+void
+never_derived_probe_group::emit_probes (translator_output* op, unparser* up)
+{
+  for (unsigned i=0; i < probes.size(); i++)
+    {
+      op->newline ();
+      up->emit_probe (probes[i]);
+    }
+}
 
 // ------------------------------------------------------------------------
 //  Dwarf derived probes.
@@ -1718,6 +1783,8 @@ struct dwarf_derived_probe : public derived_probe
   vector<Dwarf_Addr> probe_points;
   bool has_return;
 
+  void register_probe (systemtap_session& s);
+
   void add_probe_point(string const & funcname,
 		       char const * filename,
 		       int line,
@@ -1742,6 +1809,20 @@ struct dwarf_derived_probe : public derived_probe
   virtual void emit_probe_entries (translator_output * o);
 };
 
+
+struct dwarf_derived_probe_group: public derived_probe_group
+{
+private:
+  vector<dwarf_derived_probe*> probes;
+
+public:
+  virtual void register_probe(dwarf_derived_probe* p) { probes.push_back (p); }
+  virtual size_t size () { return probes.size (); }
+
+  virtual void emit_probes (translator_output* op, unparser* up);
+};
+
+
 // Helper struct to thread through the dwfl callbacks.
 struct
 dwarf_query
@@ -2939,6 +3020,13 @@ dwarf_var_expanding_copy_visitor::visit_target_symbol (target_symbol *e)
 
 
 void
+dwarf_derived_probe::register_probe(systemtap_session& s)
+{
+  s.probes.register_probe(this);
+}
+
+
+void
 dwarf_derived_probe::add_probe_point(string const & funcname,
 				     char const * filename,
 				     int line,
@@ -3375,6 +3463,17 @@ dwarf_derived_probe::emit_probe_entries (translator_output* o)
 
 
 void
+dwarf_derived_probe_group::emit_probes (translator_output* op, unparser* up)
+{
+  for (unsigned i=0; i < probes.size(); i++)
+    {
+      op->newline ();
+      up->emit_probe (probes[i]);
+    }
+}
+
+
+void
 dwarf_builder::build(systemtap_session & sess,
 		     probe * base,
 		     probe_point * location,
@@ -3464,6 +3563,8 @@ struct timer_derived_probe: public derived_probe
 
   timer_derived_probe (probe* p, probe_point* l, int64_t i, int64_t r, bool ms=false);
 
+  virtual void register_probe (systemtap_session& s);
+
   virtual void emit_registrations (translator_output * o);
   virtual void emit_deregistrations (translator_output * o);
   virtual void emit_probe_entries (translator_output * o);
@@ -3486,6 +3587,13 @@ timer_derived_probe::timer_derived_probe (probe* p, probe_point* l, int64_t i, i
 
 
 void
+timer_derived_probe::register_probe(systemtap_session& s)
+{
+  s.probes.register_probe(this);
+}
+
+
+void
 timer_derived_probe::emit_registrations (translator_output* o)
 {
   o->newline() << "init_timer (& timer_" << name << ");";
@@ -3540,6 +3648,30 @@ timer_derived_probe::emit_probe_entries (translator_output* o)
 }
 
 
+struct timer_derived_probe_group: public derived_probe_group
+{
+private:
+  vector<timer_derived_probe*> probes;
+
+public:
+  virtual void register_probe(timer_derived_probe* p) { probes.push_back (p); }
+  virtual size_t size () { return probes.size (); }
+
+  virtual void emit_probes (translator_output* op, unparser* up);
+};
+
+
+void
+timer_derived_probe_group::emit_probes (translator_output* op, unparser* up)
+{
+  for (unsigned i=0; i < probes.size(); i++)
+    {
+      op->newline ();
+      up->emit_probe (probes[i]);
+    }
+}
+
+
 struct timer_builder: public derived_probe_builder
 {
   bool time_is_msecs;
@@ -3581,6 +3713,8 @@ struct profile_derived_probe: public derived_probe
 
   profile_derived_probe (systemtap_session &s, probe* p, probe_point* l);
 
+  void register_probe (systemtap_session& s);
+
   virtual void emit_registrations (translator_output * o);
   virtual void emit_deregistrations (translator_output * o);
   virtual void emit_probe_entries (translator_output * o);
@@ -3604,6 +3738,13 @@ profile_derived_probe::profile_derived_probe (systemtap_session &s, probe* p, pr
 
 
 void
+profile_derived_probe::register_probe(systemtap_session& s)
+{
+  s.probes.register_probe(this);
+}
+
+
+void
 profile_derived_probe::emit_registrations (translator_output* o)
 {
   if (using_rpn)
@@ -3660,6 +3801,31 @@ profile_derived_probe::emit_probe_entries (translator_output* o)
 }
 
 
+struct profile_derived_probe_group: public derived_probe_group
+{
+private:
+  vector<profile_derived_probe*> probes;
+
+public:
+  virtual void register_probe(profile_derived_probe* p) {
+    probes.push_back (p); }
+  virtual size_t size () { return probes.size (); }
+
+  virtual void emit_probes (translator_output* op, unparser* up);
+};
+
+
+void
+profile_derived_probe_group::emit_probes (translator_output* op, unparser* up)
+{
+  for (unsigned i=0; i < probes.size(); i++)
+    {
+      op->newline ();
+      up->emit_probe (probes[i]);
+    }
+}
+
+
 struct profile_builder: public derived_probe_builder
 {
   profile_builder() {}
@@ -3692,6 +3858,8 @@ struct mark_derived_probe: public derived_probe
   string module;
   string probe_sig_expanded;
 
+  void register_probe (systemtap_session& s);
+
   void emit_registrations (translator_output * o);
   void emit_deregistrations (translator_output * o);
   void emit_probe_entries (translator_output * o);
@@ -3809,6 +3977,13 @@ mark_derived_probe::mark_derived_probe (systemtap_session &s,
 
 
 void
+mark_derived_probe::register_probe(systemtap_session& s)
+{
+  s.probes.register_probe(this);
+}
+
+
+void
 mark_derived_probe::emit_probe_context_vars (translator_output* o)
 {
   // Save incoming arguments
@@ -3904,6 +4079,29 @@ mark_derived_probe::emit_deregistrations (translator_output * o)
 }
 
 
+struct mark_derived_probe_group: public derived_probe_group
+{
+private:
+  vector<mark_derived_probe*> probes;
+
+public:
+  virtual void register_probe(mark_derived_probe* p) { probes.push_back (p); }
+  virtual size_t size () { return probes.size (); }
+
+  virtual void emit_probes (translator_output* op, unparser* up);
+};
+
+
+void
+mark_derived_probe_group::emit_probes (translator_output* op, unparser* up)
+{
+  for (unsigned i=0; i < probes.size(); i++)
+    {
+      op->newline ();
+      up->emit_probe (probes[i]);
+    }
+}
+
 
 struct symboltable_extract
 {
@@ -4114,6 +4312,8 @@ struct hrtimer_derived_probe: public derived_probe
     // so we don't have to loop over them in the other functions
   }
 
+  void register_probe (systemtap_session& s);
+
   virtual void emit_interval (translator_output * o);
 
   virtual void emit_registrations (translator_output * o);
@@ -4123,6 +4323,13 @@ struct hrtimer_derived_probe: public derived_probe
 
 
 void
+hrtimer_derived_probe::register_probe(systemtap_session& s)
+{
+  s.probes.register_probe(this);
+}
+
+
+void
 hrtimer_derived_probe::emit_interval (translator_output* o)
 {
   o->line() << "({";
@@ -4194,6 +4401,30 @@ hrtimer_derived_probe::emit_probe_entries (translator_output* o)
 }
 
 
+struct hrtimer_derived_probe_group: public derived_probe_group
+{
+private:
+  vector<hrtimer_derived_probe*> probes;
+
+public:
+  virtual void register_probe(hrtimer_derived_probe* p) { probes.push_back (p); }
+  virtual size_t size () { return probes.size (); }
+
+  virtual void emit_probes (translator_output* op, unparser* up);
+};
+
+
+void
+hrtimer_derived_probe_group::emit_probes (translator_output* op, unparser* up)
+{
+  for (unsigned i=0; i < probes.size(); i++)
+    {
+      op->newline ();
+      up->emit_probe (probes[i]);
+    }
+}
+
+
 struct hrtimer_builder: public derived_probe_builder
 {
   hrtimer_builder() {}
@@ -4348,3 +4579,114 @@ register_standard_tapsets(systemtap_session & s)
   s.pattern_root->bind("kernel")->bind_str("mark")->bind(new mark_builder());
   s.pattern_root->bind_str("module")->bind_str("mark")->bind(new mark_builder());
 }
+
+
+derived_probe_group_container::derived_probe_group_container ():
+  be_probe_group(new be_derived_probe_group),
+  dwarf_probe_group(new dwarf_derived_probe_group),
+  hrtimer_probe_group(new hrtimer_derived_probe_group),
+  mark_probe_group(new mark_derived_probe_group),
+  never_probe_group(new never_derived_probe_group),
+  profile_probe_group(new profile_derived_probe_group),
+  timer_probe_group(new timer_derived_probe_group)
+{
+}
+
+
+derived_probe_group_container::~derived_probe_group_container ()
+{
+  delete be_probe_group;
+  delete dwarf_probe_group;
+  delete hrtimer_probe_group;
+  delete mark_probe_group;
+  delete never_probe_group;
+  delete profile_probe_group;
+  delete timer_probe_group;
+}
+
+
+void
+derived_probe_group_container::register_probe(be_derived_probe* p)
+{
+  probes.push_back (p);
+  be_probe_group->register_probe(p);
+}
+
+
+void
+derived_probe_group_container::register_probe(dwarf_derived_probe* p)
+{
+  probes.push_back (p);
+  dwarf_probe_group->register_probe(p);
+}
+
+
+void
+derived_probe_group_container::register_probe(hrtimer_derived_probe* p)
+{
+  probes.push_back (p);
+  hrtimer_probe_group->register_probe(p);
+}
+
+
+void
+derived_probe_group_container::register_probe(mark_derived_probe* p)
+{
+  probes.push_back (p);
+  mark_probe_group->register_probe(p);
+}
+
+
+void
+derived_probe_group_container::register_probe(never_derived_probe* p)
+{
+  probes.push_back (p);
+  never_probe_group->register_probe(p);
+}
+
+
+void
+derived_probe_group_container::register_probe(profile_derived_probe* p)
+{
+  probes.push_back (p);
+  profile_probe_group->register_probe(p);
+}
+
+
+void
+derived_probe_group_container::register_probe(timer_derived_probe* p)
+{
+  probes.push_back (p);
+  timer_probe_group->register_probe(p);
+}
+
+
+void
+derived_probe_group_container::emit_probes (translator_output* op,
+					    unparser* up)
+{
+  // Sanity check.
+  size_t groups_size = be_probe_group->size ()
+      + dwarf_probe_group->size ()
+      + hrtimer_probe_group->size ()
+      + mark_probe_group->size ()
+      + never_probe_group->size ()
+      + profile_probe_group->size ()
+      + timer_probe_group->size ();
+  if (probes.size () != groups_size)
+    {
+      cerr << "There are " << probes.size () << " total probes, and "
+	   << groups_size << " grouped probes\n";
+
+      throw runtime_error("internal probe mismatch");
+    }
+
+  // Let each probe group emit its probes.
+  be_probe_group->emit_probes (op, up);
+  dwarf_probe_group->emit_probes (op, up);
+  hrtimer_probe_group->emit_probes (op, up);
+  mark_probe_group->emit_probes (op, up);
+  never_probe_group->emit_probes (op, up);
+  profile_probe_group->emit_probes (op, up);
+  timer_probe_group->emit_probes (op, up);
+}