[lttng-tools.git] / src / common / filter / filter-visitor-generate-bytecode.c

/*
 * filter-visitor-generate-bytecode.c
 *
 * LTTng filter bytecode generation
 *
 * Copyright 2012 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
 *
 * SPDX-License-Identifier: LGPL-2.1-only
 *
 */

#include <stdlib.h>
#include <string.h>
#include <common/align.h>
#include <common/compat/errno.h>
#include <common/compat/string.h>

#include "common/align.h"
#include "common/bytecode/bytecode.h"
#include "common/compat/string.h"
#include "common/macros.h"
#include "filter-ast.h"
#include "filter-ir.h"

#ifndef max_t
#define max_t(type, a, b)	((type) ((a) > (b) ? (a) : (b)))
#endif

static
int recursive_visit_gen_bytecode(struct filter_parser_ctx *ctx,
		struct ir_op *node);

static
int bytecode_patch(struct lttng_bytecode_alloc **fb,
		const void *data,
		uint16_t offset,
		uint32_t len)
{
	if (offset >= (*fb)->b.len) {
		return -EINVAL;
	}
	memcpy(&(*fb)->b.data[offset], data, len);
	return 0;
}

static
int visit_node_root(struct filter_parser_ctx *ctx, struct ir_op *node)
{
	int ret;
	struct return_op insn;

	/* Visit child */
	ret = recursive_visit_gen_bytecode(ctx, node->u.root.child);
	if (ret)
		return ret;

	/* Generate end of bytecode instruction */
	insn.op = BYTECODE_OP_RETURN;
	return bytecode_push(&ctx->bytecode, &insn, 1, sizeof(insn));
}

static
int append_str(char **s, const char *append)
{
	char *old = *s;
	char *new;
	size_t oldlen = (old == NULL) ? 0 : strlen(old);
	size_t appendlen = strlen(append);

	new = calloc(oldlen + appendlen + 1, 1);
	if (!new) {
		return -ENOMEM;
	}
	if (oldlen) {
		strcpy(new, old);
	}
	strcat(new, append);
	*s = new;
	free(old);
	return 0;
}

/*
 * 1: match
 * 0: no match
 * < 0: error
 */
static
int load_expression_legacy_match(const struct ir_load_expression *exp,
		enum bytecode_op *op_type,
		char **symbol)
{
	const struct ir_load_expression_op *op;
	bool need_dot = false;

	op = exp->child;
	switch (op->type) {
	case IR_LOAD_EXPRESSION_GET_CONTEXT_ROOT:
		*op_type = BYTECODE_OP_GET_CONTEXT_REF;
		if (append_str(symbol, "$ctx.")) {
			return -ENOMEM;
		}
		need_dot = false;
		break;
	case IR_LOAD_EXPRESSION_GET_APP_CONTEXT_ROOT:
		*op_type = BYTECODE_OP_GET_CONTEXT_REF;
		if (append_str(symbol, "$app.")) {
			return -ENOMEM;
		}
		need_dot = false;
		break;
	case IR_LOAD_EXPRESSION_GET_PAYLOAD_ROOT:
		*op_type = BYTECODE_OP_LOAD_FIELD_REF;
		need_dot = false;
		break;

	case IR_LOAD_EXPRESSION_GET_SYMBOL:
	case IR_LOAD_EXPRESSION_GET_INDEX:
	case IR_LOAD_EXPRESSION_LOAD_FIELD:
	default:
		return 0;	/* no match */
	}

	for (;;) {
		op = op->next;
		if (!op) {
			return 0;	/* no match */
		}
		switch (op->type) {
		case IR_LOAD_EXPRESSION_LOAD_FIELD:
			goto end;
		case IR_LOAD_EXPRESSION_GET_SYMBOL:
			if (need_dot && append_str(symbol, ".")) {
				return -ENOMEM;
			}
			if (append_str(symbol, op->u.symbol)) {
				return -ENOMEM;
			}
			break;
		default:
			return 0;	 /* no match */
		}
		need_dot = true;
	}
end:
	return 1;	/* Legacy match */
}

/*
 * 1: legacy match
 * 0: no legacy match
 * < 0: error
 */
static
int visit_node_load_expression_legacy(struct filter_parser_ctx *ctx,
		const struct ir_load_expression *exp,
		const struct ir_load_expression_op *op)
{
	struct load_op *insn = NULL;
	uint32_t insn_len = sizeof(struct load_op)
		+ sizeof(struct field_ref);
	struct field_ref ref_offset;
	uint32_t reloc_offset_u32;
	uint16_t reloc_offset;
	enum bytecode_op op_type;
	char *symbol = NULL;
	int ret;

	ret = load_expression_legacy_match(exp, &op_type, &symbol);
	if (ret <= 0) {
		goto end;
	}
	insn = calloc(insn_len, 1);
	if (!insn) {
		ret = -ENOMEM;
		goto end;
	}
	insn->op = op_type;
	ref_offset.offset = (uint16_t) -1U;
	memcpy(insn->data, &ref_offset, sizeof(ref_offset));
	/* reloc_offset points to struct load_op */
	reloc_offset_u32 = bytecode_get_len(&ctx->bytecode->b);
	if (reloc_offset_u32 > LTTNG_FILTER_MAX_LEN - 1) {
		ret = -EINVAL;
		goto end;
	}
	reloc_offset = (uint16_t) reloc_offset_u32;
	ret = bytecode_push(&ctx->bytecode, insn, 1, insn_len);
	if (ret) {
		goto end;
	}
	/* append reloc */
	ret = bytecode_push(&ctx->bytecode_reloc, &reloc_offset,
				1, sizeof(reloc_offset));
	if (ret) {
		goto end;
	}
	ret = bytecode_push(&ctx->bytecode_reloc, symbol,
				1, strlen(symbol) + 1);
	if (ret) {
		goto end;
	}
	ret = 1;	/* legacy */
end:
	free(insn);
	free(symbol);
	return ret;
}

