From f2339483ab00eff7a1a45c33b968891a63668c98 Mon Sep 17 00:00:00 2001

From: Serhei Makarov <smakarov@redhat.com>

Date: Tue, 16 Oct 2018 18:16:48 -0400

Subject: [PATCH 05/32] stapbpf assembler WIP #4 :: alloc and (helper) call

 operations

---

 bpf-base.cxx       |  46 ++++++----

 bpf-internal.h     |   8 +-

 bpf-translate.cxx  | 259 ++++++++++++++++++++++++++++++++++++++++-------------

 tapset/logging.stp |   2 +

 4 files changed, 237 insertions(+), 78 deletions(-)

diff --git a/bpf-base.cxx b/bpf-base.cxx

index c3e36efa1..277927b72 100644

--- a/bpf-base.cxx

+++ b/bpf-base.cxx

@@ -135,31 +135,43 @@ is_commutative(opcode code)

     }

 }

+/* Various functions for eBPF helper lookup: */

+

+std::map<unsigned, const char *> bpf_func_name_map;

+std::map<std::string, bpf_func_id> bpf_func_id_map;

+

+void

+init_bpf_helper_tables () // TODO call before script translation

+{

+#define __BPF_SET_FUNC_NAME(x) bpf_func_name_map[BPF_FUNC_ ## x] = #x

+#define __BPF_SET_FUNC_ID(x) bpf_func_id_map[#x] = BPF_FUNC_ ## x

+  __BPF_FUNC_MAPPER(__BPF_SET_FUNC_NAME)

+  __STAPBPF_FUNC_MAPPER(__BPF_SET_FUNC_NAME)

+  __BPF_FUNC_MAPPER(__BPF_SET_FUNC_ID)

+  __STAPBPF_FUNC_MAPPER(__BPF_SET_FUNC_ID)

+  (void)0;

+}

+

 const char *

 bpf_function_name (unsigned id)

 {

-  switch (id)

-    {

-    case BPF_FUNC_map_lookup_elem:	return "map_lookup_elem";

-    case BPF_FUNC_map_update_elem:	return "map_update_elem";

-    case BPF_FUNC_map_delete_elem:	return "map_delete_elem";

-    case BPF_FUNC_probe_read:		return "probe_read";

-    case BPF_FUNC_ktime_get_ns:		return "ktime_get_ns";

-    case BPF_FUNC_trace_printk:		return "trace_printk";

-    case BPF_FUNC_get_prandom_u32:	return "get_prandom_u32";

-    case BPF_FUNC_get_smp_processor_id:	return "get_smp_processor_id";

-    case BPF_FUNC_get_current_pid_tgid:	return "get_current_pid_tgid";

-    case BPF_FUNC_get_current_uid_gid:	return "get_current_uid_gid";

-    case BPF_FUNC_get_current_comm:	return "get_current_comm";

-    case BPF_FUNC_perf_event_read:	return "perf_event_read";

-    case BPF_FUNC_perf_event_output:	return "perf_event_output";

-    default:				return NULL;

-    }

+  if (bpf_func_name_map.count(id) != 0)

+    return bpf_func_name_map[id];

+  return NULL;

+}

+

+bpf_func_id

+bpf_function_id (const std::string& name)

