Filter: Dropped the setter instructions in favor of direct result storage.

This should help filter performance a bit.

7 files changed, 364 insertions, 260 deletions

diff --git a/filter/config.Y b/filter/config.Y
index 3898748c..f57575fc 100644
--- a/filter/config.Y
+++ b/filter/config.Y
@@ -21,9 +21,13 @@ static inline u32 pair(u32 a, u32 b) { return (a << 16) | b; }
 static inline u32 pair_a(u32 p) { return p >> 16; }
 static inline u32 pair_b(u32 p) { return p & 0xFFFF; }
 
-#define f_generate_complex(fi_code, da, arg) \
-  f_new_inst(FI_EA_SET, f_new_inst(fi_code, f_new_inst(FI_EA_GET, da), arg), da)
-
+#define f_generate_complex(fi_code, _da, arg) ({ \
+  struct f_inst *fi = f_new_inst(fi_code, f_new_inst(FI_EA_GET, _da), arg); \
+  fi->result.type = F_LVAL_EA; \
+  fi->result.da = _da; \
+  fi; \
+})
+  
 /*
  * Sets and their items are during parsing handled as lists, linked
  * through left ptr. The first item in a list also contains a pointer
@@ -184,7 +188,10 @@ f_generate_empty(struct f_dynamic_attr dyn)
       cf_error("Can't empty that attribute");
   }
 
-  return f_new_inst(FI_EA_SET, f_new_inst(FI_CONSTANT, empty), dyn);
+  struct f_inst *fi = f_new_inst(FI_CONSTANT, empty);
+  fi->result.type = F_LVAL_EA;
+  fi->result.da = dyn;
+  return fi;
 }
 
 #if 0
@@ -397,31 +404,34 @@ assert_done(struct f_inst *expr, const char *start, const char *end)
 static struct f_inst *
 assert_assign(struct f_lval *lval, struct f_inst *expr, const char *start, const char *end)
 {
-  struct f_inst *setter, *getter, *checker;
+  struct f_inst *getter;
   switch (lval->type) {
+    case F_LVAL_STACK:
+      bug("This shall never happen");
+    case F_LVAL_EXCEPTION:
+      bug("This shall never happen");
     case F_LVAL_VARIABLE:
-      setter = f_new_inst(FI_VAR_SET, expr, lval->sym);
       getter = f_new_inst(FI_VAR_GET, lval->sym);
       break;
     case F_LVAL_PREFERENCE:
-      setter = f_new_inst(FI_PREF_SET, expr);
       getter = f_new_inst(FI_PREF_GET);
       break;
     case F_LVAL_SA:
-      setter = f_new_inst(FI_RTA_SET, expr, lval->sa);
       getter = f_new_inst(FI_RTA_GET, lval->sa);
       break;
     case F_LVAL_EA:
-      setter = f_new_inst(FI_EA_SET, expr, lval->da);
       getter = f_new_inst(FI_EA_GET, lval->da);
       break;
-    default:
-      bug("Unknown lval type");
   }
 
-  checker = f_new_inst(FI_EQ, expr, getter);
+  struct f_inst *checker = f_new_inst(FI_EQ, expr, getter);
+
+  struct f_inst *setter = cfg_alloc(sizeof(struct f_inst));
+  *setter = *expr;
+
   setter->next = checker;
-  
+  setter->result = *lval;
+
   return assert_done(setter, start, end);
 }
 
@@ -985,29 +995,40 @@ cmd:
  | CF_SYM_KNOWN '=' term ';' {
      switch ($1->class) {
        case SYM_VARIABLE_RANGE:
-	 $$ = f_new_inst(FI_VAR_SET, $3, $1);
+	 $3->result.type = F_LVAL_VARIABLE;
+	 $3->result.sym = $1;
 	 break;
        case SYM_ATTRIBUTE:
-	 $$ = f_new_inst(FI_EA_SET, $3, *$1->attribute);
+	 $3->result.type = F_LVAL_EA;
+	 $3->result.da = *$1->attribute;
 	 break;
        default:
 	 cf_error("Can't assign to symbol %s", $1->name);
      }
+     $$ = $3;
    }
  | RETURN term ';' {
      DBG( "Ook, we'll return the value\n" );
-     $$ = f_new_inst(FI_RETURN, $2);
+     $2->result.type = F_LVAL_EXCEPTION;
+     $2->result.exception = FE_RETURN;
+     $$ = $2;
    }
  | dynamic_attr '=' term ';' {
-     $$ = f_new_inst(FI_EA_SET, $3, $1);
+     $3->result.type = F_LVAL_EA;
+     $3->result.da = $1;
+     $$ = $3;
    }
  | static_attr '=' term ';' {
      if ($1.readonly)
        cf_error( "This static attribute is read-only.");
-     $$ = f_new_inst(FI_RTA_SET, $3, $1);
+
+     $3->result.type = F_LVAL_SA;
+     $3->result.sa = $1;
+     $$ = $3;
    }
  | PREFERENCE '=' term ';' {
-     $$ = f_new_inst(FI_PREF_SET, $3);
+     $3->result.type = F_LVAL_PREFERENCE;
+     $$ = $3;
    }
  | UNSET '(' dynamic_attr ')' ';' {
      $$ = f_new_inst(FI_EA_UNSET, $3);
diff --git a/filter/data.c b/filter/data.c
index 912e2b00..cb759a59 100644
--- a/filter/data.c
+++ b/filter/data.c
@@ -525,4 +525,3 @@ val_dump(const struct f_val *v) {
   val_format(v, &b);
   return val_dump_buffer;
 }
-
diff --git a/filter/data.h b/filter/data.h
index 6973008f..3718cea4 100644
--- a/filter/data.h
+++ b/filter/data.h
@@ -107,8 +107,15 @@ struct f_static_attr {
   int readonly:1;			/* Don't allow writing */
 };
 