static
int visit_node_load_expression(struct filter_parser_ctx *ctx,
		const struct ir_op *node)
{
	struct ir_load_expression *exp;
	struct ir_load_expression_op *op;
	int ret;

	exp = node->u.load.u.expression;
	if (!exp) {
		return -EINVAL;
	}
	op = exp->child;
	if (!op) {
		return -EINVAL;
	}

	/*
	 * TODO: if we remove legacy load for application contexts, we
	 * need to update session bytecode parser as well.
	 */
	ret = visit_node_load_expression_legacy(ctx, exp, op);
	if (ret < 0) {
		return ret;
	}
	if (ret > 0) {
		return 0;	/* legacy */
	}

	for (; op != NULL; op = op->next) {
		switch (op->type) {
		case IR_LOAD_EXPRESSION_GET_CONTEXT_ROOT:
		{
			struct load_op *insn;
			uint32_t insn_len = sizeof(struct load_op);
			int ret;

			insn = calloc(insn_len, 1);
			if (!insn)
				return -ENOMEM;
			insn->op = BYTECODE_OP_GET_CONTEXT_ROOT;
			ret = bytecode_push(&ctx->bytecode, insn, 1, insn_len);
			free(insn);
			if (ret) {
				return ret;
			}
			break;
		}
		case IR_LOAD_EXPRESSION_GET_APP_CONTEXT_ROOT:
		{
			struct load_op *insn;
			uint32_t insn_len = sizeof(struct load_op);
			int ret;

			insn = calloc(insn_len, 1);
			if (!insn)
				return -ENOMEM;
			insn->op = BYTECODE_OP_GET_APP_CONTEXT_ROOT;
			ret = bytecode_push(&ctx->bytecode, insn, 1, insn_len);
			free(insn);
			if (ret) {
				return ret;
			}
			break;
		}
		case IR_LOAD_EXPRESSION_GET_PAYLOAD_ROOT:
		{
			struct load_op *insn;
			uint32_t insn_len = sizeof(struct load_op);
			int ret;

			insn = calloc(insn_len, 1);
			if (!insn)
				return -ENOMEM;
			insn->op = BYTECODE_OP_GET_PAYLOAD_ROOT;
			ret = bytecode_push(&ctx->bytecode, insn, 1, insn_len);
			free(insn);
			if (ret) {
				return ret;
			}
			break;
		}
		case IR_LOAD_EXPRESSION_GET_SYMBOL:
		{
			struct load_op *insn;
			uint32_t insn_len = sizeof(struct load_op)
				+ sizeof(struct get_symbol);
			struct get_symbol symbol_offset;
			uint32_t reloc_offset_u32;
			uint16_t reloc_offset;
			uint32_t bytecode_reloc_offset_u32;
			int ret;

			insn = calloc(insn_len, 1);
			if (!insn)
				return -ENOMEM;
			insn->op = BYTECODE_OP_GET_SYMBOL;
			bytecode_reloc_offset_u32 =
					bytecode_get_len(&ctx->bytecode_reloc->b)
					+ sizeof(reloc_offset);
			symbol_offset.offset =
					(uint16_t) bytecode_reloc_offset_u32;
			memcpy(insn->data, &symbol_offset,
					sizeof(symbol_offset));
			/* reloc_offset points to struct load_op */
			reloc_offset_u32 = bytecode_get_len(&ctx->bytecode->b);
			if (reloc_offset_u32 > LTTNG_FILTER_MAX_LEN - 1) {
				free(insn);
				return -EINVAL;
			}
			reloc_offset = (uint16_t) reloc_offset_u32;
			ret = bytecode_push(&ctx->bytecode, insn, 1, insn_len);
			if (ret) {
				free(insn);
				return ret;
			}
			/* append reloc */
			ret = bytecode_push(&ctx->bytecode_reloc, &reloc_offset,
					1, sizeof(reloc_offset));
			if (ret) {
				free(insn);
				return ret;
			}
			ret = bytecode_push(&ctx->bytecode_reloc,
					op->u.symbol,
					1, strlen(op->u.symbol) + 1);
			free(insn);
			if (ret) {
				return ret;
			}
			break;
		}
		case IR_LOAD_EXPRESSION_GET_INDEX:
		{
			struct load_op *insn;
			uint32_t insn_len = sizeof(struct load_op)
				+ sizeof(struct get_index_u64);
			struct get_index_u64 index;
			int ret;

			insn = calloc(insn_len, 1);
			if (!insn)
				return -ENOMEM;
			insn->op = BYTECODE_OP_GET_INDEX_U64;
			index.index = op->u.index;
			memcpy(insn->data, &index, sizeof(index));
			ret = bytecode_push(&ctx->bytecode, insn, 1, insn_len);
			free(insn);
			if (ret) {
				return ret;
			}
			break;
		}
		case IR_LOAD_EXPRESSION_LOAD_FIELD:
		{
			struct load_op *insn;
			uint32_t insn_len = sizeof(struct load_op);
			int ret;

			insn = calloc(insn_len, 1);
			if (!insn)
				return -ENOMEM;
			insn->op = BYTECODE_OP_LOAD_FIELD;
			ret = bytecode_push(&ctx->bytecode, insn, 1, insn_len);
			free(insn);
			if (ret) {
				return ret;
			}
			break;
		}
		}
	}
	return 0;
}

static
int visit_node_load(struct filter_parser_ctx *ctx, struct ir_op *node)
{
	int ret;

	switch (node->data_type) {
	case IR_DATA_UNKNOWN:
	default:
		fprintf(stderr, "[error] Unknown data type in %s\n",
			__func__);
		return -EINVAL;

	case IR_DATA_STRING:
	{
		struct load_op *insn;
		uint32_t insn_len = sizeof(struct load_op)
			+ strlen(node->u.load.u.string.value) + 1;

		insn = calloc(insn_len, 1);
		if (!insn)
			return -ENOMEM;

		switch (node->u.load.u.string.type) {
		case IR_LOAD_STRING_TYPE_GLOB_STAR:
			/*
			 * We explicitly tell the interpreter here that
			 * this load is a full star globbing pattern so
			 * that the appropriate matching function can be
			 * called. Also, see comment below.
			 */
			insn->op = BYTECODE_OP_LOAD_STAR_GLOB_STRING;
			break;
		default:
			/*
			 * This is the "legacy" string, which includes
			 * star globbing patterns with a star only at
			 * the end. Both "plain" and "star at the end"
			 * literal strings are handled at the same place
			 * by the tracer's filter bytecode interpreter,
			 * whereas full star globbing patterns (stars
			 * can be anywhere in the string) is a special
			 * case.
			 */
			insn->op = BYTECODE_OP_LOAD_STRING;
			break;
		}

		strcpy(insn->data, node->u.load.u.string.value);
		ret = bytecode_push(&ctx->bytecode, insn, 1, insn_len);
		free(insn);
		return ret;
	}
	case IR_DATA_NUMERIC:
	{
		struct load_op *insn;
		uint32_t insn_len = sizeof(struct load_op)
			+ sizeof(struct literal_numeric);

		insn = calloc(insn_len, 1);
		if (!insn)
			return -ENOMEM;
		insn->op = BYTECODE_OP_LOAD_S64;
		memcpy(insn->data, &node->u.load.u.num, sizeof(int64_t));
		ret = bytecode_push(&ctx->bytecode, insn, 1, insn_len);
		free(insn);
		return ret;
	}
	case IR_DATA_FLOAT:
	{
		struct load_op *insn;
		uint32_t insn_len = sizeof(struct load_op)
			+ sizeof(struct literal_double);

		insn = calloc(insn_len, 1);
		if (!insn)
			return -ENOMEM;
		insn->op = BYTECODE_OP_LOAD_DOUBLE;
		memcpy(insn->data, &node->u.load.u.flt, sizeof(double));
		ret = bytecode_push(&ctx->bytecode, insn, 1, insn_len);
		free(insn);
		return ret;
	}
	case IR_DATA_EXPRESSION:
		return visit_node_load_expression(ctx, node);
	}
}

