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.

1 files changed, 11 insertions, 2 deletions

diff --git a/dwflpp.cxx b/dwflpp.cxx
index 090aa70a..6ede1d68 100644
--- a/dwflpp.cxx
+++ b/dwflpp.cxx
@@ -1731,7 +1731,8 @@ dwflpp::translate_components(struct obstack *pool,
 
         case DW_TAG_pointer_type:
           c_translate_pointer (pool, 1, 0 /* PR9768*/, die, tail);
-          if (c.type != target_symbol::comp_literal_array_index)
+          if (c.type != target_symbol::comp_literal_array_index &&
+              c.type != target_symbol::comp_expression_array_index)
             break;
           /* else fall through as an array access */
 
@@ -1742,6 +1743,13 @@ dwflpp::translate_components(struct obstack *pool,
                                  NULL, c.num_index);
               ++i;
             }
+          else if (c.type == target_symbol::comp_expression_array_index)
+            {
+              string index = "THIS->index" + lex_cast<string>(i);
+              c_translate_array (pool, 1, 0 /* PR9768 */, die, tail,
+                                 index.c_str(), 0);
+              ++i;
+            }
           else
             throw semantic_error ("invalid access '"
                                   + lex_cast<string>(c)
@@ -1824,7 +1832,8 @@ dwflpp::translate_components(struct obstack *pool,
     }
 
   /* For an array index, we need to dereference the final DIE */
-  if (e->components.back().type == target_symbol::comp_literal_array_index)
+  if (e->components.back().type == target_symbol::comp_literal_array_index ||
+      e->components.back().type == target_symbol::comp_expression_array_index)
     die = dwarf_formref_die (attr_mem, die_mem);
 
   return die;