+/* Exception bits */
+enum f_exception {
+  FE_RETURN = 0x1,
+};
+
 /* Filter l-value type */
 enum f_lval_type {
+  F_LVAL_STACK = 0,
+  F_LVAL_EXCEPTION,
   F_LVAL_VARIABLE,
   F_LVAL_PREFERENCE,
   F_LVAL_SA,
@@ -119,6 +126,7 @@ enum f_lval_type {
 struct f_lval {
   enum f_lval_type type;
   union {
+    enum f_exception exception;
     const struct symbol *sym;
     struct f_dynamic_attr da;
     struct f_static_attr sa;
diff --git a/filter/decl.m4 b/filter/decl.m4
index 9934d0ba..a1d625f3 100644
--- a/filter/decl.m4
+++ b/filter/decl.m4
@@ -119,8 +119,6 @@ case INST_NAME(): {
   m4_undivert(105)
 #undef what
 #undef item
-  dest->items[pos].fi_code = what_->fi_code;
-  dest->items[pos].lineno = what_->lineno;
   break;
 }
 m4_undefine([[FID_LINEARIZE_BODY_EXISTS]])
@@ -236,9 +234,29 @@ do { if (whati->fl$1) {
 } } while(0)m4_dnl
 FID_ALL()')
 
-m4_define(RESULT_OK, `FID_INTERPRET_BODY()fstk->vcnt++FID_ALL()')
-m4_define(RESULT, `RESULT_VAL([[ (struct f_val) { .type = $1, .val.$2 = $3 } ]])')
-m4_define(RESULT_VAL, `FID_INTERPRET_BODY()do { res = $1; RESULT_OK; } while (0)FID_ALL()')
+m4_define(RESULT_PTR, `
+FID_INTERPRET_BODY
+  do {
+    enum filter_return fret = f_lval_set(fs, &(what->result), $1);
+    if (fret != F_NOP) return fret;
+  } while (0)m4_dnl
+FID_ALL()')
+
+m4_define(RESULT, `
+FID_INTERPRET_BODY
+  do {
+    struct f_val res_ = { .type = $1, .val.$2 = $3 };
+    RESULT_PTR(&res_);
+  } while (0)m4_dnl
+FID_ALL()')
+
+m4_define(RESULT_VOID, `
+FID_INTERPRET_BODY
+  do {
+    struct f_val res_ = { .type = T_VOID };
+    RESULT_PTR(&res_);
+  } while (0)m4_dnl
+FID_ALL()')
 
 m4_define(SYMBOL, `FID_MEMBER(const struct symbol *, sym, sym,
 [[strcmp(f1->sym->name, f2->sym->name) || (f1->sym->class != f2->sym->class)]], symbol %s, item->sym->name, const struct symbol *sym = whati->sym)')
@@ -302,6 +320,16 @@ void f_dump_line(const struct f_line *dest, uint indent)
   for (uint i=0; i<dest->len; i++) {
     const struct f_line_item *item = &dest->items[i];
     debug("%sInstruction %s at line %u\n", INDENT, f_instruction_name(item->fi_code), item->lineno);
+
+    switch (item->result.type) {
+      case F_LVAL_STACK: debug("%son stack\n", INDENT); break;
+      case F_LVAL_EXCEPTION: debug("%s=>exception 0x%x\n", INDENT, item->result.exception); break;
+      case F_LVAL_VARIABLE: debug("%s=>%s\n", INDENT, item->result.sym->name); break;
+      case F_LVAL_PREFERENCE: debug("%s=>preference\n", INDENT); break;
+      case F_LVAL_SA: debug("%s=>sa\n", INDENT); break;
+      case F_LVAL_EA: debug("%s=>ea\n", INDENT); break;
+    }
+
     switch (item->fi_code) {
 FID_WR_PUT(7)
       default: bug("Unknown instruction %x in f_dump_line", item->fi_code);
@@ -318,6 +346,9 @@ linearize(struct f_line *dest, const struct f_inst *what_, uint pos)
     switch (what_->fi_code) {
 FID_WR_PUT(8)
     }
+    dest->items[pos].fi_code = what_->fi_code;
+    dest->items[pos].lineno = what_->lineno;
+    dest->items[pos].result = what_->result;
     pos++;
   }
   return pos;
@@ -360,6 +391,32 @@ f_same(const struct f_line *fl1, const struct f_line *fl2)
     if (f1_->flags != f2_->flags)
       return 0;
 
+    if (f1_->result.type != f2_->result.type) return 0;
+    switch (f1_->result.type) {
+      case F_LVAL_STACK:
+	break;
+      case F_LVAL_EXCEPTION:
+	if (f1_->result.exception != f2_->result.exception)
+	  return 0;
+	break;
+      case F_LVAL_VARIABLE:
+	if (strcmp(f1_->result.sym->name, f2_->result.sym->name))
+	  return 0;
+	if (f1_->result.sym->class != f2_->result.sym->class)
+	  return 0;
+	break;
+      case F_LVAL_PREFERENCE:
+	break;
+      case F_LVAL_SA:
+	if (f1_->result.sa.sa_code != f2_->result.sa.sa_code)
+	  return 0;
+	break;
+      case F_LVAL_EA:
+	if (f1_->result.da.ea_code != f2_->result.da.ea_code)
+	  return 0;
+	break;
+    }
+
     switch(f1_->fi_code) {
 FID_WR_PUT(9)
     }
@@ -382,6 +439,7 @@ struct f_inst {
   enum f_instruction_code fi_code;	/* Instruction code */
   int size;				/* How many instructions are underneath */
   int lineno;				/* Line number */
+  struct f_lval result;			/* Destination */
   union {
     FID_WR_PUT(1)
   };
@@ -392,6 +450,7 @@ struct f_line_item {
   enum f_instruction_code fi_code;	/* What to do */
   enum f_instruction_flags flags;	/* Flags, instruction-specific */
   uint lineno;				/* Where */
+  struct f_lval result;			/* Destination */
   union {
     FID_WR_PUT(2)
   };
diff --git a/filter/f-inst.c b/filter/f-inst.c
index 749e072c..3be76d11 100644
--- a/filter/f-inst.c
+++ b/filter/f-inst.c
@@ -36,7 +36,7 @@
  *	m4_dnl	  ACCESS_RTE;				this instruction needs route
  *	m4_dnl	  ACCESS_EATTRS;			this instruction needs extended attributes
  *	m4_dnl	  RESULT(type, union-field, value);	putting this on value stack
- *	m4_dnl	  RESULT_OK;				legalize what already is on the value stack
+ *	m4_dnl	  RESULT_PTR(vptr);			put what is pointed-to on the value stack
  *	m4_dnl	}
  *
  *	Other code is just copied into the interpreter part.
@@ -50,41 +50,37 @@
   INST(FI_ADD, 2, 1) {
     ARG(1,T_INT);
     ARG(2,T_INT);
-    res.val.i += v2.val.i;
-    RESULT_OK;
+    RESULT(T_INT, i, v1.val.i + v2.val.i);
   }
   INST(FI_SUBTRACT, 2, 1) {
     ARG(1,T_INT);
     ARG(2,T_INT);
-    res.val.i -= v2.val.i;
-    RESULT_OK;
+    RESULT(T_INT, i, v1.val.i - v2.val.i);
   }
   INST(FI_MULTIPLY, 2, 1) {
     ARG(1,T_INT);
     ARG(2,T_INT);
-    res.val.i *= v2.val.i;
-    RESULT_OK;
+    RESULT(T_INT, i, v1.val.i * v2.val.i);
   }
   INST(FI_DIVIDE, 2, 1) {
     ARG(1,T_INT);
     ARG(2,T_INT);
     if (v2.val.i == 0) runtime( "Mother told me not to divide by 0" );
-    res.val.i /= v2.val.i;
-    RESULT_OK;
+    RESULT(T_INT, i, v1.val.i / v2.val.i);
   }
   INST(FI_AND, 1, 1) {
     ARG(1,T_BOOL);
-    if (res.val.i)
+    if (v1.val.i)
       LINE(2,0);
     else
-      RESULT_OK;
+      RESULT_PTR(&(v1));
   }
   INST(FI_OR, 1, 1) {
     ARG(1,T_BOOL);
-    if (!res.val.i)
+    if (!v1.val.i)
       LINE(2,0);
     else
-      RESULT_OK;
+      RESULT_PTR(&(v1));
   }
   INST(FI_PAIR_CONSTRUCT, 2, 1) {
     ARG(1,T_INT);
@@ -281,8 +277,7 @@
 
   INST(FI_VAR_GET, 0, 1) {
     SYMBOL(1);
-    res = fstk->vstk[curline.vbase + sym->offset];
-    RESULT_OK;
+    RESULT_PTR(&(fstk->vstk[curline.vbase + sym->offset]));
   }
 
     /* some constants have value in a[1], some in *a[0].p, strange. */
@@ -303,8 +298,7 @@
       debug("%svalue %s\n", INDENT, val_dump(&item->val));
     FID_ALL
 
-    res = whati->val;
-    RESULT_OK;
+    RESULT_PTR(&(whati->val));
   }
   INST(FI_CONSTANT_DEFINED, 0, 1) {
     FID_STRUCT_IN
@@ -324,8 +318,7 @@
       debug("%sconstant %s with value %s\n", INDENT, item->sym->name, val_dump(item->valp));
     FID_ALL
 
-    res = *whati->valp;
-    RESULT_OK;
+    RESULT_PTR(whati->valp);
   }
   INST(FI_PRINT, 1, 0) {
     ARG_ANY(1);
@@ -398,76 +391,6 @@
     }
   }
 
-  INST(FI_RTA_SET, 1, 0) {
-    ACCESS_RTE;
-    ARG_ANY(1);
-    STATIC_ATTR;
-    if (sa.f_type != v1.type)
-      runtime( "Attempt to set static attribute to incompatible type" );
-
-    f_rta_cow(fs);
-    {
-      struct rta *rta = (*fs->rte)->attrs;
-
-      switch (sa.sa_code)
-      {
-      case SA_FROM:
-	rta->from = v1.val.ip;
-	break;
-
-      case SA_GW:
-	{
-	  ip_addr ip = v1.val.ip;
-	  neighbor *n = neigh_find(rta->src->proto, ip, NULL, 0);
-	  if (!n || (n->scope == SCOPE_HOST))
-	    runtime( "Invalid gw address" );
-
-	  rta->dest = RTD_UNICAST;
-	  rta->nh.gw = ip;
-	  rta->nh.iface = n->iface;
-	  rta->nh.next = NULL;
-	  rta->hostentry = NULL;
-	}
-	break;
-
-      case SA_SCOPE:
-	rta->scope = v1.val.i;
-	break;
-
-      case SA_DEST:
-	{
-	  int i = v1.val.i;
-	  if ((i != RTD_BLACKHOLE) && (i != RTD_UNREACHABLE) && (i != RTD_PROHIBIT))
-	    runtime( "Destination can be changed only to blackhole, unreachable or prohibit" );
-
-	  rta->dest = i;
-	  rta->nh.gw = IPA_NONE;
-	  rta->nh.iface = NULL;
-	  rta->nh.next = NULL;
-	  rta->hostentry = NULL;
-	}
-	break;
-
-      case SA_IFNAME:
-	{
-	  struct iface *ifa = if_find_by_name(v1.val.s);
-	  if (!ifa)
-	    runtime( "Invalid iface name" );
-
-	  rta->dest = RTD_UNICAST;
-	  rta->nh.gw = IPA_NONE;
-	  rta->nh.iface = ifa;
-	  rta->nh.next = NULL;
-	  rta->hostentry = NULL;
-	}
-	break;
-
-      default:
-	bug("Invalid static attribute access (%u/%u)", sa.f_type, sa.sa_code);
-      }
-    }
-  }
-
   INST(FI_EA_GET, 0, 1) {	/* Access to extended attributes */
     DYNAMIC_ATTR;
     ACCESS_RTE;
@@ -501,8 +424,7 @@
 	}
 
 	/* Undefined value */
-	res.type = T_VOID;
-	RESULT_OK;
+	RESULT_VOID;
 	break;
       }
 
@@ -535,8 +457,7 @@
 	RESULT(T_LCLIST, ad, e->u.ptr);
 	break;
       case EAF_TYPE_UNDEF:
-	res.type = T_VOID;
-	RESULT_OK;
+	RESULT_VOID;
 	break;
       default:
 	bug("Unknown dynamic attribute type");
@@ -544,95 +465,6 @@
     }
   }
 
-  INST(FI_EA_SET, 1, 0) {
-    ACCESS_RTE;
-    ACCESS_EATTRS;
-    ARG_ANY(1);
-    DYNAMIC_ATTR;
-    {
-      struct ea_list *l = lp_alloc(fs->pool, sizeof(struct ea_list) + sizeof(eattr));
-
-      l->next = NULL;
-      l->flags = EALF_SORTED;
-      l->count = 1;
-      l->attrs[0].id = da.ea_code;
-      l->attrs[0].flags = 0;
-      l->attrs[0].type = da.type | EAF_ORIGINATED | EAF_FRESH;
-
-      switch (da.type) {
-      case EAF_TYPE_INT:
-	if (v1.type != da.f_type)
-	  runtime( "Setting int attribute to non-int value" );
-	l->attrs[0].u.data = v1.val.i;
-	break;
-
-      case EAF_TYPE_ROUTER_ID:
-	/* IP->Quad implicit conversion */
-	if (val_is_ip4(&v1)) {
-	  l->attrs[0].u.data = ipa_to_u32(v1.val.ip);
-	  break;
-	}
-	/* T_INT for backward compatibility */
-	if ((v1.type != T_QUAD) && (v1.type != T_INT))
-	  runtime( "Setting quad attribute to non-quad value" );
-	l->attrs[0].u.data = v1.val.i;
-	break;
-
-      case EAF_TYPE_OPAQUE:
-	runtime( "Setting opaque attribute is not allowed" );
-	break;
-      case EAF_TYPE_IP_ADDRESS:
-	if (v1.type != T_IP)
-	  runtime( "Setting ip attribute to non-ip value" );
-	int len = sizeof(ip_addr);
-	struct adata *ad = lp_alloc(fs->pool, sizeof(struct adata) + len);
-	ad->length = len;
-	(* (ip_addr *) ad->data) = v1.val.ip;
-	l->attrs[0].u.ptr = ad;
-	break;
-      case EAF_TYPE_AS_PATH:
-	if (v1.type != T_PATH)
-	  runtime( "Setting path attribute to non-path value" );
-	l->attrs[0].u.ptr = v1.val.ad;
-	break;
-      case EAF_TYPE_BITFIELD:
-	if (v1.type != T_BOOL)
-	  runtime( "Setting bit in bitfield attribute to non-bool value" );
-	{
-	  /* First, we have to find the old value */
-	  eattr *e = ea_find(*fs->eattrs, da.ea_code);
-	  u32 data = e ? e->u.data : 0;
-
-	  if (v1.val.i)
-	    l->attrs[0].u.data = data | (1u << da.bit);
-	  else
-	    l->attrs[0].u.data = data & ~(1u << da.bit);
-	}
-	break;
-      case EAF_TYPE_INT_SET:
-	if (v1.type != T_CLIST)
-	  runtime( "Setting clist attribute to non-clist value" );
-	l->attrs[0].u.ptr = v1.val.ad;
-	break;
-      case EAF_TYPE_EC_SET:
-	if (v1.type != T_ECLIST)
-	  runtime( "Setting eclist attribute to non-eclist value" );
-	l->attrs[0].u.ptr = v1.val.ad;
-	break;
-      case EAF_TYPE_LC_SET:
-	if (v1.type != T_LCLIST)
-	  runtime( "Setting lclist attribute to non-lclist value" );
-	l->attrs[0].u.ptr = v1.val.ad;
-	break;
-      default: bug("Unknown type in e,S");
-      }
-
-      f_rta_cow(fs);
-      l->next = *fs->eattrs;
-      *fs->eattrs = l;
-    }
-  }
-
   INST(FI_EA_UNSET, 0, 0) {
     DYNAMIC_ATTR;
     ACCESS_RTE;
@@ -660,15 +492,6 @@
     RESULT(T_INT, i, (*fs->rte)->pref);
   }
 
-  INST(FI_PREF_SET, 1, 0) {
-    ACCESS_RTE;
-    ARG(1,T_INT);
-    if (v1.val.i > 0xFFFF)
-      runtime( "Setting preference value out of bounds" );
-    f_rte_cow(fs);
-    (*fs->rte)->pref = v1.val.i;
-  }
-
   INST(FI_LENGTH, 1, 1) {	/* Get length of */
     ARG_ANY(1);
     switch(v1.type) {
@@ -744,33 +567,6 @@
     RESULT(T_INT, i, as_path_get_last_nonaggregated(v1.val.ad));
   }
 
-  INST(FI_RETURN, 1, 1) {
-    /* Acquire the return value */
-    ARG_ANY(1);
-    uint retpos = fstk->vcnt;
-
-    /* Drop every sub-block including ourselves */
-    while ((fstk->ecnt-- > 0) && !(fstk->estk[fstk->ecnt].emask & FE_RETURN))
-      ;
-
-    /* Now we are at the caller frame; if no such, try to convert to accept/reject. */
-    if (!fstk->ecnt)
-      if (fstk->vstk[retpos].type == T_BOOL)
-	if (fstk->vstk[retpos].val.i)
-
-	  return F_ACCEPT;
-	else
-	  return F_REJECT;
-      else
-	runtime("Can't return non-bool from non-function");
-
-    /* Set the value stack position, overwriting the former implicit void */
-    fstk->vcnt = fstk->estk[fstk->ecnt].ventry - 1;
-
-    /* Copy the return value */
-    RESULT_VAL(fstk->vstk[retpos]);
-  }
-
   INST(FI_CALL, 0, 1) {
     SYMBOL;
 
diff --git a/filter/f-inst.h b/filter/f-inst.h
index f0dcec64..ca685ded 100644
--- a/filter/f-inst.h
+++ b/filter/f-inst.h
@@ -84,7 +84,6 @@ static inline struct f_dynamic_attr f_new_dynamic_attr(u8 type, u8 bit, enum f_t
 { return (struct f_dynamic_attr) { .type = type, .bit = bit, .f_type = f_type, .ea_code = code }; }   /* f_type currently unused; will be handy for static type checking */
 static inline struct f_static_attr f_new_static_attr(int f_type, int code, int readonly)
 { return (struct f_static_attr) { .f_type = f_type, .sa_code = code, .readonly = readonly }; }
-struct f_inst *f_generate_complex(enum f_instruction_code fi_code, struct f_dynamic_attr da, struct f_inst *argument);
 struct f_inst *f_generate_roa_check(struct rtable_config *table, struct f_inst *prefix, struct f_inst *asn);
 
 /* Hook for call bt_assert() function in configuration */
diff --git a/filter/filter.c b/filter/filter.c
index 9b61c707..98df7bd0 100644
--- a/filter/filter.c
+++ b/filter/filter.c
@@ -51,12 +51,6 @@
 #include "filter/data.h"
 
 
-/* Exception bits */
-enum f_exception {
-  FE_RETURN = 0x1,
-};
-
-
 struct filter_stack {
   /* Value stack for execution */
 #define F_VAL_STACK_MAX	4096
@@ -151,7 +145,7 @@ f_rta_cow(struct filter_state *fs)
 }
 
 static char *
-val_format_str(struct filter_state *fs, struct f_val *v) {
+val_format_str(struct filter_state *fs, const struct f_val *v) {
   buffer b;
   LOG_BUFFER_INIT(b);
   val_format(v, &b);
@@ -160,6 +154,233 @@ val_format_str(struct filter_state *fs, struct f_val *v) {
 
 static struct tbf rl_runtime_err = TBF_DEFAULT_LOG_LIMITS;
 
+#define runtime(fmt, ...) do { \
+  if (!(fs->flags & FF_SILENT)) \
+    log_rl(&rl_runtime_err, L_ERR "filters, line %d: " fmt, \
+	(fs->stack->estk[fs->stack->ecnt-1].line->items[fs->stack->estk[fs->stack->ecnt-1].pos-1]).lineno, \
+	##__VA_ARGS__); \
+  return F_ERROR; \
+} while(0)
+
+#define ACCESS_RTE do { if (!fs->rte) runtime("No route to access"); } while (0)
+#define ACCESS_EATTRS do { if (!fs->eattrs) f_cache_eattrs(fs); } while (0)
+
+static inline enum filter_return
+f_rta_set(struct filter_state *fs, struct f_static_attr sa, const struct f_val *val)
+{
+    ACCESS_RTE;
+    if (sa.f_type != val->type)
+      runtime( "Attempt to set static attribute to incompatible type" );
+
+    f_rta_cow(fs);
+    {
+      struct rta *rta = (*fs->rte)->attrs;
+
+      switch (sa.sa_code)
+      {
+      case SA_FROM:
+	rta->from = val->val.ip;
+	return F_NOP;
+
+      case SA_GW:
+	{
+	  ip_addr ip = val->val.ip;
+	  neighbor *n = neigh_find(rta->src->proto, ip, NULL, 0);
+	  if (!n || (n->scope == SCOPE_HOST))
+	    runtime( "Invalid gw address" );
+
+	  rta->dest = RTD_UNICAST;
+	  rta->nh.gw = ip;
+	  rta->nh.iface = n->iface;
+	  rta->nh.next = NULL;
+	  rta->hostentry = NULL;
+	}
+	return F_NOP;
+
+      case SA_SCOPE:
+	rta->scope = val->val.i;
+	return F_NOP;
+
+      case SA_DEST:
+	{
+	  int i = val->val.i;
+	  if ((i != RTD_BLACKHOLE) && (i != RTD_UNREACHABLE) && (i != RTD_PROHIBIT))
+	    runtime( "Destination can be changed only to blackhole, unreachable or prohibit" );
+
+	  rta->dest = i;
+	  rta->nh.gw = IPA_NONE;
+	  rta->nh.iface = NULL;
+	  rta->nh.next = NULL;
+	  rta->hostentry = NULL;
+	}
+	return F_NOP;
+
+      case SA_IFNAME:
+	{
+	  struct iface *ifa = if_find_by_name(val->val.s);
+	  if (!ifa)
+	    runtime( "Invalid iface name" );
+
+	  rta->dest = RTD_UNICAST;
+	  rta->nh.gw = IPA_NONE;
+	  rta->nh.iface = ifa;
+	  rta->nh.next = NULL;
+	  rta->hostentry = NULL;
+	}
+	return F_NOP;
+
+      default:
+	bug("Invalid static attribute access (%u/%u)", sa.f_type, sa.sa_code);
+      }
+    }
+}
+
+static inline enum filter_return
+f_ea_set(struct filter_state *fs, struct f_dynamic_attr da, const struct f_val *val)
+{
+    ACCESS_RTE;
+    ACCESS_EATTRS;
+    {
+      struct ea_list *l = lp_alloc(fs->pool, sizeof(struct ea_list) + sizeof(eattr));
+
+      l->next = NULL;
+      l->flags = EALF_SORTED;
+      l->count = 1;
+      l->attrs[0].id = da.ea_code;
+      l->attrs[0].flags = 0;
+      l->attrs[0].type = da.type | EAF_ORIGINATED | EAF_FRESH;
+
+      switch (da.type) {
+      case EAF_TYPE_INT:
+	if (val->type != da.f_type)
+	  runtime( "Setting int attribute to non-int value" );
+	l->attrs[0].u.data = val->val.i;
+	break;
+
+      case EAF_TYPE_ROUTER_ID:
+	/* IP->Quad implicit conversion */
+	if (val_is_ip4(val)) {
+	  l->attrs[0].u.data = ipa_to_u32(val->val.ip);
+	  break;
+	}
+	/* T_INT for backward compatibility */
+	if ((val->type != T_QUAD) && (val->type != T_INT))
+	  runtime( "Setting quad attribute to non-quad value" );
+	l->attrs[0].u.data = val->val.i;
+	break;
+
+      case EAF_TYPE_OPAQUE:
+	runtime( "Setting opaque attribute is not allowed" );
+	break;
+      case EAF_TYPE_IP_ADDRESS:
+	if (val->type != T_IP)
+	  runtime( "Setting ip attribute to non-ip value" );
+	int len = sizeof(ip_addr);
+	struct adata *ad = lp_alloc(fs->pool, sizeof(struct adata) + len);
+	ad->length = len;
+	(* (ip_addr *) ad->data) = val->val.ip;
+	l->attrs[0].u.ptr = ad;
+	break;
+      case EAF_TYPE_AS_PATH:
+	if (val->type != T_PATH)
+	  runtime( "Setting path attribute to non-path value" );
+	l->attrs[0].u.ptr = val->val.ad;
+	break;
+      case EAF_TYPE_BITFIELD:
+	if (val->type != T_BOOL)
+	  runtime( "Setting bit in bitfield attribute to non-bool value" );
+	{
+	  /* First, we have to find the old value */
+	  eattr *e = ea_find(*fs->eattrs, da.ea_code);
+	  u32 data = e ? e->u.data : 0;
+
+	  if (val->val.i)
+	    l->attrs[0].u.data = data | (1u << da.bit);
+	  else
+	    l->attrs[0].u.data = data & ~(1u << da.bit);
+	}
+	break;
+      case EAF_TYPE_INT_SET:
+	if (val->type != T_CLIST)
+	  runtime( "Setting clist attribute to non-clist value" );
+	l->attrs[0].u.ptr = val->val.ad;
+	break;
+      case EAF_TYPE_EC_SET:
+	if (val->type != T_ECLIST)
+	  runtime( "Setting eclist attribute to non-eclist value" );
+	l->attrs[0].u.ptr = val->val.ad;
+	break;
+      case EAF_TYPE_LC_SET:
+	if (val->type != T_LCLIST)
+	  runtime( "Setting lclist attribute to non-lclist value" );
+	l->attrs[0].u.ptr = val->val.ad;
+	break;
+      default: bug("Unknown type in e,S");
+      }
+
+      f_rta_cow(fs);
+      l->next = *fs->eattrs;
+      *fs->eattrs = l;
+
+      return F_NOP;
+    }
+}
+
+static inline enum filter_return
+f_lval_set(struct filter_state *fs, const struct f_lval *lv, const struct f_val *val)
+{
+  switch (lv->type) {
+    case F_LVAL_STACK:
+      fs->stack->vstk[fs->stack->vcnt] = *val;
+      fs->stack->vcnt++;
+      return F_NOP;
+    case F_LVAL_EXCEPTION:
+      {
+	/* Drop every sub-block including ourselves */
+	while ((fs->stack->ecnt-- > 0) && !(fs->stack->estk[fs->stack->ecnt].emask & lv->exception))
+	  ;
+
+	/* Now we are at the catch frame; if no such, try to convert to accept/reject. */
+	if (!fs->stack->ecnt)
+	  if (lv->exception == FE_RETURN)
+	    if (val->type == T_BOOL)
+	      if (val->val.i)
+		return F_ACCEPT;
+	      else
+		return F_REJECT;
+	    else
+	      runtime("Can't return non-bool from non-function");
+	  else
+	    runtime("Unhandled exception 0x%x: %s", lv->exception, val_format_str(fs, val));
+
+	/* Set the value stack position, overwriting the former implicit void */
+	fs->stack->vcnt = fs->stack->estk[fs->stack->ecnt].ventry;
+
+	/* Copy the return value */
+	fs->stack->vstk[fs->stack->vcnt - 1] = *val;
+	return F_NOP;
+      }
+    case F_LVAL_VARIABLE:
+      fs->stack->vstk[fs->stack->estk[fs->stack->ecnt-1].vbase + lv->sym->offset] = *val;
+      return F_NOP;
+    case F_LVAL_PREFERENCE:
+      ACCESS_RTE;
+      if (val->type != T_INT)
+	runtime("Preference must be integer, got 0x%02x", val->type);
+      if (val->val.i > 0xFFFF)
+	runtime("Preference is at most 65536");
+      f_rte_cow(fs);
+      (*fs->rte)->pref = val->val.i;
+      return F_NOP;
+    case F_LVAL_SA:
+      return f_rta_set(fs, lv->sa, val);
+    case F_LVAL_EA:
+      return f_ea_set(fs, lv->da, val);
+    default:
+      bug("This shall never happen");
+  }    
+}
+
 /**
  * interpret
  * @fs: filter state
@@ -209,15 +430,6 @@ interpret(struct filter_state *fs, const struct f_line *line, struct f_val *val)
 #define v2 fstk->vstk[fstk->vcnt + 1]
 #define v3 fstk->vstk[fstk->vcnt + 2]
 
-#define runtime(fmt, ...) do { \
-  if (!(fs->flags & FF_SILENT)) \
-    log_rl(&rl_runtime_err, L_ERR "filters, line %d: " fmt, what->lineno, ##__VA_ARGS__); \
-  return F_ERROR; \
-} while(0)
-
-#define ACCESS_RTE do { if (!fs->rte) runtime("No route to access"); } while (0)
-#define ACCESS_EATTRS do { if (!fs->eattrs) f_cache_eattrs(fs); } while (0)
-
 #include "filter/inst-interpret.c"
 #undef res
 #undef v1
@@ -233,6 +445,16 @@ interpret(struct filter_state *fs, const struct f_line *line, struct f_val *val)
     fstk->vcnt -= curline.line->vars;
     fstk->vcnt -= curline.line->args;
     fstk->ecnt--;
+
+    /* If the caller wants to store the result somewhere, do it. */
+    if (fstk->ecnt) {
+      const struct f_line_item *caller = &(curline.line->items[curline.pos-1]);
+      if (caller->result.type != F_LVAL_STACK) {
+	enum filter_return fret = f_lval_set(fs, &(caller->result), &fstk->vstk[--fstk->vcnt]);
+	if (fret != F_NOP)
+	  return fret;
+      }
+    }
   }
 
   if (fstk->vcnt == 0) {