static
int visit_node_unary(struct filter_parser_ctx *ctx, struct ir_op *node)
{
	int ret;
	struct unary_op insn;

	/* Visit child */
	ret = recursive_visit_gen_bytecode(ctx, node->u.unary.child);
	if (ret)
		return ret;

	/* Generate end of bytecode instruction */
	switch (node->u.unary.type) {
	case AST_UNARY_UNKNOWN:
	default:
		fprintf(stderr, "[error] Unknown unary node type in %s\n",
			__func__);
		return -EINVAL;
	case AST_UNARY_PLUS:
		/* Nothing to do. */
		return 0;
	case AST_UNARY_MINUS:
		insn.op = BYTECODE_OP_UNARY_MINUS;
		return bytecode_push(&ctx->bytecode, &insn, 1, sizeof(insn));
	case AST_UNARY_NOT:
		insn.op = BYTECODE_OP_UNARY_NOT;
		return bytecode_push(&ctx->bytecode, &insn, 1, sizeof(insn));
	case AST_UNARY_BIT_NOT:
		insn.op = BYTECODE_OP_UNARY_BIT_NOT;
		return bytecode_push(&ctx->bytecode, &insn, 1, sizeof(insn));
	}
}

/*
 * Binary comparator nesting is disallowed. This allows fitting into
 * only 2 registers.
 */
static
int visit_node_binary(struct filter_parser_ctx *ctx, struct ir_op *node)
{
	int ret;
	struct binary_op insn;

	/* Visit child */
	ret = recursive_visit_gen_bytecode(ctx, node->u.binary.left);
	if (ret)
		return ret;
	ret = recursive_visit_gen_bytecode(ctx, node->u.binary.right);
	if (ret)
		return ret;

	switch (node->u.binary.type) {
	case AST_OP_UNKNOWN:
	default:
		fprintf(stderr, "[error] Unknown unary node type in %s\n",
			__func__);
		return -EINVAL;

	case AST_OP_AND:
	case AST_OP_OR:
		fprintf(stderr, "[error] Unexpected logical node type in %s\n",
			__func__);
		return -EINVAL;

	case AST_OP_MUL:
		insn.op = BYTECODE_OP_MUL;
		break;
	case AST_OP_DIV:
		insn.op = BYTECODE_OP_DIV;
		break;
	case AST_OP_MOD:
		insn.op = BYTECODE_OP_MOD;
		break;
	case AST_OP_PLUS:
		insn.op = BYTECODE_OP_PLUS;
		break;
	case AST_OP_MINUS:
		insn.op = BYTECODE_OP_MINUS;
		break;
	case AST_OP_BIT_RSHIFT:
		insn.op = BYTECODE_OP_BIT_RSHIFT;
		break;
	case AST_OP_BIT_LSHIFT:
		insn.op = BYTECODE_OP_BIT_LSHIFT;
		break;
	case AST_OP_BIT_AND:
		insn.op = BYTECODE_OP_BIT_AND;
		break;
	case AST_OP_BIT_OR:
		insn.op = BYTECODE_OP_BIT_OR;
		break;
	case AST_OP_BIT_XOR:
		insn.op = BYTECODE_OP_BIT_XOR;
		break;

	case AST_OP_EQ:
		insn.op = BYTECODE_OP_EQ;
		break;
	case AST_OP_NE:
		insn.op = BYTECODE_OP_NE;
		break;
	case AST_OP_GT:
		insn.op = BYTECODE_OP_GT;
		break;
	case AST_OP_LT:
		insn.op = BYTECODE_OP_LT;
		break;
	case AST_OP_GE:
		insn.op = BYTECODE_OP_GE;
		break;
	case AST_OP_LE:
		insn.op = BYTECODE_OP_LE;
		break;
	}
	return bytecode_push(&ctx->bytecode, &insn, 1, sizeof(insn));
}

/*
 * A logical op always return a s64 (1 or 0).
 */
static
int visit_node_logical(struct filter_parser_ctx *ctx, struct ir_op *node)
{
	int ret;
	struct logical_op insn;
	uint16_t skip_offset_loc;
	uint16_t target_loc;

	/* Visit left child */
	ret = recursive_visit_gen_bytecode(ctx, node->u.binary.left);
	if (ret)
		return ret;
	/* Cast to s64 if float or field ref */
	if ((node->u.binary.left->data_type == IR_DATA_FIELD_REF
				|| node->u.binary.left->data_type == IR_DATA_GET_CONTEXT_REF
				|| node->u.binary.left->data_type == IR_DATA_EXPRESSION)
			|| node->u.binary.left->data_type == IR_DATA_FLOAT) {
		struct cast_op cast_insn;

		if (node->u.binary.left->data_type == IR_DATA_FIELD_REF
				|| node->u.binary.left->data_type == IR_DATA_GET_CONTEXT_REF
				|| node->u.binary.left->data_type == IR_DATA_EXPRESSION) {
			cast_insn.op = BYTECODE_OP_CAST_TO_S64;
		} else {
			cast_insn.op = BYTECODE_OP_CAST_DOUBLE_TO_S64;
		}
		ret = bytecode_push(&ctx->bytecode, &cast_insn,
					1, sizeof(cast_insn));
		if (ret)
			return ret;
	}
	switch (node->u.logical.type) {
	default:
		fprintf(stderr, "[error] Unknown node type in %s\n",
			__func__);
		return -EINVAL;

	case AST_OP_AND:
		insn.op = BYTECODE_OP_AND;
		break;
	case AST_OP_OR:
		insn.op = BYTECODE_OP_OR;
		break;
	}
	insn.skip_offset = (uint16_t) -1UL;	/* Temporary */
	ret = bytecode_push_logical(&ctx->bytecode, &insn, 1, sizeof(insn),
			&skip_offset_loc);
	if (ret)
		return ret;
	/* Visit right child */
	ret = recursive_visit_gen_bytecode(ctx, node->u.binary.right);
	if (ret)
		return ret;
	/* Cast to s64 if float or field ref */
	if ((node->u.binary.right->data_type == IR_DATA_FIELD_REF
				|| node->u.binary.right->data_type == IR_DATA_GET_CONTEXT_REF
				|| node->u.binary.right->data_type == IR_DATA_EXPRESSION)
			|| node->u.binary.right->data_type == IR_DATA_FLOAT) {
		struct cast_op cast_insn;

		if (node->u.binary.right->data_type == IR_DATA_FIELD_REF
				|| node->u.binary.right->data_type == IR_DATA_GET_CONTEXT_REF
				|| node->u.binary.right->data_type == IR_DATA_EXPRESSION) {
			cast_insn.op = BYTECODE_OP_CAST_TO_S64;
		} else {
			cast_insn.op = BYTECODE_OP_CAST_DOUBLE_TO_S64;
		}
		ret = bytecode_push(&ctx->bytecode, &cast_insn,
					1, sizeof(cast_insn));
		if (ret)
			return ret;
	}
	/* We now know where the logical op can skip. */
	target_loc = (uint16_t) bytecode_get_len(&ctx->bytecode->b);
	ret = bytecode_patch(&ctx->bytecode,
			&target_loc,			/* Offset to jump to */
			skip_offset_loc,		/* Where to patch */
			sizeof(uint16_t));
	return ret;
}