+{

+  if (bpf_func_id_map.count(name) != 0)

+    return bpf_func_id_map[name];

+  return __BPF_FUNC_MAX_ID;

 }

 unsigned

 bpf_function_nargs (unsigned id)

 {

+  // ??? generalize to all bpf functions

   switch (id)

     {

     case BPF_FUNC_map_lookup_elem:	return 2;

diff --git a/bpf-internal.h b/bpf-internal.h

index 719446db8..61514db9f 100644

--- a/bpf-internal.h

+++ b/bpf-internal.h

@@ -96,14 +96,20 @@ bool is_move(opcode c);

 bool is_ldst(opcode c);

 bool is_binary(opcode c);

 bool is_commutative(opcode c);

+

+void init_bpf_helper_tables();

 const char *bpf_function_name (unsigned id);

+bpf_func_id bpf_function_id (const std::string &name);

 unsigned bpf_function_nargs (unsigned id);

 const opcode BPF_LD_MAP = BPF_LD | BPF_IMM | BPF_DW | (BPF_PSEUDO_MAP_FD << 8);

-// Not actual BPF helpers, but treating them like one simplifies some of the

+// Not actual BPF helpers, but treating them as such simplifies some of the

 // interpreter logic. We give them IDs that shouldn't conflict with IDs of

 // real BPF helpers.

+#define __STAPBPF_FUNC_MAPPER(FN) \

+  FN(map_get_next_key),           \

+  FN(sprintf),

 const bpf_func_id BPF_FUNC_map_get_next_key    = (bpf_func_id) -1;

 const bpf_func_id BPF_FUNC_sprintf             = (bpf_func_id) -2;

diff --git a/bpf-translate.cxx b/bpf-translate.cxx

index 023ac6ce7..af3f54b50 100644

--- a/bpf-translate.cxx

+++ b/bpf-translate.cxx

@@ -179,7 +179,7 @@ struct bpf_unparser : public throwing_visitor

   // TODO General triage of bpf-possible functionality:

   virtual void visit_block (::block *s);

   // TODO visit_try_block -> UNHANDLED

-  virtual void visit_embeddedcode (embeddedcode *s); // TODO need to find testcase/example for this

+  virtual void visit_embeddedcode (embeddedcode *s);

   virtual void visit_null_statement (null_statement *s);

   virtual void visit_expr_statement (expr_statement *s);

   virtual void visit_if_statement (if_statement* s);

@@ -192,7 +192,7 @@ struct bpf_unparser : public throwing_visitor

   virtual void visit_continue_statement (continue_statement* s);

   virtual void visit_literal_string (literal_string *e);

   virtual void visit_literal_number (literal_number* e);

-  // TODO visit_embedded_expr -> UNHANDLED, could be handled like embedded_code with a return value?

+  // TODO visit_embedded_expr -> UNHANDLED, could treat as embedded_code

   virtual void visit_binary_expression (binary_expression* e);

   virtual void visit_unary_expression (unary_expression* e);

   virtual void visit_pre_crement (pre_crement* e);

@@ -200,7 +200,7 @@ struct bpf_unparser : public throwing_visitor

   virtual void visit_logical_or_expr (logical_or_expr* e);

   virtual void visit_logical_and_expr (logical_and_expr* e);

   virtual void visit_array_in (array_in* e);

-  // ??? visit_regex_query is UNHANDLED, requires adding new kernel functionality.

+  // ??? visit_regex_query -> UNHANDLED, requires new kernel functionality

   virtual void visit_compound_expression (compound_expression *e);

   virtual void visit_comparison (comparison* e);

   // TODO visit_concatenation -> (2) pseudo-LOOP: copy the strings while concatenating

@@ -239,14 +239,21 @@ struct bpf_unparser : public throwing_visitor

   value *emit_context_var(bpf_context_vardecl *v);

   // Used for the embedded-code assembler:

+  int64_t parse_imm (const asm_stmt &stmt, const std::string &str);

   size_t parse_asm_stmt (embeddedcode *s, size_t start,

                            /*OUT*/asm_stmt &stmt);

-  value *emit_asm_arg(const asm_stmt &stmt, const std::string &reg,

-                      bool allow_imm = true);

+  value *emit_asm_arg(const asm_stmt &stmt, const std::string &arg,

+                      bool allow_imm = true, bool allow_emit = true);

   value *emit_asm_reg(const asm_stmt &stmt, const std::string ®);

+  value *get_asm_reg(const asm_stmt &stmt, const std::string ®);

   void emit_asm_opcode(const asm_stmt &stmt,

                        std::map<std::string, block *> label_map);

+  // Used for the embedded-code assembler's diagnostics:

+  source_loc adjusted_loc;

+  size_t adjust_pos;

+  std::vector<token *> adjusted_toks; // track for deallocation

+

   // Used for string data:

   value *emit_literal_string(const std::string &str, const token *tok);

   value *emit_string_copy(value *dest, int ofs, value *src, bool zero_pad = false);

@@ -580,17 +587,22 @@ bpf_unparser::visit_block (::block *s)

    Ahh for the days of 1960s FORTRAN.

-   TODO: It might make more sense to implement an assembler based on

+   ??? It might make more sense to implement an assembler based on

    the syntax used in official eBPF subsystem docs. */

-/* Possible assembly statement types include:

+/* Supported assembly statement types include:

    <stmt> ::= label, <dest=label>;

+   <stmt> ::= alloc, <dest=reg>, <imm=imm>;

+   <stmt> ::= call, <dest=reg>, <param[0]=function name>, <param[1]=arg>, ...;

+   <stmt> ::= printf, <param[0]=string constant>, <param[1]=arg>, ...;

+   <stmt> ::= error, <param[0]=string constant>, <param[1]=arg>, ...;

    <stmt> ::= <code=integer opcode>, <dest=reg>, <src1=reg>,

               <off/jmp_target=off>, <imm=imm>;

-   Possible argument types include:

+   Supported argument types include:

+   <arg> ::= <reg> | <imm>

    <reg> ::= <register index> | r<register index> |

              $<identifier> | $<integer constant> | $$ | <string constant>

    <imm> ::= <integer constant> | BPF_MAXSTRINGLEN

@@ -598,6 +610,9 @@ bpf_unparser::visit_block (::block *s)

 */

+// TODO

+#define BPF_ASM_DEBUG

+

 struct asm_stmt {

   std::string kind;

@@ -609,9 +624,10 @@ struct asm_stmt {

   bool has_fallthrough = false;

   std::string jmp_target, fallthrough;

+  // metadata for call, error instructions

+  std::vector<std::string> params;

+

   token *tok;

-  bool deallocate_tok = false;

-  ~asm_stmt() { if (deallocate_tok) delete tok; }

 };

 std::ostream&

@@ -647,10 +663,30 @@ is_numeric (const std::string &str)

     stol(str, &pos, 0);

   } catch (std::invalid_argument &e) {

     return false;

+  } catch (std::out_of_range &e) {

+    /* XXX: probably numeric but not valid; give up */

+    return false;

   }

   return (pos == str.size());

 }

+int64_t

+bpf_unparser::parse_imm (const asm_stmt &stmt, const std::string &str)

+{

+  int64_t val;

+  if (str == "BPF_MAXSTRINGLEN")

+    val = BPF_MAXSTRINGLEN;

+  else if (str == "-")

+    val = 0;

+  else try {

+      val = stol(str);

+    } catch (std::exception &e) { // XXX: invalid_argument, out_of_range

+      throw SEMANTIC_ERROR (_F("invalid bpf embeddedcode operand '%s'",

+                               str.c_str()), stmt.tok);

+    }

+  return val;

+}

+

 /* Parse an assembly statement starting from position start in code,

    then write the output in stmt. Returns a position immediately after

    the parsed statement. */

@@ -663,31 +699,14 @@ bpf_unparser::parse_asm_stmt (embeddedcode *s, size_t start,

  retry:

   std::vector<std::string> args;

   unsigned n = code.size();

+  size_t pos;

   bool in_comment = false;

   bool in_string = false;

-  // compute token with adjusted source location for diagnostics

-  source_loc adjusted_loc; // TODO: ought to create a proper copy constructor for source_loc

-  adjusted_loc.file = s->tok->location.file;

-  adjusted_loc.line = s->tok->location.line;

-  adjusted_loc.column = s->tok->location.column;

-  for (size_t pos = 0; pos < start && pos < n; pos++)

-    {

-      // TODO: should save adjusted_loc state between parse_asm_stmt invocations; add field?

-      char c = code[pos];

-      if (c == '\n')

-        {

-          adjusted_loc.line++;

-          adjusted_loc.column = 1;

-        }

-      else

-        adjusted_loc.column++;

-    }

-

-  // TODO: As before, parser is extremely non-rigorous and could do

+  // ??? As before, parser is extremely non-rigorous and could do

   // with some tightening in terms of the inputs it accepts.

-  size_t pos;

   std::string arg = "";

+  size_t save_start = start; // -- position for diagnostics

   for (pos = start; pos < n; pos++)

   {

     char c = code[pos];

@@ -714,6 +733,9 @@ bpf_unparser::parse_asm_stmt (embeddedcode *s, size_t start,

       ++pos, in_comment = true;

     else if (c == '"') // found a literal string

       {

+        if (arg.empty() && args.empty())

+          save_start = pos; // start of first argument

+

         // XXX: This allows '"' inside an arg and will treat the

         // string as a sequence of weird identifier characters.  A

         // more rigorous parser would error on mixing strings and

@@ -738,6 +760,9 @@ bpf_unparser::parse_asm_stmt (embeddedcode *s, size_t start,

       }

     else // found (we assume) a regular char

       {

+        if (arg.empty() && args.empty())

+          save_start = pos; // start of first argument

+

         // XXX: As before, this strips whitespace within args

         // (so '$ab', '$ a b' and '$a b' are equivalent).

         //

@@ -760,28 +785,73 @@ bpf_unparser::parse_asm_stmt (embeddedcode *s, size_t start,

       goto retry;

     }

+  // compute token with adjusted source location for diagnostics

+  // TODO: needs some attention to how multiline tokens are printed in error reporting -- with this code, caret aligns incorrectly

+  for (/* use saved adjust_pos */; adjust_pos < save_start && adjust_pos < n; adjust_pos++)

+    {

+      char c = code[adjust_pos];

+      if (c == '\n')

+        {

+          adjusted_loc.line++;

+          adjusted_loc.column = 1;

+        }

+      else

+        adjusted_loc.column++;

+    }

+

   // set token with adjusted source location

-  //stmt.tok = (token *)s->tok;

-  // TODO this segfaults for some reason, some data not copied?

   stmt.tok = s->tok->adjust_location(adjusted_loc);

-  stmt.deallocate_tok = false; // TODO must avoid destroy-on-copy

+  adjusted_toks.push_back(stmt.tok);

-  std::cerr << "DEBUG GOT stmt "; // TODO

-  for (unsigned k = 0; k < args.size(); k++) std::cerr << args[k] << " / ";

-  std::cerr << std::endl; // TODO

+#ifdef BPF_ASM_DEBUG

+  std::cerr << "bpf_asm parse_asm_stmt: tokenizer got ";

+  for (unsigned k = 0; k < args.size(); k++)

+    std::cerr << args[k] << ", ";

+  std::cerr << std::endl;

+#endif

   if (args[0] == "label")

     {

       if (args.size() != 2)

-        throw SEMANTIC_ERROR (_("invalid bpf embeddedcode syntax"), stmt.tok);

+        throw SEMANTIC_ERROR (_F("invalid bpf embeddedcode syntax (label expects 1 arg, found %lu)", args.size()-1), stmt.tok);

+      stmt.kind = args[0];

+      stmt.dest = args[1];

+    }

+  else if (args[0] == "alloc")

+    {

+      if (args.size() != 3)

+        throw SEMANTIC_ERROR (_F("invalid bpf embeddedcode syntax (alloc expects 2 args, found %lu)", args.size()-1), stmt.tok);

       stmt.kind = args[0];

       stmt.dest = args[1];

+      stmt.imm = parse_imm(stmt, args[2]);

+    }

+  else if (args[0] == "call")

+    {

+      if (args.size() < 3)

+        throw SEMANTIC_ERROR (_F("invalid bpf embeddedcode syntax (call expects at least 2 args, found %lu)", args.size()-1), stmt.tok);

+      stmt.kind = args[0];

+      stmt.dest = args[1];

+      for (unsigned k = 2; k < args.size(); k++)

+        stmt.params.push_back(args[k]);

+    }

+  else if (args[0] == "printf" || args[0] == "error")

+    {

+      if (args.size() < 2)

+        throw SEMANTIC_ERROR (_F("invalid bpf embeddedcode syntax (%s expects at least 2 args, found %lu)", args[0].c_str(), args.size()-1), stmt.tok);

+      stmt.kind = args[0];

+      for (unsigned k = 2; k < args.size(); k++)

+        stmt.params.push_back(args[k]);

     }

   else if (is_numeric(args[0]))

     {

-      if (args.size() != 5) // TODO change to 4 to test err+tok

-        throw SEMANTIC_ERROR (_("invalid bpf embeddedcode syntax"), stmt.tok);

+      if (args.size() != 5)

+        throw SEMANTIC_ERROR (_F("invalid bpf embeddedcode syntax (opcode expects 4 args, found %lu)", args.size()-1), stmt.tok);

       stmt.kind = "opcode";

-      stmt.code = stoul(args[0], 0, 0); // TODO signal error

+      try {

+        stmt.code = stoul(args[0], 0, 0);

+      } catch (std::exception &e) { // XXX: invalid_argument, out_of_range

+        throw SEMANTIC_ERROR (_F("invalid bpf embeddedcode opcode '%s'",

+                                 args[0].c_str()), stmt.tok);

+      }

       stmt.dest = args[1];

       stmt.src1 = args[2];

@@ -799,25 +869,16 @@ bpf_unparser::parse_asm_stmt (embeddedcode *s, size_t start,

           stmt.off = 0;

           stmt.jmp_target = args[3];

         }

-      else if (args[3] == "BPF_MAXSTRINGLEN")

-        stmt.off = BPF_MAXSTRINGLEN;

-      else if (args[3] == "-")

-        stmt.off = 0;

       else

-        stmt.off = stol(args[3]); // TODO signal error

+        stmt.off = parse_imm(stmt, args[3]);

-      if (args[4] == "BPF_MAXSTRINGLEN")

-        stmt.imm = BPF_MAXSTRINGLEN;

-      else if (args[4] == "-")

-        stmt.imm = 0;

-      else

-        stmt.imm = stol(args[4]); // TODO signal error

+      stmt.imm = parse_imm(stmt, args[4]);

     }

   else

     throw SEMANTIC_ERROR (_F("unknown bpf embeddedcode operator '%s'",

                              args[0].c_str()), stmt.tok);

-  // we returned a statement, so there's more parsing to be done

+  // we returned one statement, there may be more parsing to be done

   return pos;

 }

@@ -828,7 +889,7 @@ std::string translate_escapes (const interned_string &str);

    May emit code to store a string constant on the stack. */

 value *

 bpf_unparser::emit_asm_arg (const asm_stmt &stmt, const std::string &arg,

-                            bool allow_imm)

+                            bool allow_imm, bool allow_emit)

 {

   if (arg == "$$")

     {

@@ -859,7 +920,6 @@ bpf_unparser::emit_asm_arg (const asm_stmt &stmt, const std::string &arg,

       auto ok = this_locals->insert (v);

       assert (ok.second);

       return reg;

-      // TODO write a testcase

     }

   else if (is_numeric(arg) && allow_imm)

     {

@@ -879,13 +939,17 @@ bpf_unparser::emit_asm_arg (const asm_stmt &stmt, const std::string &arg,

     }

   else if (arg[0] == '"')

     {

-      // TODO verify correctness

+      if (!allow_emit)

+        throw SEMANTIC_ERROR (_F("invalid bpf argument %s "

+                                 "(string literal not allowed here)",

+                                 arg.c_str()), stmt.tok);

+

       /* arg is a string constant */

       if (arg[arg.size() - 1] != '"')

         throw SEMANTIC_ERROR (_F("BUG: improper string %s",

                                  arg.c_str()), stmt.tok);

       std::string escaped_str = arg.substr(1,arg.size()-2); /* strip quotes */

-      std::string str = translate_escapes(escaped_str); // TODO interned_str?

+      std::string str = translate_escapes(escaped_str);

       return emit_literal_string(str, stmt.tok);

     }

   else if (arg == "BPF_MAXSTRINGLEN")

@@ -913,12 +977,22 @@ bpf_unparser::emit_asm_arg (const asm_stmt &stmt, const std::string &arg,

 }

+/* As above, but don't accept immediate values.

+   Do accept string constants (since they're stored in a register). */

 value *

 bpf_unparser::emit_asm_reg (const asm_stmt &stmt, const std::string &reg)

 {

   return emit_asm_arg(stmt, reg, /*allow_imm=*/false);

 }

+/* As above, but don't allow string constants or anything that emits code.

+   Useful if the context requires an lvalue. */

+value *

+bpf_unparser::get_asm_reg (const asm_stmt &stmt, const std::string &reg)

+{

+  return emit_asm_arg(stmt, reg, /*allow_imm=*/false, /*allow_emit=*/false);

+}

+

 void

 bpf_unparser::emit_asm_opcode (const asm_stmt &stmt,

                                std::map<std::string, block *> label_map)

@@ -1013,7 +1087,7 @@ bpf_unparser::emit_asm_opcode (const asm_stmt &stmt,

   value *v_dest = NULL;

   if (r_dest || r_src0)

-    v_dest = emit_asm_reg(stmt, stmt.dest);

+    v_dest = get_asm_reg(stmt, stmt.dest);

   else if (stmt.dest != "0" && stmt.dest != "-")

     throw SEMANTIC_ERROR (_F("invalid register field '%s' in bpf code",

                              stmt.dest.c_str()), stmt.tok);

@@ -1069,6 +1143,10 @@ bpf_unparser::visit_embeddedcode (embeddedcode *s)

   std::vector<asm_stmt> statements;

   asm_stmt stmt;

+  // track adjusted source location for each stmt

+  adjusted_loc = s->tok->location;

+  adjust_pos = 0;

+

   size_t pos = 0;

   while ((pos = parse_asm_stmt(s, pos, stmt)) != std::string::npos)

     {

@@ -1133,7 +1211,7 @@ bpf_unparser::visit_embeddedcode (embeddedcode *s)

           after_jump = NULL;

         }

     }

-  if (after_jump != NULL) // TODO: should just fall through to exit

+  if (after_jump != NULL) // ??? should just fall through to exit

     throw SEMANTIC_ERROR (_("BUG: bpf embeddedcode doesn't support "

                             "fallthrough on final asm_stmt"), stmt.tok);

@@ -1144,14 +1222,67 @@ bpf_unparser::visit_embeddedcode (embeddedcode *s)

        it != statements.end(); it++)

     {

       stmt = *it;

-      std::cerr << "DEBUG processing " << stmt << std::endl; // TODO

+#ifdef BPF_ASM_DEBUG

+      std::cerr << "bpf_asm visit_embeddedcode: " << stmt << std::endl;

+#endif

       if (stmt.kind == "label")

         {

-          // TODO: be sure there's no gap in the edge

           if (!jumped_already)

             emit_jmp (label_map[stmt.dest]);

           set_block(label_map[stmt.dest]);

         }

+      else if (stmt.kind == "alloc")

+        {

+          /* Reserve stack space and store its address in dest. */

+          int ofs = this_prog.max_tmp_space + stmt.imm;

+          value *dest = get_asm_reg(stmt, stmt.dest);

+          this_prog.use_tmp_space(-ofs);

+          this_prog.mk_binary(this_ins, BPF_ADD, dest,

+                              this_prog.lookup_reg(BPF_REG_10) /*frame*/,

+                              this_prog.new_imm(ofs));

+        }

+      else if (stmt.kind == "call")

+        {

+          std::string func_name = stmt.params[0];

+          bpf_func_id hid = bpf_function_id(func_name);

+          if (hid != __BPF_FUNC_MAX_ID)

+            {

+              // TODO diagnostic: check if the number of arguments is correct

+              regno r = BPF_REG_1; unsigned nargs = 0;

+              for (unsigned k = 1; k < stmt.params.size(); k++)

+                {

+                  // ??? Could make params optional to avoid this part,

+                  // ??? since the calling convention is well-known.

+                  value *from_reg = emit_asm_arg(stmt, stmt.params[k]);

+                  value *to_reg = this_prog.lookup_reg(r);

+                  this_prog.mk_mov(this_ins, to_reg, from_reg);

+                  nargs++; r++;

+                }

+              this_prog.mk_call(this_ins, hid, nargs);

+              this_prog.mk_mov(this_ins, get_asm_reg(stmt, stmt.dest),

+                               this_prog.lookup_reg(BPF_REG_0) /* returnval */);

+              // ??? Could make stmt.dest optional to avoid this extra mov,

+              // ??? since the BPF_REG_0 convention is well-known.

+            }

+          else

+            {

+              // TODO function_name = params[0];

+              // TODO args = parse_reg(params[1]), parse_reg(params[2]), ...

+              // TODO emit_functioncall() with good bits from visit_functioncall()

+              throw SEMANTIC_ERROR (_("BUG: bpf embeddedcode non-helper 'call' not yet supported"),

+                                    stmt.tok);

+            }

+        }

+      else if (stmt.kind == "printf" || stmt.kind == "error")

+        {

+          // TODO Note that error() should be modeled on the tapset function in tapset/logging.stp

+          // TODO format = params[0];

+          // TODO args = parse_reg(params[1]), parse_reg(params[2]), ...

+          // TODO emit_print_format() with good bits from visit_print_format()

+          // TODO if (stmt.kind == "error") emit functioncall to exit() 

+          throw SEMANTIC_ERROR (_("BUG: bpf embeddedcode 'printf/error' not yet supported"),

+                                stmt.tok);

+        }

       else if (stmt.kind == "opcode")

         {

           emit_asm_opcode (stmt, label_map);

@@ -1164,6 +1295,12 @@ bpf_unparser::visit_embeddedcode (embeddedcode *s)

       if (stmt.has_fallthrough)

         set_block(label_map[stmt.fallthrough]);

     }

+

+  // housekeeping -- deallocate adjusted_toks along with statements

+  for (std::vector<token *>::iterator it = adjusted_toks.begin();

+       it != adjusted_toks.end(); it++)

+    delete *it;

+  adjusted_toks.clear();

 }

 void

@@ -3260,6 +3397,8 @@ translate_bpf_pass (systemtap_session& s)

 {

   using namespace bpf;

+  init_bpf_helper_tables();

+

   if (elf_version(EV_CURRENT) == EV_NONE)

     return 1;

diff --git a/tapset/logging.stp b/tapset/logging.stp

index 59edce3c8..839239b8f 100644

--- a/tapset/logging.stp

+++ b/tapset/logging.stp

@@ -128,6 +128,8 @@ function error (msg:string)

      exit() // TODO: should support MAXERRORS, probe error {}

    }

 %)

+// NOTE: The 'error' statement in the eBPF assembler in bpf-translate.cxx

+// should be kept up-to-date with the behaviour of this function.

 /**

  * sfunction assert - evaluate assertion

-- 

2.14.5