* offsets are absolute from start of bytecode.
*/
-enum filter_register {
- REG_R0 = 0,
- REG_R1 = 1,
- REG_ERROR,
-};
-
struct field_ref {
/* Initially, symbol offset. After link, field offset. */
uint16_t offset;
struct load_op {
filter_opcode_t op;
- uint8_t reg; /* enum filter_register */
char data[0];
/* data to load. Size known by enum filter_opcode and null-term char. */
} __attribute__((packed));
struct unary_op {
filter_opcode_t op;
- uint8_t reg; /* enum filter_register */
} __attribute__((packed));
/* skip_offset is absolute from start of bytecode */
struct cast_op {
filter_opcode_t op;
- uint8_t reg; /* enum filter_register */
} __attribute__((packed));
struct return_op {
}
static
-int reg_strcmp(struct reg reg[NR_REG], const char *cmp_type)
+int stack_strcmp(struct estack *stack, const char *cmp_type)
{
- const char *p = reg[REG_R0].str, *q = reg[REG_R1].str;
+ const char *p = estack_bx(stack)->u.s.str, *q = estack_ax(stack)->u.s.str;
int ret;
int diff;
for (;;) {
int escaped_r0 = 0;
- if (unlikely(p - reg[REG_R0].str > reg[REG_R0].seq_len || *p == '\0')) {
- if (q - reg[REG_R1].str > reg[REG_R1].seq_len || *q == '\0')
+ if (unlikely(p - estack_bx(stack)->u.s.str > estack_bx(stack)->u.s.seq_len || *p == '\0')) {
+ if (q - estack_ax(stack)->u.s.str > estack_ax(stack)->u.s.seq_len || *q == '\0')
diff = 0;
else
diff = -1;
break;
}
- if (unlikely(q - reg[REG_R1].str > reg[REG_R1].seq_len || *q == '\0')) {
- if (p - reg[REG_R0].str > reg[REG_R0].seq_len || *p == '\0')
+ if (unlikely(q - estack_ax(stack)->u.s.str > estack_ax(stack)->u.s.seq_len || *q == '\0')) {
+ if (p - estack_bx(stack)->u.s.str > estack_bx(stack)->u.s.seq_len || *p == '\0')
diff = 0;
else
diff = 1;
break;
}
- if (reg[REG_R0].literal) {
+ if (estack_bx(stack)->u.s.literal) {
ret = parse_char(&p);
if (ret == -1) {
return 0;
}
/* else compare both char */
}
- if (reg[REG_R1].literal) {
+ if (estack_ax(stack)->u.s.literal) {
ret = parse_char(&q);
if (ret == -1) {
return 0;
void *pc, *next_pc, *start_pc;
int ret = -EINVAL;
int retval = 0;
- struct reg reg[NR_REG];
+ struct estack _stack;
+ struct estack *stack = &_stack;
#ifndef INTERPRETER_USE_SWITCH
static void *dispatch[NR_FILTER_OPS] = {
[ FILTER_OP_UNKNOWN ] = &&LABEL_FILTER_OP_UNKNOWN,
};
#endif /* #ifndef INTERPRETER_USE_SWITCH */
+ estack_init(stack);
+
START_OP
OP(FILTER_OP_UNKNOWN):
goto end;
OP(FILTER_OP_RETURN):
- retval = !!reg[0].v;
+ retval = !!estack_ax(stack)->u.v;
ret = 0;
goto end;
OP(FILTER_OP_EQ_STRING):
{
- reg[REG_R0].v = (reg_strcmp(reg, "==") == 0);
- reg[REG_R0].type = REG_S64;
+ int res;
+
+ res = (stack_strcmp(stack, "==") == 0);
+ estack_pop(stack);
+ estack_ax(stack)->u.v = res;
+ estack_ax(stack)->type = REG_S64;
next_pc += sizeof(struct binary_op);
PO;
}
OP(FILTER_OP_NE_STRING):
{
- reg[REG_R0].v = (reg_strcmp(reg, "!=") != 0);
- reg[REG_R0].type = REG_S64;
+ int res;
+
+ res = (stack_strcmp(stack, "!=") != 0);
+ estack_pop(stack);
+ estack_ax(stack)->u.v = res;
+ estack_ax(stack)->type = REG_S64;
next_pc += sizeof(struct binary_op);
PO;
}
OP(FILTER_OP_GT_STRING):
{
- reg[REG_R0].v = (reg_strcmp(reg, ">") > 0);
- reg[REG_R0].type = REG_S64;
+ int res;
+
+ res = (stack_strcmp(stack, ">") > 0);
+ estack_pop(stack);
+ estack_ax(stack)->u.v = res;
+ estack_ax(stack)->type = REG_S64;
next_pc += sizeof(struct binary_op);
PO;
}
OP(FILTER_OP_LT_STRING):
{
- reg[REG_R0].v = (reg_strcmp(reg, "<") < 0);
- reg[REG_R0].type = REG_S64;
+ int res;
+
+ res = (stack_strcmp(stack, "<") < 0);
+ estack_pop(stack);
+ estack_ax(stack)->u.v = res;
+ estack_ax(stack)->type = REG_S64;
next_pc += sizeof(struct binary_op);
PO;
}
OP(FILTER_OP_GE_STRING):
{
- reg[REG_R0].v = (reg_strcmp(reg, ">=") >= 0);
- reg[REG_R0].type = REG_S64;
+ int res;
+
+ res = (stack_strcmp(stack, ">=") >= 0);
+ estack_pop(stack);
+ estack_ax(stack)->u.v = res;
+ estack_ax(stack)->type = REG_S64;
next_pc += sizeof(struct binary_op);
PO;
}
OP(FILTER_OP_LE_STRING):
{
- reg[REG_R0].v = (reg_strcmp(reg, "<=") <= 0);
- reg[REG_R0].type = REG_S64;
+ int res;
+
+ res = (stack_strcmp(stack, "<=") <= 0);
+ estack_pop(stack);
+ estack_ax(stack)->u.v = res;
+ estack_ax(stack)->type = REG_S64;
next_pc += sizeof(struct binary_op);
PO;
}
OP(FILTER_OP_EQ_S64):
{
- reg[REG_R0].v = (reg[REG_R0].v == reg[REG_R1].v);
- reg[REG_R0].type = REG_S64;
+ int res;
+
+ res = (estack_bx(stack)->u.v == estack_ax(stack)->u.v);
+ estack_pop(stack);
+ estack_ax(stack)->u.v = res;
+ estack_ax(stack)->type = REG_S64;
next_pc += sizeof(struct binary_op);
PO;
}
OP(FILTER_OP_NE_S64):
{
- reg[REG_R0].v = (reg[REG_R0].v != reg[REG_R1].v);
- reg[REG_R0].type = REG_S64;
+ int res;
+
+ res = (estack_bx(stack)->u.v != estack_ax(stack)->u.v);
+ estack_pop(stack);
+ estack_ax(stack)->u.v = res;
+ estack_ax(stack)->type = REG_S64;
next_pc += sizeof(struct binary_op);
PO;
}
OP(FILTER_OP_GT_S64):
{
- reg[REG_R0].v = (reg[REG_R0].v > reg[REG_R1].v);
- reg[REG_R0].type = REG_S64;
+ int res;
+
+ res = (estack_bx(stack)->u.v > estack_ax(stack)->u.v);
+ estack_pop(stack);
+ estack_ax(stack)->u.v = res;
+ estack_ax(stack)->type = REG_S64;
next_pc += sizeof(struct binary_op);
PO;
}
OP(FILTER_OP_LT_S64):
{
- reg[REG_R0].v = (reg[REG_R0].v < reg[REG_R1].v);
- reg[REG_R0].type = REG_S64;
+ int res;
+
+ res = (estack_bx(stack)->u.v < estack_ax(stack)->u.v);
+ estack_pop(stack);
+ estack_ax(stack)->u.v = res;
+ estack_ax(stack)->type = REG_S64;
next_pc += sizeof(struct binary_op);
PO;
}
OP(FILTER_OP_GE_S64):
{
- reg[REG_R0].v = (reg[REG_R0].v >= reg[REG_R1].v);
- reg[REG_R0].type = REG_S64;
+ int res;
+
+ res = (estack_bx(stack)->u.v >= estack_ax(stack)->u.v);
+ estack_pop(stack);
+ estack_ax(stack)->u.v = res;
+ estack_ax(stack)->type = REG_S64;
next_pc += sizeof(struct binary_op);
PO;
}
OP(FILTER_OP_LE_S64):
{
- reg[REG_R0].v = (reg[REG_R0].v <= reg[REG_R1].v);
- reg[REG_R0].type = REG_S64;
+ int res;
+
+ res = (estack_bx(stack)->u.v <= estack_ax(stack)->u.v);
+ estack_pop(stack);
+ estack_ax(stack)->u.v = res;
+ estack_ax(stack)->type = REG_S64;
next_pc += sizeof(struct binary_op);
PO;
}
OP(FILTER_OP_EQ_DOUBLE):
{
- if (unlikely(reg[REG_R0].type == REG_S64))
- reg[REG_R0].d = (double) reg[REG_R0].v;
- else if (unlikely(reg[REG_R1].type == REG_S64))
- reg[REG_R1].d = (double) reg[REG_R1].v;
- reg[REG_R0].v = (reg[REG_R0].d == reg[REG_R1].d);
- reg[REG_R0].type = REG_S64;
+ int res;
+
+ if (unlikely(estack_ax(stack)->type == REG_S64))
+ estack_ax(stack)->u.d = (double) estack_ax(stack)->u.v;
+ else if (unlikely(estack_bx(stack)->type == REG_S64))
+ estack_bx(stack)->u.d = (double) estack_bx(stack)->u.v;
+ res = (estack_bx(stack)->u.v == estack_ax(stack)->u.v);
+ estack_pop(stack);
+ estack_ax(stack)->u.v = res;
+ estack_ax(stack)->type = REG_S64;
next_pc += sizeof(struct binary_op);
PO;
}
OP(FILTER_OP_NE_DOUBLE):
{
- if (unlikely(reg[REG_R0].type == REG_S64))
- reg[REG_R0].d = (double) reg[REG_R0].v;
- else if (unlikely(reg[REG_R1].type == REG_S64))
- reg[REG_R1].d = (double) reg[REG_R1].v;
- reg[REG_R0].v = (reg[REG_R0].d != reg[REG_R1].d);
- reg[REG_R0].type = REG_S64;
+ int res;
+
+ if (unlikely(estack_ax(stack)->type == REG_S64))
+ estack_ax(stack)->u.d = (double) estack_ax(stack)->u.v;
+ else if (unlikely(estack_bx(stack)->type == REG_S64))
+ estack_bx(stack)->u.d = (double) estack_bx(stack)->u.v;
+ res = (estack_bx(stack)->u.v != estack_ax(stack)->u.v);
+ estack_pop(stack);
+ estack_ax(stack)->u.v = res;
+ estack_ax(stack)->type = REG_S64;
next_pc += sizeof(struct binary_op);
PO;
}
OP(FILTER_OP_GT_DOUBLE):
{
- if (unlikely(reg[REG_R0].type == REG_S64))
- reg[REG_R0].d = (double) reg[REG_R0].v;
- else if (unlikely(reg[REG_R1].type == REG_S64))
- reg[REG_R1].d = (double) reg[REG_R1].v;
- reg[REG_R0].v = (reg[REG_R0].d > reg[REG_R1].d);
- reg[REG_R0].type = REG_S64;
+ int res;
+
+ if (unlikely(estack_ax(stack)->type == REG_S64))
+ estack_ax(stack)->u.d = (double) estack_ax(stack)->u.v;
+ else if (unlikely(estack_bx(stack)->type == REG_S64))
+ estack_bx(stack)->u.d = (double) estack_bx(stack)->u.v;
+ res = (estack_bx(stack)->u.v > estack_ax(stack)->u.v);
+ estack_pop(stack);
+ estack_ax(stack)->u.v = res;
+ estack_ax(stack)->type = REG_S64;
next_pc += sizeof(struct binary_op);
PO;
}
OP(FILTER_OP_LT_DOUBLE):
{
- if (unlikely(reg[REG_R0].type == REG_S64))
- reg[REG_R0].d = (double) reg[REG_R0].v;
- else if (unlikely(reg[REG_R1].type == REG_S64))
- reg[REG_R1].d = (double) reg[REG_R1].v;
- reg[REG_R0].v = (reg[REG_R0].d < reg[REG_R1].d);
- reg[REG_R0].type = REG_S64;
+ int res;
+
+ if (unlikely(estack_ax(stack)->type == REG_S64))
+ estack_ax(stack)->u.d = (double) estack_ax(stack)->u.v;
+ else if (unlikely(estack_bx(stack)->type == REG_S64))
+ estack_bx(stack)->u.d = (double) estack_bx(stack)->u.v;
+ res = (estack_bx(stack)->u.v < estack_ax(stack)->u.v);
+ estack_pop(stack);
+ estack_ax(stack)->u.v = res;
+ estack_ax(stack)->type = REG_S64;
next_pc += sizeof(struct binary_op);
PO;
}
OP(FILTER_OP_GE_DOUBLE):
{
- if (unlikely(reg[REG_R0].type == REG_S64))
- reg[REG_R0].d = (double) reg[REG_R0].v;
- else if (unlikely(reg[REG_R1].type == REG_S64))
- reg[REG_R1].d = (double) reg[REG_R1].v;
- reg[REG_R0].v = (reg[REG_R0].d >= reg[REG_R1].d);
- reg[REG_R0].type = REG_S64;
+ int res;
+
+ if (unlikely(estack_ax(stack)->type == REG_S64))
+ estack_ax(stack)->u.d = (double) estack_ax(stack)->u.v;
+ else if (unlikely(estack_bx(stack)->type == REG_S64))
+ estack_bx(stack)->u.d = (double) estack_bx(stack)->u.v;
+ res = (estack_bx(stack)->u.v >= estack_ax(stack)->u.v);
+ estack_pop(stack);
+ estack_ax(stack)->u.v = res;
+ estack_ax(stack)->type = REG_S64;
next_pc += sizeof(struct binary_op);
PO;
}
OP(FILTER_OP_LE_DOUBLE):
{
- if (unlikely(reg[REG_R0].type == REG_S64))
- reg[REG_R0].d = (double) reg[REG_R0].v;
- else if (unlikely(reg[REG_R1].type == REG_S64))
- reg[REG_R1].d = (double) reg[REG_R1].v;
- reg[REG_R0].v = (reg[REG_R0].d <= reg[REG_R1].d);
- reg[REG_R0].type = REG_S64;
+ int res;
+
+ if (unlikely(estack_ax(stack)->type == REG_S64))
+ estack_ax(stack)->u.d = (double) estack_ax(stack)->u.v;
+ else if (unlikely(estack_bx(stack)->type == REG_S64))
+ estack_bx(stack)->u.d = (double) estack_bx(stack)->u.v;
+ res = (estack_bx(stack)->u.v <= estack_ax(stack)->u.v);
+ estack_pop(stack);
+ estack_ax(stack)->u.v = res;
+ estack_ax(stack)->type = REG_S64;
next_pc += sizeof(struct binary_op);
PO;
}
}
OP(FILTER_OP_UNARY_MINUS_S64):
{
- struct unary_op *insn = (struct unary_op *) pc;
-
- reg[insn->reg].v = -reg[insn->reg].v;
+ estack_ax(stack)->u.v = -estack_ax(stack)->u.v;
next_pc += sizeof(struct unary_op);
PO;
}
OP(FILTER_OP_UNARY_MINUS_DOUBLE):
{
- struct unary_op *insn = (struct unary_op *) pc;
-
- reg[insn->reg].d = -reg[insn->reg].d;
+ estack_ax(stack)->u.d = -estack_ax(stack)->u.d;
next_pc += sizeof(struct unary_op);
PO;
}
OP(FILTER_OP_UNARY_NOT_S64):
{
- struct unary_op *insn = (struct unary_op *) pc;
-
- reg[insn->reg].v = !reg[insn->reg].v;
+ estack_ax(stack)->u.v = !estack_ax(stack)->u.v;
next_pc += sizeof(struct unary_op);
PO;
}
OP(FILTER_OP_UNARY_NOT_DOUBLE):
{
- struct unary_op *insn = (struct unary_op *) pc;
-
- reg[insn->reg].d = !reg[insn->reg].d;
+ estack_ax(stack)->u.d = !estack_ax(stack)->u.d;
next_pc += sizeof(struct unary_op);
PO;
}
{
struct logical_op *insn = (struct logical_op *) pc;
- /* If REG_R0 is 0, skip and evaluate to 0 */
- if (unlikely(reg[REG_R0].v == 0)) {
+ /* If AX is 0, skip and evaluate to 0 */
+ if (unlikely(estack_ax(stack)->u.v == 0)) {
dbg_printf("Jumping to bytecode offset %u\n",
(unsigned int) insn->skip_offset);
next_pc = start_pc + insn->skip_offset;
{
struct logical_op *insn = (struct logical_op *) pc;
- /* If REG_R0 is nonzero, skip and evaluate to 1 */
+ /* If AX is nonzero, skip and evaluate to 1 */
- if (unlikely(reg[REG_R0].v != 0)) {
- reg[REG_R0].v = 1;
+ if (unlikely(estack_ax(stack)->u.v != 0)) {
+ estack_ax(stack)->u.v = 1;
dbg_printf("Jumping to bytecode offset %u\n",
(unsigned int) insn->skip_offset);
next_pc = start_pc + insn->skip_offset;
dbg_printf("load field ref offset %u type string\n",
ref->offset);
- reg[insn->reg].str =
+ estack_push(stack);
+ estack_ax(stack)->u.s.str =
*(const char * const *) &filter_stack_data[ref->offset];
- if (unlikely(!reg[insn->reg].str)) {
+ if (unlikely(!estack_ax(stack)->u.s.str)) {
dbg_printf("Filter warning: loading a NULL string.\n");
ret = -EINVAL;
goto end;
}
- reg[insn->reg].type = REG_STRING;
- reg[insn->reg].seq_len = UINT_MAX;
- reg[insn->reg].literal = 0;
- dbg_printf("ref load string %s\n", reg[insn->reg].str);
+ estack_ax(stack)->type = REG_STRING;
+ estack_ax(stack)->u.s.seq_len = UINT_MAX;
+ estack_ax(stack)->u.s.literal = 0;
+ dbg_printf("ref load string %s\n", estack_ax(stack)->u.s.str);
next_pc += sizeof(struct load_op) + sizeof(struct field_ref);
PO;
}
dbg_printf("load field ref offset %u type sequence\n",
ref->offset);
- reg[insn->reg].seq_len =
+ estack_push(stack);
+ estack_ax(stack)->u.s.seq_len =
*(unsigned long *) &filter_stack_data[ref->offset];
- reg[insn->reg].str =
+ estack_ax(stack)->u.s.str =
*(const char **) (&filter_stack_data[ref->offset
+ sizeof(unsigned long)]);
- if (unlikely(!reg[insn->reg].str)) {
+ if (unlikely(!estack_ax(stack)->u.s.str)) {
dbg_printf("Filter warning: loading a NULL sequence.\n");
ret = -EINVAL;
goto end;
}
- reg[insn->reg].type = REG_STRING;
- reg[insn->reg].literal = 0;
+ estack_ax(stack)->type = REG_STRING;
+ estack_ax(stack)->u.s.literal = 0;
next_pc += sizeof(struct load_op) + sizeof(struct field_ref);
PO;
}
dbg_printf("load field ref offset %u type s64\n",
ref->offset);
- memcpy(®[insn->reg].v, &filter_stack_data[ref->offset],
+ estack_push(stack);
+ memcpy(&estack_ax(stack)->u.v, &filter_stack_data[ref->offset],
sizeof(struct literal_numeric));
- reg[insn->reg].type = REG_S64;
- dbg_printf("ref load s64 %" PRIi64 "\n", reg[insn->reg].v);
+ estack_ax(stack)->type = REG_S64;
+ dbg_printf("ref load s64 %" PRIi64 "\n", estack_ax(stack)->u.v);
next_pc += sizeof(struct load_op) + sizeof(struct field_ref);
PO;
}
dbg_printf("load field ref offset %u type double\n",
ref->offset);
- memcpy(®[insn->reg].d, &filter_stack_data[ref->offset],
+ estack_push(stack);
+ memcpy(&estack_ax(stack)->u.d, &filter_stack_data[ref->offset],
sizeof(struct literal_double));
- reg[insn->reg].type = REG_DOUBLE;
- dbg_printf("ref load double %g\n", reg[insn->reg].d);
+ estack_ax(stack)->type = REG_DOUBLE;
+ dbg_printf("ref load double %g\n", estack_ax(stack)->u.d);
next_pc += sizeof(struct load_op) + sizeof(struct field_ref);
PO;
}
struct load_op *insn = (struct load_op *) pc;
dbg_printf("load string %s\n", insn->data);
- reg[insn->reg].str = insn->data;
- reg[insn->reg].type = REG_STRING;
- reg[insn->reg].seq_len = UINT_MAX;
- reg[insn->reg].literal = 1;
+ estack_push(stack);
+ estack_ax(stack)->type = REG_STRING;
+ estack_ax(stack)->u.s.str = insn->data;
+ estack_ax(stack)->u.s.seq_len = UINT_MAX;
+ estack_ax(stack)->u.s.literal = 1;
next_pc += sizeof(struct load_op) + strlen(insn->data) + 1;
PO;
}
{
struct load_op *insn = (struct load_op *) pc;
- memcpy(®[insn->reg].v, insn->data,
+ estack_push(stack);
+ memcpy(&estack_ax(stack)->u.v, insn->data,
sizeof(struct literal_numeric));
- dbg_printf("load s64 %" PRIi64 "\n", reg[insn->reg].v);
- reg[insn->reg].type = REG_S64;
+ dbg_printf("load s64 %" PRIi64 "\n", estack_ax(stack)->u.v);
+ estack_ax(stack)->type = REG_S64;
next_pc += sizeof(struct load_op)
+ sizeof(struct literal_numeric);
PO;
{
struct load_op *insn = (struct load_op *) pc;
- memcpy(®[insn->reg].d, insn->data,
+ estack_push(stack);
+ memcpy(&estack_ax(stack)->u.d, insn->data,
sizeof(struct literal_double));
- dbg_printf("load s64 %g\n", reg[insn->reg].d);
- reg[insn->reg].type = REG_DOUBLE;
+ dbg_printf("load s64 %g\n", estack_ax(stack)->u.d);
+ estack_ax(stack)->type = REG_DOUBLE;
next_pc += sizeof(struct load_op)
+ sizeof(struct literal_double);
PO;
OP(FILTER_OP_CAST_DOUBLE_TO_S64):
{
- struct cast_op *insn = (struct cast_op *) pc;
-
- reg[insn->reg].v = (int64_t) reg[insn->reg].d;
- reg[insn->reg].type = REG_S64;
+ estack_ax(stack)->u.v = (int64_t) estack_ax(stack)->u.d;
+ estack_ax(stack)->type = REG_S64;
next_pc += sizeof(struct cast_op);
PO;
}
{
void *pc, *next_pc, *start_pc;
int ret = -EINVAL;
- struct vreg reg[NR_REG];
- int i;
+ struct vstack _stack;
+ struct vstack *stack = &_stack;
- for (i = 0; i < NR_REG; i++) {
- reg[i].type = REG_TYPE_UNKNOWN;
- reg[i].literal = 0;
- }
+ vstack_init(stack);
start_pc = &bytecode->data[0];
for (pc = next_pc = start_pc; pc - start_pc < bytecode->len;
{
struct binary_op *insn = (struct binary_op *) pc;
- switch(reg[REG_R0].type) {
+ switch(vstack_ax(stack)->type) {
default:
ERR("unknown register type\n");
ret = -EINVAL;
insn->op = FILTER_OP_EQ_STRING;
break;
case REG_S64:
- if (reg[REG_R1].type == REG_S64)
+ if (vstack_bx(stack)->type == REG_S64)
insn->op = FILTER_OP_EQ_S64;
else
insn->op = FILTER_OP_EQ_DOUBLE;
insn->op = FILTER_OP_EQ_DOUBLE;
break;
}
- reg[REG_R0].type = REG_S64;
+ /* Pop 2, push 1 */
+ if (vstack_pop(stack)) {
+ ret = -EINVAL;
+ goto end;
+ }
+ vstack_ax(stack)->type = REG_S64;
next_pc += sizeof(struct binary_op);
break;
}
{
struct binary_op *insn = (struct binary_op *) pc;
- switch(reg[REG_R0].type) {
+ switch(vstack_ax(stack)->type) {
default:
ERR("unknown register type\n");
ret = -EINVAL;
insn->op = FILTER_OP_NE_STRING;
break;
case REG_S64:
- if (reg[REG_R1].type == REG_S64)
+ if (vstack_bx(stack)->type == REG_S64)
insn->op = FILTER_OP_NE_S64;
else
insn->op = FILTER_OP_NE_DOUBLE;
insn->op = FILTER_OP_NE_DOUBLE;
break;
}
- reg[REG_R0].type = REG_S64;
+ /* Pop 2, push 1 */
+ if (vstack_pop(stack)) {
+ ret = -EINVAL;
+ goto end;
+ }
+ vstack_ax(stack)->type = REG_S64;
next_pc += sizeof(struct binary_op);
break;
}
{
struct binary_op *insn = (struct binary_op *) pc;
- switch(reg[REG_R0].type) {
+ switch(vstack_ax(stack)->type) {
default:
ERR("unknown register type\n");
ret = -EINVAL;
insn->op = FILTER_OP_GT_STRING;
break;
case REG_S64:
- if (reg[REG_R1].type == REG_S64)
+ if (vstack_bx(stack)->type == REG_S64)
insn->op = FILTER_OP_GT_S64;
else
insn->op = FILTER_OP_GT_DOUBLE;
insn->op = FILTER_OP_GT_DOUBLE;
break;
}
- reg[REG_R0].type = REG_S64;
+ /* Pop 2, push 1 */
+ if (vstack_pop(stack)) {
+ ret = -EINVAL;
+ goto end;
+ }
+ vstack_ax(stack)->type = REG_S64;
next_pc += sizeof(struct binary_op);
break;
}
{
struct binary_op *insn = (struct binary_op *) pc;
- switch(reg[REG_R0].type) {
+ switch(vstack_ax(stack)->type) {
default:
ERR("unknown register type\n");
ret = -EINVAL;
insn->op = FILTER_OP_LT_STRING;
break;
case REG_S64:
- if (reg[REG_R1].type == REG_S64)
+ if (vstack_bx(stack)->type == REG_S64)
insn->op = FILTER_OP_LT_S64;
else
insn->op = FILTER_OP_LT_DOUBLE;
insn->op = FILTER_OP_LT_DOUBLE;
break;
}
- reg[REG_R0].type = REG_S64;
+ /* Pop 2, push 1 */
+ if (vstack_pop(stack)) {
+ ret = -EINVAL;
+ goto end;
+ }
+ vstack_ax(stack)->type = REG_S64;
next_pc += sizeof(struct binary_op);
break;
}
{
struct binary_op *insn = (struct binary_op *) pc;
- switch(reg[REG_R0].type) {
+ switch(vstack_ax(stack)->type) {
default:
ERR("unknown register type\n");
ret = -EINVAL;
insn->op = FILTER_OP_GE_STRING;
break;
case REG_S64:
- if (reg[REG_R1].type == REG_S64)
+ if (vstack_bx(stack)->type == REG_S64)
insn->op = FILTER_OP_GE_S64;
else
insn->op = FILTER_OP_GE_DOUBLE;
insn->op = FILTER_OP_GE_DOUBLE;
break;
}
- reg[REG_R0].type = REG_S64;
+ /* Pop 2, push 1 */
+ if (vstack_pop(stack)) {
+ ret = -EINVAL;
+ goto end;
+ }
+ vstack_ax(stack)->type = REG_S64;
next_pc += sizeof(struct binary_op);
break;
}
{
struct binary_op *insn = (struct binary_op *) pc;
- switch(reg[REG_R0].type) {
+ switch(vstack_ax(stack)->type) {
default:
ERR("unknown register type\n");
ret = -EINVAL;
insn->op = FILTER_OP_LE_STRING;
break;
case REG_S64:
- if (reg[REG_R1].type == REG_S64)
+ if (vstack_bx(stack)->type == REG_S64)
insn->op = FILTER_OP_LE_S64;
else
insn->op = FILTER_OP_LE_DOUBLE;
insn->op = FILTER_OP_LE_DOUBLE;
break;
}
- reg[REG_R0].type = REG_S64;
+ vstack_ax(stack)->type = REG_S64;
next_pc += sizeof(struct binary_op);
break;
}
case FILTER_OP_GE_DOUBLE:
case FILTER_OP_LE_DOUBLE:
{
- reg[REG_R0].type = REG_S64;
+ /* Pop 2, push 1 */
+ if (vstack_pop(stack)) {
+ ret = -EINVAL;
+ goto end;
+ }
+ vstack_ax(stack)->type = REG_S64;
next_pc += sizeof(struct binary_op);
break;
}
{
struct unary_op *insn = (struct unary_op *) pc;
- switch(reg[insn->reg].type) {
+ switch(vstack_ax(stack)->type) {
default:
ERR("unknown register type\n");
ret = -EINVAL;
insn->op = FILTER_OP_UNARY_PLUS_DOUBLE;
break;
}
+ /* Pop 1, push 1 */
next_pc += sizeof(struct unary_op);
break;
}
{
struct unary_op *insn = (struct unary_op *) pc;
- switch(reg[insn->reg].type) {
+ switch(vstack_ax(stack)->type) {
default:
ERR("unknown register type\n");
ret = -EINVAL;
insn->op = FILTER_OP_UNARY_MINUS_DOUBLE;
break;
}
+ /* Pop 1, push 1 */
next_pc += sizeof(struct unary_op);
break;
}
{
struct unary_op *insn = (struct unary_op *) pc;
- switch(reg[insn->reg].type) {
+ switch(vstack_ax(stack)->type) {
default:
ERR("unknown register type\n");
ret = -EINVAL;
insn->op = FILTER_OP_UNARY_NOT_DOUBLE;
break;
}
+ /* Pop 1, push 1 */
next_pc += sizeof(struct unary_op);
break;
}
case FILTER_OP_UNARY_MINUS_DOUBLE:
case FILTER_OP_UNARY_NOT_DOUBLE:
{
+ /* Pop 1, push 1 */
next_pc += sizeof(struct unary_op);
break;
}
case FILTER_OP_LOAD_FIELD_REF_STRING:
case FILTER_OP_LOAD_FIELD_REF_SEQUENCE:
{
- struct load_op *insn = (struct load_op *) pc;
-
- reg[insn->reg].type = REG_STRING;
- reg[insn->reg].literal = 0;
+ if (vstack_push(stack)) {
+ ret = -EINVAL;
+ goto end;
+ }
+ vstack_ax(stack)->type = REG_STRING;
next_pc += sizeof(struct load_op) + sizeof(struct field_ref);
break;
}
case FILTER_OP_LOAD_FIELD_REF_S64:
{
- struct load_op *insn = (struct load_op *) pc;
-
- reg[insn->reg].type = REG_S64;
- reg[insn->reg].literal = 0;
+ if (vstack_push(stack)) {
+ ret = -EINVAL;
+ goto end;
+ }
+ vstack_ax(stack)->type = REG_S64;
next_pc += sizeof(struct load_op) + sizeof(struct field_ref);
break;
}
case FILTER_OP_LOAD_FIELD_REF_DOUBLE:
{
- struct load_op *insn = (struct load_op *) pc;
-
- reg[insn->reg].type = REG_DOUBLE;
- reg[insn->reg].literal = 0;
+ if (vstack_push(stack)) {
+ ret = -EINVAL;
+ goto end;
+ }
+ vstack_ax(stack)->type = REG_DOUBLE;
next_pc += sizeof(struct load_op) + sizeof(struct field_ref);
break;
}
{
struct load_op *insn = (struct load_op *) pc;
- reg[insn->reg].type = REG_STRING;
- reg[insn->reg].literal = 1;
+ if (vstack_push(stack)) {
+ ret = -EINVAL;
+ goto end;
+ }
+ vstack_ax(stack)->type = REG_STRING;
next_pc += sizeof(struct load_op) + strlen(insn->data) + 1;
break;
}
case FILTER_OP_LOAD_S64:
{
- struct load_op *insn = (struct load_op *) pc;
-
- reg[insn->reg].type = REG_S64;
- reg[insn->reg].literal = 1;
+ if (vstack_push(stack)) {
+ ret = -EINVAL;
+ goto end;
+ }
+ vstack_ax(stack)->type = REG_S64;
next_pc += sizeof(struct load_op)
+ sizeof(struct literal_numeric);
break;
case FILTER_OP_LOAD_DOUBLE:
{
- struct load_op *insn = (struct load_op *) pc;
-
- reg[insn->reg].type = REG_DOUBLE;
- reg[insn->reg].literal = 1;
+ if (vstack_push(stack)) {
+ ret = -EINVAL;
+ goto end;
+ }
+ vstack_ax(stack)->type = REG_DOUBLE;
next_pc += sizeof(struct load_op)
+ sizeof(struct literal_double);
break;
{
struct cast_op *insn = (struct cast_op *) pc;
- switch (reg[insn->reg].type) {
+ switch (vstack_ax(stack)->type) {
default:
ERR("unknown register type\n");
ret = -EINVAL;
insn->op = FILTER_OP_CAST_DOUBLE_TO_S64;
break;
}
- reg[insn->reg].type = REG_S64;
+ /* Pop 1, push 1 */
+ vstack_ax(stack)->type = REG_S64;
next_pc += sizeof(struct cast_op);
break;
}
case FILTER_OP_CAST_DOUBLE_TO_S64:
{
- struct cast_op *insn = (struct cast_op *) pc;
-
- reg[insn->reg].type = REG_S64;
+ /* Pop 1, push 1 */
+ vstack_ax(stack)->type = REG_S64;
next_pc += sizeof(struct cast_op);
break;
}
#include <urcu/rculfhash.h>
#include "lttng-hash-helper.h"
+/*
+ * Number of merge points for hash table size. Hash table initialized to
+ * that size, and we do not resize, because we do not want to trigger
+ * RCU worker thread execution: fall-back on linear traversal if number
+ * of merge points exceeds this value.
+ */
+#define DEFAULT_NR_MERGE_POINTS 128
+#define MIN_NR_BUCKETS 128
+#define MAX_NR_BUCKETS 128
+
/* merge point table node */
struct lfht_mp_node {
struct cds_lfht_node node;
/* Context at merge point */
- struct vreg reg[NR_REG];
+ struct vstack stack;
unsigned long target_pc;
};
static
int merge_point_add(struct cds_lfht *ht, unsigned long target_pc,
- const struct vreg reg[NR_REG])
+ const struct vstack *stack)
{
struct lfht_mp_node *node;
unsigned long hash = lttng_hash_mix((const void *) target_pc,
if (!node)
return -ENOMEM;
node->target_pc = target_pc;
- memcpy(node->reg, reg, sizeof(node->reg));
+ memcpy(&node->stack, stack, sizeof(node->stack));
cds_lfht_add(ht, hash, &node->node);
return 0;
}
/*
- * Number of merge points for hash table size. Hash table initialized to
- * that size, and we do not resize, because we do not want to trigger
- * RCU worker thread execution: fall-back on linear traversal if number
- * of merge points exceeds this value.
+ * Binary comparators use top of stack and top of stack -1.
*/
-#define DEFAULT_NR_MERGE_POINTS 128
-#define MIN_NR_BUCKETS 128
-#define MAX_NR_BUCKETS 128
-
static
-int bin_op_compare_check(const struct vreg reg[NR_REG], const char *str)
+int bin_op_compare_check(struct vstack *stack, const char *str)
{
- switch (reg[REG_R0].type) {
+ if (unlikely(!vstack_ax(stack) || !vstack_bx(stack)))
+ goto error_unknown;
+
+ switch (vstack_ax(stack)->type) {
default:
goto error_unknown;
case REG_STRING:
- switch (reg[REG_R1].type) {
+ switch (vstack_bx(stack)->type) {
default:
goto error_unknown;
break;
case REG_S64:
case REG_DOUBLE:
- switch (reg[REG_R1].type) {
+ switch (vstack_bx(stack)->type) {
default:
goto error_unknown;
return 0;
error_unknown:
-
return -EINVAL;
+
error_mismatch:
ERR("type mismatch for '%s' binary operator\n", str);
return -EINVAL;
*/
static
int validate_instruction_context(struct bytecode_runtime *bytecode,
- const struct vreg reg[NR_REG],
+ struct vstack *stack,
void *start_pc,
void *pc)
{
case FILTER_OP_EQ:
{
- ret = bin_op_compare_check(reg, "==");
+ ret = bin_op_compare_check(stack, "==");
if (ret)
goto end;
break;
}
case FILTER_OP_NE:
{
- ret = bin_op_compare_check(reg, "!=");
+ ret = bin_op_compare_check(stack, "!=");
if (ret)
goto end;
break;
}
case FILTER_OP_GT:
{
- ret = bin_op_compare_check(reg, ">");
+ ret = bin_op_compare_check(stack, ">");
if (ret)
goto end;
break;
}
case FILTER_OP_LT:
{
- ret = bin_op_compare_check(reg, "<");
+ ret = bin_op_compare_check(stack, "<");
if (ret)
goto end;
break;
}
case FILTER_OP_GE:
{
- ret = bin_op_compare_check(reg, ">=");
+ ret = bin_op_compare_check(stack, ">=");
if (ret)
goto end;
break;
}
case FILTER_OP_LE:
{
- ret = bin_op_compare_check(reg, "<=");
+ ret = bin_op_compare_check(stack, "<=");
if (ret)
goto end;
break;
case FILTER_OP_GE_STRING:
case FILTER_OP_LE_STRING:
{
- if (reg[REG_R0].type != REG_STRING
- || reg[REG_R1].type != REG_STRING) {
+ if (!vstack_ax(stack) || !vstack_bx(stack)) {
+ ERR("Empty stack\n");
+ ret = -EINVAL;
+ goto end;
+ }
+ if (vstack_ax(stack)->type != REG_STRING
+ || vstack_bx(stack)->type != REG_STRING) {
ERR("Unexpected register type for string comparator\n");
ret = -EINVAL;
goto end;
case FILTER_OP_GE_S64:
case FILTER_OP_LE_S64:
{
- if (reg[REG_R0].type != REG_S64
- || reg[REG_R1].type != REG_S64) {
+ if (!vstack_ax(stack) || !vstack_bx(stack)) {
+ ERR("Empty stack\n");
+ ret = -EINVAL;
+ goto end;
+ }
+ if (vstack_ax(stack)->type != REG_S64
+ || vstack_bx(stack)->type != REG_S64) {
ERR("Unexpected register type for s64 comparator\n");
ret = -EINVAL;
goto end;
case FILTER_OP_GE_DOUBLE:
case FILTER_OP_LE_DOUBLE:
{
- if ((reg[REG_R0].type != REG_DOUBLE && reg[REG_R0].type != REG_S64)
- || (reg[REG_R1].type != REG_DOUBLE && reg[REG_R1].type != REG_S64)) {
+ if (!vstack_ax(stack) || !vstack_bx(stack)) {
+ ERR("Empty stack\n");
+ ret = -EINVAL;
+ goto end;
+ }
+ if ((vstack_ax(stack)->type != REG_DOUBLE && vstack_ax(stack)->type != REG_S64)
+ || (vstack_bx(stack)-> type != REG_DOUBLE && vstack_bx(stack)->type != REG_S64)) {
ERR("Unexpected register type for double comparator\n");
ret = -EINVAL;
goto end;
}
- if (reg[REG_R0].type != REG_DOUBLE && reg[REG_R1].type != REG_DOUBLE) {
+ if (vstack_ax(stack)->type != REG_DOUBLE && vstack_bx(stack)->type != REG_DOUBLE) {
ERR("Double operator should have at least one double register\n");
ret = -EINVAL;
goto end;
case FILTER_OP_UNARY_MINUS:
case FILTER_OP_UNARY_NOT:
{
- struct unary_op *insn = (struct unary_op *) pc;
-
- if (unlikely(insn->reg >= REG_ERROR)) {
- ERR("invalid register %u\n",
- (unsigned int) insn->reg);
+ if (!vstack_ax(stack)) {
+ ERR("Empty stack\n");
ret = -EINVAL;
goto end;
}
- switch (reg[insn->reg].type) {
+ switch (vstack_ax(stack)->type) {
default:
ERR("unknown register type\n");
ret = -EINVAL;
case FILTER_OP_UNARY_MINUS_S64:
case FILTER_OP_UNARY_NOT_S64:
{
- struct unary_op *insn = (struct unary_op *) pc;
-
- if (unlikely(insn->reg >= REG_ERROR)) {
- ERR("invalid register %u\n",
- (unsigned int) insn->reg);
+ if (!vstack_ax(stack)) {
+ ERR("Empty stack\n");
ret = -EINVAL;
goto end;
}
- if (reg[insn->reg].type != REG_S64) {
+ if (vstack_ax(stack)->type != REG_S64) {
ERR("Invalid register type\n");
ret = -EINVAL;
goto end;
case FILTER_OP_UNARY_MINUS_DOUBLE:
case FILTER_OP_UNARY_NOT_DOUBLE:
{
- struct unary_op *insn = (struct unary_op *) pc;
-
- if (unlikely(insn->reg >= REG_ERROR)) {
- ERR("invalid register %u\n",
- (unsigned int) insn->reg);
+ if (!vstack_ax(stack)) {
+ ERR("Empty stack\n");
ret = -EINVAL;
goto end;
}
- if (reg[insn->reg].type != REG_DOUBLE) {
+ if (vstack_ax(stack)->type != REG_DOUBLE) {
ERR("Invalid register type\n");
ret = -EINVAL;
goto end;
{
struct logical_op *insn = (struct logical_op *) pc;
- if (reg[REG_R0].type != REG_S64) {
+ if (!vstack_ax(stack)) {
+ ERR("Empty stack\n");
+ ret = -EINVAL;
+ goto end;
+ }
+ if (vstack_ax(stack)->type != REG_S64) {
ERR("Logical comparator expects S64 register\n");
ret = -EINVAL;
goto end;
struct load_op *insn = (struct load_op *) pc;
struct field_ref *ref = (struct field_ref *) insn->data;
- if (unlikely(insn->reg >= REG_ERROR)) {
- ERR("invalid register %u\n",
- (unsigned int) insn->reg);
- ret = -EINVAL;
- goto end;
- }
dbg_printf("Validate load field ref offset %u type string\n",
ref->offset);
break;
struct load_op *insn = (struct load_op *) pc;
struct field_ref *ref = (struct field_ref *) insn->data;
- if (unlikely(insn->reg >= REG_ERROR)) {
- ERR("invalid register %u\n",
- (unsigned int) insn->reg);
- ret = -EINVAL;
- goto end;
- }
dbg_printf("Validate load field ref offset %u type s64\n",
ref->offset);
break;
struct load_op *insn = (struct load_op *) pc;
struct field_ref *ref = (struct field_ref *) insn->data;
- if (unlikely(insn->reg >= REG_ERROR)) {
- ERR("invalid register %u\n",
- (unsigned int) insn->reg);
- ret = -EINVAL;
- goto end;
- }
dbg_printf("Validate load field ref offset %u type double\n",
ref->offset);
break;
case FILTER_OP_LOAD_STRING:
{
- struct load_op *insn = (struct load_op *) pc;
-
- if (unlikely(insn->reg >= REG_ERROR)) {
- ERR("invalid register %u\n",
- (unsigned int) insn->reg);
- ret = -EINVAL;
- goto end;
- }
break;
}
case FILTER_OP_LOAD_S64:
{
- struct load_op *insn = (struct load_op *) pc;
-
- if (unlikely(insn->reg >= REG_ERROR)) {
- ERR("invalid register %u\n",
- (unsigned int) insn->reg);
- ret = -EINVAL;
- goto end;
- }
break;
}
case FILTER_OP_LOAD_DOUBLE:
{
- struct load_op *insn = (struct load_op *) pc;
-
- if (unlikely(insn->reg >= REG_ERROR)) {
- ERR("invalid register %u\n",
- (unsigned int) insn->reg);
- ret = -EINVAL;
- goto end;
- }
break;
}
{
struct cast_op *insn = (struct cast_op *) pc;
- if (unlikely(insn->reg >= REG_ERROR)) {
- ERR("invalid register %u\n",
- (unsigned int) insn->reg);
+ if (!vstack_ax(stack)) {
+ ERR("Empty stack\n");
ret = -EINVAL;
goto end;
}
- switch (reg[insn->reg].type) {
+ switch (vstack_ax(stack)->type) {
default:
ERR("unknown register type\n");
ret = -EINVAL;
break;
}
if (insn->op == FILTER_OP_CAST_DOUBLE_TO_S64) {
- if (reg[insn->reg].type != REG_DOUBLE) {
+ if (vstack_ax(stack)->type != REG_DOUBLE) {
ERR("Cast expects double\n");
ret = -EINVAL;
goto end;
static
int validate_instruction_all_contexts(struct bytecode_runtime *bytecode,
struct cds_lfht *merge_points,
- const struct vreg reg[NR_REG],
+ struct vstack *stack,
void *start_pc,
void *pc)
{
unsigned long hash;
/* Validate the context resulting from the previous instruction */
- ret = validate_instruction_context(bytecode, reg, start_pc, pc);
+ ret = validate_instruction_context(bytecode, stack, start_pc, pc);
if (ret)
return ret;
dbg_printf("Filter: validate merge point at offset %lu\n",
target_pc);
- ret = validate_instruction_context(bytecode, mp_node->reg,
+ ret = validate_instruction_context(bytecode, &mp_node->stack,
start_pc, pc);
if (ret)
return ret;
static
int exec_insn(struct bytecode_runtime *bytecode,
struct cds_lfht *merge_points,
- struct vreg reg[NR_REG],
+ struct vstack *stack,
void **_next_pc,
void *pc)
{
case FILTER_OP_GE_DOUBLE:
case FILTER_OP_LE_DOUBLE:
{
- reg[REG_R0].type = REG_S64;
+ /* Pop 2, push 1 */
+ if (vstack_pop(stack)) {
+ ret = -EINVAL;
+ goto end;
+ }
+ if (!vstack_ax(stack)) {
+ ERR("Empty stack\n");
+ ret = -EINVAL;
+ goto end;
+ }
+ vstack_ax(stack)->type = REG_S64;
next_pc += sizeof(struct binary_op);
break;
}
case FILTER_OP_UNARY_MINUS_S64:
case FILTER_OP_UNARY_NOT_S64:
{
- reg[REG_R0].type = REG_S64;
+ /* Pop 1, push 1 */
+ if (!vstack_ax(stack)) {
+ ERR("Empty stack\n");
+ ret = -EINVAL;
+ goto end;
+ }
+ vstack_ax(stack)->type = REG_S64;
next_pc += sizeof(struct unary_op);
break;
}
case FILTER_OP_UNARY_MINUS_DOUBLE:
case FILTER_OP_UNARY_NOT_DOUBLE:
{
- reg[REG_R0].type = REG_DOUBLE;
+ /* Pop 1, push 1 */
+ if (!vstack_ax(stack)) {
+ ERR("Empty stack\n");
+ ret = -EINVAL;
+ goto end;
+ }
+ vstack_ax(stack)->type = REG_DOUBLE;
next_pc += sizeof(struct unary_op);
break;
}
int merge_ret;
/* Add merge point to table */
- merge_ret = merge_point_add(merge_points, insn->skip_offset, reg);
+ merge_ret = merge_point_add(merge_points, insn->skip_offset,
+ stack);
if (merge_ret) {
ret = merge_ret;
goto end;
case FILTER_OP_LOAD_FIELD_REF_STRING:
case FILTER_OP_LOAD_FIELD_REF_SEQUENCE:
{
- struct load_op *insn = (struct load_op *) pc;
-
- reg[insn->reg].type = REG_STRING;
- reg[insn->reg].literal = 0;
+ if (vstack_push(stack)) {
+ ret = -EINVAL;
+ goto end;
+ }
+ vstack_ax(stack)->type = REG_STRING;
next_pc += sizeof(struct load_op) + sizeof(struct field_ref);
break;
}
case FILTER_OP_LOAD_FIELD_REF_S64:
{
- struct load_op *insn = (struct load_op *) pc;
-
- reg[insn->reg].type = REG_S64;
- reg[insn->reg].literal = 0;
+ if (vstack_push(stack)) {
+ ret = -EINVAL;
+ goto end;
+ }
+ vstack_ax(stack)->type = REG_S64;
next_pc += sizeof(struct load_op) + sizeof(struct field_ref);
break;
}
case FILTER_OP_LOAD_FIELD_REF_DOUBLE:
{
- struct load_op *insn = (struct load_op *) pc;
-
- reg[insn->reg].type = REG_DOUBLE;
- reg[insn->reg].literal = 0;
+ if (vstack_push(stack)) {
+ ret = -EINVAL;
+ goto end;
+ }
+ vstack_ax(stack)->type = REG_DOUBLE;
next_pc += sizeof(struct load_op) + sizeof(struct field_ref);
break;
}
{
struct load_op *insn = (struct load_op *) pc;
- reg[insn->reg].type = REG_STRING;
- reg[insn->reg].literal = 1;
+ if (vstack_push(stack)) {
+ ret = -EINVAL;
+ goto end;
+ }
+ vstack_ax(stack)->type = REG_STRING;
next_pc += sizeof(struct load_op) + strlen(insn->data) + 1;
break;
}
case FILTER_OP_LOAD_S64:
{
- struct load_op *insn = (struct load_op *) pc;
-
- reg[insn->reg].type = REG_S64;
- reg[insn->reg].literal = 1;
+ if (vstack_push(stack)) {
+ ret = -EINVAL;
+ goto end;
+ }
+ vstack_ax(stack)->type = REG_S64;
next_pc += sizeof(struct load_op)
+ sizeof(struct literal_numeric);
break;
case FILTER_OP_LOAD_DOUBLE:
{
- struct load_op *insn = (struct load_op *) pc;
-
- reg[insn->reg].type = REG_DOUBLE;
- reg[insn->reg].literal = 1;
+ if (vstack_push(stack)) {
+ ret = -EINVAL;
+ goto end;
+ }
+ vstack_ax(stack)->type = REG_DOUBLE;
next_pc += sizeof(struct load_op)
+ sizeof(struct literal_double);
break;
case FILTER_OP_CAST_TO_S64:
case FILTER_OP_CAST_DOUBLE_TO_S64:
{
- struct cast_op *insn = (struct cast_op *) pc;
-
- reg[insn->reg].type = REG_S64;
+ /* Pop 1, push 1 */
+ if (!vstack_ax(stack)) {
+ ERR("Empty stack\n");
+ ret = -EINVAL;
+ goto end;
+ }
+ vstack_ax(stack)->type = REG_S64;
next_pc += sizeof(struct cast_op);
break;
}
struct cds_lfht *merge_points;
void *pc, *next_pc, *start_pc;
int ret = -EINVAL;
- struct vreg reg[NR_REG];
- int i;
+ struct vstack stack;
- for (i = 0; i < NR_REG; i++) {
- reg[i].type = REG_TYPE_UNKNOWN;
- reg[i].literal = 0;
- }
+ vstack_init(&stack);
if (!lttng_hash_seed_ready) {
lttng_hash_seed = time(NULL);
* all merge points targeting this instruction.
*/
ret = validate_instruction_all_contexts(bytecode, merge_points,
- reg, start_pc, pc);
+ &stack, start_pc, pc);
if (ret)
goto end;
- ret = exec_insn(bytecode, merge_points, reg, &next_pc, pc);
+ ret = exec_insn(bytecode, merge_points, &stack, &next_pc, pc);
if (ret <= 0)
goto end;
}
#include <helper.h>
#include <lttng/ust-events.h>
#include <stdint.h>
+#include <assert.h>
#include <errno.h>
#include <string.h>
#include <inttypes.h>
#include <usterr-signal-safe.h>
#include "filter-bytecode.h"
-#define NR_REG 2
+/* Filter stack length, in number of entries */
+#define FILTER_STACK_LEN 8
#ifndef min_t
#define min_t(type, a, b) \
char data[0];
};
-enum reg_type {
+enum entry_type {
REG_S64,
REG_DOUBLE,
REG_STRING,
REG_TYPE_UNKNOWN,
};
-/* Validation registers */
-struct vreg {
- enum reg_type type;
- int literal; /* is string literal ? */
+/* Validation stack */
+struct vstack_entry {
+ enum entry_type type;
};
-/* Execution registers */
-struct reg {
- enum reg_type type;
- int64_t v;
- double d;
+struct vstack {
+ int top; /* top of stack */
+ struct vstack_entry e[FILTER_STACK_LEN];
+};
+
+static inline
+void vstack_init(struct vstack *stack)
+{
+ stack->top = -1;
+}
+
+static inline
+struct vstack_entry *vstack_ax(struct vstack *stack)
+{
+ if (unlikely(stack->top < 0))
+ return NULL;
+ return &stack->e[stack->top];
+}
+
+static inline
+struct vstack_entry *vstack_bx(struct vstack *stack)
+{
+ if (unlikely(stack->top < 1))
+ return NULL;
+ return &stack->e[stack->top - 1];
+}
+
+static inline
+int vstack_push(struct vstack *stack)
+{
+ if (stack->top >= FILTER_STACK_LEN - 1) {
+ ERR("Stack full\n");
+ return -EINVAL;
+ }
+ ++stack->top;
+ return 0;
+}
+
+static inline
+int vstack_pop(struct vstack *stack)
+{
+ if (unlikely(stack->top < 0)) {
+ ERR("Stack empty\n");
+ return -EINVAL;
+ }
+ stack->top--;
+ return 0;
+}
+
+/* Execution stack */
+struct estack_entry {
+ enum entry_type type;
+
+ union {
+ int64_t v;
+ double d;
+
+ struct {
+ const char *str;
+ size_t seq_len;
+ int literal; /* is string literal ? */
+ } s;
+ } u;
+};
- const char *str;
- size_t seq_len;
- int literal; /* is string literal ? */
+struct estack {
+ int top; /* top of stack */
+ struct estack_entry e[FILTER_STACK_LEN];
};
+static inline
+void estack_init(struct estack *stack)
+{
+ stack->top = -1;
+}
+
+static inline
+struct estack_entry *estack_ax(struct estack *stack)
+{
+ assert(stack->top >= 0);
+ return &stack->e[stack->top];
+}
+
+static inline
+struct estack_entry *estack_bx(struct estack *stack)
+{
+ assert(stack->top >= 1);
+ return &stack->e[stack->top - 1];
+}
+
+static inline
+void estack_push(struct estack *stack)
+{
+ assert(stack->top < FILTER_STACK_LEN - 1);
+ ++stack->top;
+}
+
+static inline
+void estack_pop(struct estack *stack)
+{
+ assert(stack->top >= 0);
+ stack->top--;
+}
+
const char *print_op(enum filter_op op);
int lttng_filter_validate_bytecode(struct bytecode_runtime *bytecode);
projects / lttng-ust.git / commitdiff