/*
 * Postorder traversal of the tree. We need the children result before
 * we can evaluate the parent.
 */
static
int recursive_visit_gen_bytecode(struct filter_parser_ctx *ctx,
		struct ir_op *node)
{
	switch (node->op) {
	case IR_OP_UNKNOWN:
	default:
		fprintf(stderr, "[error] Unknown node type in %s\n",
			__func__);
		return -EINVAL;

	case IR_OP_ROOT:
		return visit_node_root(ctx, node);
	case IR_OP_LOAD:
		return visit_node_load(ctx, node);
	case IR_OP_UNARY:
		return visit_node_unary(ctx, node);
	case IR_OP_BINARY:
		return visit_node_binary(ctx, node);
	case IR_OP_LOGICAL:
		return visit_node_logical(ctx, node);
	}
}

LTTNG_HIDDEN
void filter_bytecode_free(struct filter_parser_ctx *ctx)
{
	if (!ctx) {
		return;
	}

	if (ctx->bytecode) {
		free(ctx->bytecode);
		ctx->bytecode = NULL;
	}

	if (ctx->bytecode_reloc) {
		free(ctx->bytecode_reloc);
		ctx->bytecode_reloc = NULL;
	}
}

LTTNG_HIDDEN
int filter_visitor_bytecode_generate(struct filter_parser_ctx *ctx)
{
	int ret;

	ret = bytecode_init(&ctx->bytecode);
	if (ret)
		return ret;
	ret = bytecode_init(&ctx->bytecode_reloc);
	if (ret)
		goto error;
	ret = recursive_visit_gen_bytecode(ctx, ctx->ir_root);
	if (ret)
		goto error;

	/* Finally, append symbol table to bytecode */
	ctx->bytecode->b.reloc_table_offset = bytecode_get_len(&ctx->bytecode->b);
	return bytecode_push(&ctx->bytecode, ctx->bytecode_reloc->b.data,
			1, bytecode_get_len(&ctx->bytecode_reloc->b));

error:
	filter_bytecode_free(ctx);
	return ret;
}
Commit	Line	Data
953192ba MD	1	/*
	2	* filter-visitor-generate-bytecode.c
	3	*
	4	* LTTng filter bytecode generation
	5	*
ab5be9fa	6	* Copyright 2012 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
953192ba	7	*
ab5be9fa	8	* SPDX-License-Identifier: LGPL-2.1-only
953192ba	9	*
953192ba MD	10	*/
	11
	12	#include <stdlib.h>
	13	#include <string.h>
46820c8b	14	#include <common/align.h>
edf4b93e	15	#include <common/compat/errno.h>
afc5df03	16	#include <common/compat/string.h>
46820c8b	17
0ae3cfc6 SM	18	#include "common/align.h"
	19	#include "common/bytecode/bytecode.h"
	20	#include "common/compat/string.h"
	21	#include "common/macros.h"
953192ba	22	#include "filter-ast.h"
0ae3cfc6	23	#include "filter-ir.h"
a187da1a	24
953192ba MD	25	#ifndef max_t
	26	#define max_t(type, a, b) ((type) ((a) > (b) ? (a) : (b)))
	27	#endif
	28
953192ba MD	29	static
	30	int recursive_visit_gen_bytecode(struct filter_parser_ctx *ctx,
	31	struct ir_op *node);
	32
953192ba	33	static
2b00d462	34	int bytecode_patch(struct lttng_bytecode_alloc **fb,
953192ba MD	35	const void *data,
	36	uint16_t offset,
	37	uint32_t len)
	38	{
	39	if (offset >= (*fb)->b.len) {
	40	return -EINVAL;
	41	}
	42	memcpy(&(*fb)->b.data[offset], data, len);
	43	return 0;
	44	}
	45
	46	static
	47	int visit_node_root(struct filter_parser_ctx ctx, struct ir_op node)
	48	{
	49	int ret;
	50	struct return_op insn;
	51
	52	/* Visit child */
	53	ret = recursive_visit_gen_bytecode(ctx, node->u.root.child);
	54	if (ret)
	55	return ret;
	56
	57	/* Generate end of bytecode instruction */
2b00d462	58	insn.op = BYTECODE_OP_RETURN;
953192ba MD	59	return bytecode_push(&ctx->bytecode, &insn, 1, sizeof(insn));
	60	}
	61
