From 6fda2dff51c667a8c73545dd397b844108715310 Mon Sep 17 00:00:00 2001
From: Josh Stone <jistone@redhat.com>
Date: Mon, 3 Aug 2009 14:45:21 -0700
Subject: PR2049: support arbitrary $target-array indexing

Rather than just numeric literals, we can now support arbitrary
expressions for the index value.  Note that loc2c won't allow this for
noncontiguous arrays, as the access methods need to be statically
computed, but for contiguous arrays and pointers-as-arrays it works
just fine.

* staptree.h (target_symbol::component): Add expression_array_index.
* staptree.cxx (target_symbol::visit_components): New helper.
  (target_symbol::assert_no_components): Recognize new array type.
  (target_symbol::component::print): Print subexpressions.
  (traversing_visitor::visit_target_symbol, visit_cast_op): Visit the
  indexing components too.
  (varuse_collecting_visitor::visit_target_symbol): Ditto.
  (update_visitor::visit_target_symbol, visit_cast_op): Ditto.
* elaborate.cxx (void_statement_reducer::visit_target_symbol): New.
  (void_statement_reducer::visit_cast_op): Save indexes too.
* parse.cxx (parser::parse_target_symbol_components): Parse expressions.
* tapsets.cxx (dwarf_var_expanding_visitor::visit_target_symbol): Pass
  expression-indexes as parameters (indexN) to the dwarf function.
  (dwarf_cast_expanding_visitor::visit_cast_op): Ditto.
  (tracepoint_var_expanding_visitor::visit_target_symbol_arg): Ditto.
  (sdt_var_expanding_visitor::visit_target_symbol): Visit the new @cast.
* dwflpp.cxx (dwflpp::translate_components): Use THIS->indexN.
* translate.cxx (c_unparser::visit_target_symbol): Correct error msg.
* testsuite/systemtap.base/pointer_array.stp: Use a simple index.
---
 elaborate.cxx | 62 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 60 insertions(+), 2 deletions(-)

(limited to 'elaborate.cxx')

diff --git a/elaborate.cxx b/elaborate.cxx
index fafc5e63..d1ebe326 100644
--- a/elaborate.cxx
+++ b/elaborate.cxx
@@ -2534,6 +2534,7 @@ struct void_statement_reducer: public update_visitor
   void visit_concatenation (concatenation* e);
   void visit_functioncall (functioncall* e);
   void visit_print_format (print_format* e);
+  void visit_target_symbol (target_symbol* e);
   void visit_cast_op (cast_op* e);
 
   // these are a bit hairy to grok due to the intricacies of indexables and
@@ -2802,17 +2803,74 @@ void_statement_reducer::visit_print_format (print_format* e)
   provide (e);
 }
 
+void
+void_statement_reducer::visit_target_symbol (target_symbol* e)
+{
+  // When target_symbol isn't needed, it's just as good to
+  // evaluate any array indexes directly
+
+  block *b = new block;
+  b->tok = e->tok;
+
+  for (unsigned i=0; i<e->components.size(); i++ )
+    {
+      if (e->components[i].type != target_symbol::comp_expression_array_index)
+        continue;
+
+      expr_statement *es = new expr_statement;
+      es->value = e->components[i].expr_index;
+      es->tok = es->value->tok;
+      b->statements.push_back(es);
+    }
+
+  if (b->statements.empty())
+    {
+      delete b;
+      provide (e);
+      return;
+    }
+
+  if (session.verbose>2)
+    clog << "Eliding unused target symbol " << *e->tok << endl;
+
+  b->visit(this);
+  relaxed_p = false;
+  e = 0;
+  provide (e);
+}
+
 void
 void_statement_reducer::visit_cast_op (cast_op* e)
 {
   // When the result of a cast operation isn't needed, it's just as good to
-  // evaluate the operand directly
+  // evaluate the operand and any array indexes directly
+
+  block *b = new block;
+  b->tok = e->tok;
+
+  expr_statement *es = new expr_statement;
+  es->value = e->operand;
+  es->tok = es->value->tok;
+  b->statements.push_back(es);
+
+  for (unsigned i=0; i<e->components.size(); i++ )
+    {
+      if (e->components[i].type != target_symbol::comp_expression_array_index)
+        continue;
+
+      es = new expr_statement;
+      es->value = e->components[i].expr_index;
+      es->tok = es->value->tok;
+      b->statements.push_back(es);
+    }
 
   if (session.verbose>2)
     clog << "Eliding unused typecast " << *e->tok << endl;
 
+  b->visit(this);
   relaxed_p = false;
-  e->operand->visit(this);
+  e = 0;
+  provide (e);
 }
 
 
-- 
cgit