016dbbb4 MD	62	static
	63	int append_str(char *s, const char append)
	64	{
	65	char old = s;
	66	char *new;
	67	size_t oldlen = (old == NULL) ? 0 : strlen(old);
	68	size_t appendlen = strlen(append);
	69
	70	new = calloc(oldlen + appendlen + 1, 1);
	71	if (!new) {
	72	return -ENOMEM;
	73	}
	74	if (oldlen) {
	75	strcpy(new, old);
	76	}
	77	strcat(new, append);
	78	*s = new;
	79	free(old);
	80	return 0;
	81	}
	82
	83	/*
	84	* 1: match
	85	* 0: no match
	86	* < 0: error
	87	*/
	88	static
	89	int load_expression_legacy_match(const struct ir_load_expression *exp,
2b00d462	90	enum bytecode_op *op_type,
016dbbb4 MD	91	char **symbol)
	92	{
	93	const struct ir_load_expression_op *op;
	94	bool need_dot = false;
	95
	96	op = exp->child;
	97	switch (op->type) {
	98	case IR_LOAD_EXPRESSION_GET_CONTEXT_ROOT:
2b00d462	99	*op_type = BYTECODE_OP_GET_CONTEXT_REF;
016dbbb4 MD	100	if (append_str(symbol, "$ctx.")) {
	101	return -ENOMEM;
	102	}
	103	need_dot = false;
	104	break;
	105	case IR_LOAD_EXPRESSION_GET_APP_CONTEXT_ROOT:
2b00d462	106	*op_type = BYTECODE_OP_GET_CONTEXT_REF;
016dbbb4 MD	107	if (append_str(symbol, "$app.")) {
	108	return -ENOMEM;
	109	}
	110	need_dot = false;
	111	break;
	112	case IR_LOAD_EXPRESSION_GET_PAYLOAD_ROOT:
2b00d462	113	*op_type = BYTECODE_OP_LOAD_FIELD_REF;
016dbbb4 MD	114	need_dot = false;
	115	break;
	116
	117	case IR_LOAD_EXPRESSION_GET_SYMBOL:
	118	case IR_LOAD_EXPRESSION_GET_INDEX:
	119	case IR_LOAD_EXPRESSION_LOAD_FIELD:
	120	default:
	121	return 0; /* no match */
	122	}
	123
	124	for (;;) {
	125	op = op->next;
	126	if (!op) {
	127	return 0; /* no match */
	128	}
	129	switch (op->type) {
	130	case IR_LOAD_EXPRESSION_LOAD_FIELD:
	131	goto end;
	132	case IR_LOAD_EXPRESSION_GET_SYMBOL:
	133	if (need_dot && append_str(symbol, ".")) {
	134	return -ENOMEM;
	135	}
	136	if (append_str(symbol, op->u.symbol)) {
	137	return -ENOMEM;
	138	}
	139	break;
	140	default:
	141	return 0; /* no match */
	142	}
	143	need_dot = true;
	144	}
	145	end:
	146	return 1; /* Legacy match */
	147	}
	148
	149	/*
	150	* 1: legacy match
	151	* 0: no legacy match
	152	* < 0: error
	153	*/
	154	static
	155	int visit_node_load_expression_legacy(struct filter_parser_ctx *ctx,
	156	const struct ir_load_expression *exp,
	157	const struct ir_load_expression_op *op)
	158	{
	159	struct load_op *insn = NULL;
	160	uint32_t insn_len = sizeof(struct load_op)
	161	+ sizeof(struct field_ref);
	162	struct field_ref ref_offset;
	163	uint32_t reloc_offset_u32;
	164	uint16_t reloc_offset;
2b00d462	165	enum bytecode_op op_type;
016dbbb4 MD	166	char *symbol = NULL;
	167	int ret;
	168
	169	ret = load_expression_legacy_match(exp, &op_type, &symbol);
	170	if (ret <= 0) {
	171	goto end;
	172	}
	173	insn = calloc(insn_len, 1);
	174	if (!insn) {
	175	ret = -ENOMEM;
	176	goto end;
	177	}
	178	insn->op = op_type;
	179	ref_offset.offset = (uint16_t) -1U;
	180	memcpy(insn->data, &ref_offset, sizeof(ref_offset));
	181	/* reloc_offset points to struct load_op */
	182	reloc_offset_u32 = bytecode_get_len(&ctx->bytecode->b);
	183	if (reloc_offset_u32 > LTTNG_FILTER_MAX_LEN - 1) {
	184	ret = -EINVAL;
	185	goto end;
	186	}
	187	reloc_offset = (uint16_t) reloc_offset_u32;
	188	ret = bytecode_push(&ctx->bytecode, insn, 1, insn_len);
	189	if (ret) {
	190	goto end;
	191	}
	192	/* append reloc */
	193	ret = bytecode_push(&ctx->bytecode_reloc, &reloc_offset,
	194	1, sizeof(reloc_offset));
	195	if (ret) {
	196	goto end;
	197	}
	198	ret = bytecode_push(&ctx->bytecode_reloc, symbol,
	199	1, strlen(symbol) + 1);
73e38068 JG	200	if (ret) {
	201	goto end;
	202	}
016dbbb4 MD	203	ret = 1; /* legacy */
	204	end:
	205	free(insn);
	206	free(symbol);
	207	return ret;
	208	}
	209
bff988fa MD	210	static
	211	int visit_node_load_expression(struct filter_parser_ctx *ctx,
	212	const struct ir_op *node)
	213	{
	214	struct ir_load_expression *exp;
	215	struct ir_load_expression_op *op;
016dbbb4	216	int ret;
bff988fa MD	217
	218	exp = node->u.load.u.expression;
	219	if (!exp) {
	220	return -EINVAL;
	221	}
	222	op = exp->child;
	223	if (!op) {
	224	return -EINVAL;
	225	}
016dbbb4	226
b4bc01f7 MD	227	/*
	228	* TODO: if we remove legacy load for application contexts, we
	229	* need to update session bytecode parser as well.
	230	*/
016dbbb4 MD	231	ret = visit_node_load_expression_legacy(ctx, exp, op);
	232	if (ret < 0) {
	233	return ret;
	234	}
	235	if (ret > 0) {
	236	return 0; /* legacy */
	237	}
	238
bff988fa MD	239	for (; op != NULL; op = op->next) {
	240	switch (op->type) {
	241	case IR_LOAD_EXPRESSION_GET_CONTEXT_ROOT:
	242	{
	243	struct load_op *insn;
	244	uint32_t insn_len = sizeof(struct load_op);
	245	int ret;
	246
	247	insn = calloc(insn_len, 1);
	248	if (!insn)
	249	return -ENOMEM;
2b00d462	250	insn->op = BYTECODE_OP_GET_CONTEXT_ROOT;
bff988fa MD	251	ret = bytecode_push(&ctx->bytecode, insn, 1, insn_len);
	252	free(insn);
	253	if (ret) {
	254	return ret;
	255	}
	256	break;
	257	}
	258	case IR_LOAD_EXPRESSION_GET_APP_CONTEXT_ROOT:
	259	{
	260	struct load_op *insn;
	261	uint32_t insn_len = sizeof(struct load_op);
	262	int ret;
	263
	264	insn = calloc(insn_len, 1);
	265	if (!insn)
	266	return -ENOMEM;
2b00d462	267	insn->op = BYTECODE_OP_GET_APP_CONTEXT_ROOT;
bff988fa MD	268	ret = bytecode_push(&ctx->bytecode, insn, 1, insn_len);
	269	free(insn);
	270	if (ret) {
	271	return ret;
	272	}
	273	break;
	274	}
	275	case IR_LOAD_EXPRESSION_GET_PAYLOAD_ROOT:
	276	{
	277	struct load_op *insn;
	278	uint32_t insn_len = sizeof(struct load_op);
	279	int ret;
	280
	281	insn = calloc(insn_len, 1);
	282	if (!insn)
	283	return -ENOMEM;
2b00d462	284	insn->op = BYTECODE_OP_GET_PAYLOAD_ROOT;
bff988fa MD	285	ret = bytecode_push(&ctx->bytecode, insn, 1, insn_len);
	286	free(insn);
	287	if (ret) {
	288	return ret;
	289	}
	290	break;
	291	}
	292	case IR_LOAD_EXPRESSION_GET_SYMBOL:
	293	{
	294	struct load_op *insn;
	295	uint32_t insn_len = sizeof(struct load_op)
	296	+ sizeof(struct get_symbol);
	297	struct get_symbol symbol_offset;
	298	uint32_t reloc_offset_u32;
	299	uint16_t reloc_offset;
	300	uint32_t bytecode_reloc_offset_u32;
	301	int ret;
	302
	303	insn = calloc(insn_len, 1);
	304	if (!insn)
	305	return -ENOMEM;
2b00d462	306	insn->op = BYTECODE_OP_GET_SYMBOL;
bff988fa MD	307	bytecode_reloc_offset_u32 =
	308	bytecode_get_len(&ctx->bytecode_reloc->b)
	309	+ sizeof(reloc_offset);
	310	symbol_offset.offset =
	311	(uint16_t) bytecode_reloc_offset_u32;
	312	memcpy(insn->data, &symbol_offset,
	313	sizeof(symbol_offset));
	314	/* reloc_offset points to struct load_op */
	315	reloc_offset_u32 = bytecode_get_len(&ctx->bytecode->b);
	316	if (reloc_offset_u32 > LTTNG_FILTER_MAX_LEN - 1) {
	317	free(insn);
	318	return -EINVAL;
	319	}
	320	reloc_offset = (uint16_t) reloc_offset_u32;
	321	ret = bytecode_push(&ctx->bytecode, insn, 1, insn_len);
	322	if (ret) {
	323	free(insn);
	324	return ret;
	325	}
	326	/* append reloc */
	327	ret = bytecode_push(&ctx->bytecode_reloc, &reloc_offset,
	328	1, sizeof(reloc_offset));
	329	if (ret) {
	330	free(insn);
	331	return ret;
	332	}
	333	ret = bytecode_push(&ctx->bytecode_reloc,
	334	op->u.symbol,
	335	1, strlen(op->u.symbol) + 1);
	336	free(insn);
	337	if (ret) {
	338	return ret;
	339	}
	340	break;
	341	}
	342	case IR_LOAD_EXPRESSION_GET_INDEX:
	343	{
	344	struct load_op *insn;
	345	uint32_t insn_len = sizeof(struct load_op)
	346	+ sizeof(struct get_index_u64);
	347	struct get_index_u64 index;
	348	int ret;
	349
	350	insn = calloc(insn_len, 1);
	351	if (!insn)
	352	return -ENOMEM;
2b00d462	353	insn->op = BYTECODE_OP_GET_INDEX_U64;
bff988fa MD	354	index.index = op->u.index;
	355	memcpy(insn->data, &index, sizeof(index));
	356	ret = bytecode_push(&ctx->bytecode, insn, 1, insn_len);
	357	free(insn);
	358	if (ret) {
	359	return ret;
	360	}
	361	break;
	362	}
	363	case IR_LOAD_EXPRESSION_LOAD_FIELD:
	364	{
	365	struct load_op *insn;
	366	uint32_t insn_len = sizeof(struct load_op);
	367	int ret;
	368
	369	insn = calloc(insn_len, 1);
	370	if (!insn)
	371	return -ENOMEM;
2b00d462	372	insn->op = BYTECODE_OP_LOAD_FIELD;
bff988fa MD	373	ret = bytecode_push(&ctx->bytecode, insn, 1, insn_len);
	374	free(insn);
	375	if (ret) {
	376	return ret;
	377	}
	378	break;
	379	}
	380	}
	381	}
	382	return 0;
	383	}
	384
953192ba MD	385	static
	386	int visit_node_load(struct filter_parser_ctx ctx, struct ir_op node)
	387	{
	388	int ret;
	389
	390	switch (node->data_type) {
	391	case IR_DATA_UNKNOWN:
	392	default:
	393	fprintf(stderr, "[error] Unknown data type in %s\n",
	394	__func__);
	395	return -EINVAL;
	396
	397	case IR_DATA_STRING:
	398	{
	399	struct load_op *insn;
	400	uint32_t insn_len = sizeof(struct load_op)
9f449915	401	+ strlen(node->u.load.u.string.value) + 1;
953192ba MD	402
	403	insn = calloc(insn_len, 1);
	404	if (!insn)
	405	return -ENOMEM;
9f449915 PP	406
	407	switch (node->u.load.u.string.type) {
	408	case IR_LOAD_STRING_TYPE_GLOB_STAR:
	409	/*
	410	* We explicitly tell the interpreter here that
	411	* this load is a full star globbing pattern so
	412	* that the appropriate matching function can be
	413	* called. Also, see comment below.
	414	*/
2b00d462	415	insn->op = BYTECODE_OP_LOAD_STAR_GLOB_STRING;
9f449915 PP	416	break;
	417	default:
	418	/*
	419	* This is the "legacy" string, which includes
	420	* star globbing patterns with a star only at
	421	* the end. Both "plain" and "star at the end"
	422	* literal strings are handled at the same place
	423	* by the tracer's filter bytecode interpreter,
	424	* whereas full star globbing patterns (stars
	425	* can be anywhere in the string) is a special
	426	* case.
	427	*/
2b00d462	428	insn->op = BYTECODE_OP_LOAD_STRING;
9f449915 PP	429	break;
	430	}
	431
	432	strcpy(insn->data, node->u.load.u.string.value);
953192ba MD	433	ret = bytecode_push(&ctx->bytecode, insn, 1, insn_len);
	434	free(insn);
	435	return ret;
	436	}
	437	case IR_DATA_NUMERIC:
	438	{
	439	struct load_op *insn;
	440	uint32_t insn_len = sizeof(struct load_op)
	441	+ sizeof(struct literal_numeric);
	442
	443	insn = calloc(insn_len, 1);
	444	if (!insn)
	445	return -ENOMEM;
2b00d462	446	insn->op = BYTECODE_OP_LOAD_S64;
58d494e4	447	memcpy(insn->data, &node->u.load.u.num, sizeof(int64_t));
953192ba MD	448	ret = bytecode_push(&ctx->bytecode, insn, 1, insn_len);
	449	free(insn);
	450	return ret;
	451	}
e90d8561 MD	452	case IR_DATA_FLOAT:
	453	{
	454	struct load_op *insn;
	455	uint32_t insn_len = sizeof(struct load_op)
	456	+ sizeof(struct literal_double);
	457
	458	insn = calloc(insn_len, 1);
	459	if (!insn)
	460	return -ENOMEM;
2b00d462	461	insn->op = BYTECODE_OP_LOAD_DOUBLE;
58d494e4	462	memcpy(insn->data, &node->u.load.u.flt, sizeof(double));
e90d8561 MD	463	ret = bytecode_push(&ctx->bytecode, insn, 1, insn_len);
	464	free(insn);
	465	return ret;
	466	}
bff988fa MD	467	case IR_DATA_EXPRESSION:
bff988fa MD	468	return visit_node_load_expression(ctx, node);
953192ba MD	469	}
	470	}
	471
	472	static
	473	int visit_node_unary(struct filter_parser_ctx ctx, struct ir_op node)
	474	{
	475	int ret;
	476	struct unary_op insn;
	477
	478	/* Visit child */
	479	ret = recursive_visit_gen_bytecode(ctx, node->u.unary.child);
	480	if (ret)
	481	return ret;
	482
	483	/* Generate end of bytecode instruction */
	484	switch (node->u.unary.type) {
	485	case AST_UNARY_UNKNOWN:
	486	default:
	487	fprintf(stderr, "[error] Unknown unary node type in %s\n",
	488	__func__);
	489	return -EINVAL;
	490	case AST_UNARY_PLUS:
	491	/* Nothing to do. */
	492	return 0;
	493	case AST_UNARY_MINUS:
2b00d462	494	insn.op = BYTECODE_OP_UNARY_MINUS;
953192ba MD	495	return bytecode_push(&ctx->bytecode, &insn, 1, sizeof(insn));
953192ba MD	496	case AST_UNARY_NOT:
2b00d462	497	insn.op = BYTECODE_OP_UNARY_NOT;
953192ba	498	return bytecode_push(&ctx->bytecode, &insn, 1, sizeof(insn));
116d3c01	499	case AST_UNARY_BIT_NOT:
2b00d462	500	insn.op = BYTECODE_OP_UNARY_BIT_NOT;
116d3c01	501	return bytecode_push(&ctx->bytecode, &insn, 1, sizeof(insn));
953192ba MD	502	}
	503	}
	504
	505	/*
	506	* Binary comparator nesting is disallowed. This allows fitting into
	507	* only 2 registers.
	508	*/
	509	static
	510	int visit_node_binary(struct filter_parser_ctx ctx, struct ir_op node)
	511	{
	512	int ret;
	513	struct binary_op insn;
	514
	515	/* Visit child */
	516	ret = recursive_visit_gen_bytecode(ctx, node->u.binary.left);
	517	if (ret)
	518	return ret;
	519	ret = recursive_visit_gen_bytecode(ctx, node->u.binary.right);
	520	if (ret)
	521	return ret;
	522
	523	switch (node->u.binary.type) {
	524	case AST_OP_UNKNOWN:
	525	default:
	526	fprintf(stderr, "[error] Unknown unary node type in %s\n",
	527	__func__);
	528	return -EINVAL;
	529
	530	case AST_OP_AND:
	531	case AST_OP_OR:
	532	fprintf(stderr, "[error] Unexpected logical node type in %s\n",
	533	__func__);
	534	return -EINVAL;
	535
	536	case AST_OP_MUL:
2b00d462	537	insn.op = BYTECODE_OP_MUL;
953192ba MD	538	break;
953192ba MD	539	case AST_OP_DIV:
2b00d462	540	insn.op = BYTECODE_OP_DIV;
953192ba MD	541	break;
953192ba MD	542	case AST_OP_MOD:
2b00d462	543	insn.op = BYTECODE_OP_MOD;
953192ba MD	544	break;
953192ba MD	545	case AST_OP_PLUS:
2b00d462	546	insn.op = BYTECODE_OP_PLUS;
953192ba MD	547	break;
953192ba MD	548	case AST_OP_MINUS:
2b00d462	549	insn.op = BYTECODE_OP_MINUS;
953192ba	550	break;
116d3c01	551	case AST_OP_BIT_RSHIFT:
2b00d462	552	insn.op = BYTECODE_OP_BIT_RSHIFT;
953192ba	553	break;
116d3c01	554	case AST_OP_BIT_LSHIFT:
2b00d462	555	insn.op = BYTECODE_OP_BIT_LSHIFT;
953192ba	556	break;
bff988fa	557	case AST_OP_BIT_AND:
2b00d462	558	insn.op = BYTECODE_OP_BIT_AND;
953192ba	559	break;
bff988fa	560	case AST_OP_BIT_OR:
2b00d462	561	insn.op = BYTECODE_OP_BIT_OR;
953192ba	562	break;
bff988fa	563	case AST_OP_BIT_XOR:
2b00d462	564	insn.op = BYTECODE_OP_BIT_XOR;
953192ba MD	565	break;
	566
	567	case AST_OP_EQ:
2b00d462	568	insn.op = BYTECODE_OP_EQ;
953192ba MD	569	break;
953192ba MD	570	case AST_OP_NE:
2b00d462	571	insn.op = BYTECODE_OP_NE;
953192ba MD	572	break;
953192ba MD	573	case AST_OP_GT:
2b00d462	574	insn.op = BYTECODE_OP_GT;
953192ba MD	575	break;
953192ba MD	576	case AST_OP_LT:
2b00d462	577	insn.op = BYTECODE_OP_LT;
953192ba MD	578	break;
953192ba MD	579	case AST_OP_GE:
2b00d462	580	insn.op = BYTECODE_OP_GE;
953192ba MD	581	break;
953192ba MD	582	case AST_OP_LE:
2b00d462	583	insn.op = BYTECODE_OP_LE;
953192ba MD	584	break;
	585	}
	586	return bytecode_push(&ctx->bytecode, &insn, 1, sizeof(insn));
	587	}
	588
8cf9540a MD	589	/*
	590	* A logical op always return a s64 (1 or 0).
	591	*/
953192ba MD	592	static
	593	int visit_node_logical(struct filter_parser_ctx ctx, struct ir_op node)
	594	{
	595	int ret;
	596	struct logical_op insn;
	597	uint16_t skip_offset_loc;
	598	uint16_t target_loc;
	599
	600	/* Visit left child */
	601	ret = recursive_visit_gen_bytecode(ctx, node->u.binary.left);
	602	if (ret)
	603	return ret;
8cf9540a	604	/* Cast to s64 if float or field ref */
586dc72f	605	if ((node->u.binary.left->data_type == IR_DATA_FIELD_REF
661dfdd1	606	\|\| node->u.binary.left->data_type == IR_DATA_GET_CONTEXT_REF
bff988fa	607	\|\| node->u.binary.left->data_type == IR_DATA_EXPRESSION)
8cf9540a MD	608	\|\| node->u.binary.left->data_type == IR_DATA_FLOAT) {
	609	struct cast_op cast_insn;
	610
586dc72f	611	if (node->u.binary.left->data_type == IR_DATA_FIELD_REF
661dfdd1	612	\|\| node->u.binary.left->data_type == IR_DATA_GET_CONTEXT_REF
bff988fa	613	\|\| node->u.binary.left->data_type == IR_DATA_EXPRESSION) {
2b00d462	614	cast_insn.op = BYTECODE_OP_CAST_TO_S64;
29fefef8	615	} else {
2b00d462	616	cast_insn.op = BYTECODE_OP_CAST_DOUBLE_TO_S64;
29fefef8	617	}
8cf9540a MD	618	ret = bytecode_push(&ctx->bytecode, &cast_insn,
	619	1, sizeof(cast_insn));
	620	if (ret)
	621	return ret;
	622	}
953192ba MD	623	switch (node->u.logical.type) {
	624	default:
	625	fprintf(stderr, "[error] Unknown node type in %s\n",
	626	__func__);
	627	return -EINVAL;
	628
	629	case AST_OP_AND:
2b00d462	630	insn.op = BYTECODE_OP_AND;
953192ba MD	631	break;
953192ba MD	632	case AST_OP_OR:
2b00d462	633	insn.op = BYTECODE_OP_OR;
953192ba MD	634	break;
	635	}
	636	insn.skip_offset = (uint16_t) -1UL; /* Temporary */
	637	ret = bytecode_push_logical(&ctx->bytecode, &insn, 1, sizeof(insn),
	638	&skip_offset_loc);
	639	if (ret)
	640	return ret;
	641	/* Visit right child */
	642	ret = recursive_visit_gen_bytecode(ctx, node->u.binary.right);
	643	if (ret)
	644	return ret;
8cf9540a	645	/* Cast to s64 if float or field ref */
586dc72f	646	if ((node->u.binary.right->data_type == IR_DATA_FIELD_REF
661dfdd1	647	\|\| node->u.binary.right->data_type == IR_DATA_GET_CONTEXT_REF
bff988fa	648	\|\| node->u.binary.right->data_type == IR_DATA_EXPRESSION)
8cf9540a MD	649	\|\| node->u.binary.right->data_type == IR_DATA_FLOAT) {
	650	struct cast_op cast_insn;
	651
586dc72f	652	if (node->u.binary.right->data_type == IR_DATA_FIELD_REF
661dfdd1	653	\|\| node->u.binary.right->data_type == IR_DATA_GET_CONTEXT_REF
bff988fa	654	\|\| node->u.binary.right->data_type == IR_DATA_EXPRESSION) {
2b00d462	655	cast_insn.op = BYTECODE_OP_CAST_TO_S64;
29fefef8	656	} else {
2b00d462	657	cast_insn.op = BYTECODE_OP_CAST_DOUBLE_TO_S64;
29fefef8	658	}
8cf9540a MD	659	ret = bytecode_push(&ctx->bytecode, &cast_insn,
	660	1, sizeof(cast_insn));
	661	if (ret)
	662	return ret;
	663	}
953192ba MD	664	/* We now know where the logical op can skip. */
	665	target_loc = (uint16_t) bytecode_get_len(&ctx->bytecode->b);
	666	ret = bytecode_patch(&ctx->bytecode,
	667	&target_loc, /* Offset to jump to */
	668	skip_offset_loc, /* Where to patch */
	669	sizeof(uint16_t));
	670	return ret;
	671	}
	672
	673	/*
	674	* Postorder traversal of the tree. We need the children result before
	675	* we can evaluate the parent.
	676	*/
	677	static
	678	int recursive_visit_gen_bytecode(struct filter_parser_ctx *ctx,
	679	struct ir_op *node)
	680	{
	681	switch (node->op) {
	682	case IR_OP_UNKNOWN:
	683	default:
	684	fprintf(stderr, "[error] Unknown node type in %s\n",
	685	__func__);
	686	return -EINVAL;
	687
	688	case IR_OP_ROOT:
	689	return visit_node_root(ctx, node);
	690	case IR_OP_LOAD:
	691	return visit_node_load(ctx, node);
	692	case IR_OP_UNARY:
	693	return visit_node_unary(ctx, node);
	694	case IR_OP_BINARY:
	695	return visit_node_binary(ctx, node);
	696	case IR_OP_LOGICAL:
	697	return visit_node_logical(ctx, node);
	698	}
	699	}
	700
a187da1a	701	LTTNG_HIDDEN
953192ba MD	702	void filter_bytecode_free(struct filter_parser_ctx *ctx)
953192ba MD	703	{
7ca1dc6f DG	704	if (!ctx) {
	705	return;
	706	}
	707
3f0c8837 DG	708	if (ctx->bytecode) {
	709	free(ctx->bytecode);
	710	ctx->bytecode = NULL;
	711	}
	712
	713	if (ctx->bytecode_reloc) {
	714	free(ctx->bytecode_reloc);
	715	ctx->bytecode_reloc = NULL;
	716	}
953192ba MD	717	}
953192ba MD	718
a187da1a	719	LTTNG_HIDDEN
953192ba MD	720	int filter_visitor_bytecode_generate(struct filter_parser_ctx *ctx)
	721	{
	722	int ret;
	723
	724	ret = bytecode_init(&ctx->bytecode);
	725	if (ret)
	726	return ret;
	727	ret = bytecode_init(&ctx->bytecode_reloc);
	728	if (ret)
	729	goto error;
	730	ret = recursive_visit_gen_bytecode(ctx, ctx->ir_root);
	731	if (ret)
	732	goto error;
	733
	734	/* Finally, append symbol table to bytecode */
	735	ctx->bytecode->b.reloc_table_offset = bytecode_get_len(&ctx->bytecode->b);
	736	return bytecode_push(&ctx->bytecode, ctx->bytecode_reloc->b.data,
	737	1, bytecode_get_len(&ctx->bytecode_reloc->b));
	738
	739	error:
	740	filter_bytecode_free(ctx);
	741	return ret;
	742	}