[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:
		{
			const int ret = bytecode_push_get_context_root(&ctx->bytecode);

			if (ret) {
				return ret;
			}

			break;
		}
		case IR_LOAD_EXPRESSION_GET_APP_CONTEXT_ROOT:
		{
			const int ret = bytecode_push_get_app_context_root(&ctx->bytecode);

			if (ret) {
				return ret;
			}

			break;
		}
		case IR_LOAD_EXPRESSION_GET_PAYLOAD_ROOT:
		{
			const int ret = bytecode_push_get_payload_root(&ctx->bytecode);

			if (ret) {
				return ret;
			}

			break;
		}
		case IR_LOAD_EXPRESSION_GET_SYMBOL:
		{
			const int ret = bytecode_push_get_symbol(
					&ctx->bytecode,
					&ctx->bytecode_reloc,
					op->u.symbol);

			if (ret) {
				return ret;
			}

			break;
		}
		case IR_LOAD_EXPRESSION_GET_INDEX:
		{
			const int ret = bytecode_push_get_index_u64(&ctx->bytecode, op->u.index);

			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	{
6afbab01	243	const int ret = bytecode_push_get_context_root(&ctx->bytecode);
bff988fa	244
bff988fa MD	245	if (ret) {
	246	return ret;
	247	}
6afbab01	248
bff988fa MD	249	break;
	250	}
	251	case IR_LOAD_EXPRESSION_GET_APP_CONTEXT_ROOT:
	252	{
6afbab01	253	const int ret = bytecode_push_get_app_context_root(&ctx->bytecode);
bff988fa	254
bff988fa MD	255	if (ret) {
	256	return ret;
	257	}
6afbab01	258
bff988fa MD	259	break;
	260	}
	261	case IR_LOAD_EXPRESSION_GET_PAYLOAD_ROOT:
	262	{
6afbab01	263	const int ret = bytecode_push_get_payload_root(&ctx->bytecode);
bff988fa	264
bff988fa MD	265	if (ret) {
	266	return ret;
	267	}
6afbab01	268
bff988fa MD	269	break;
	270	}
	271	case IR_LOAD_EXPRESSION_GET_SYMBOL:
	272	{
6afbab01 SM	273	const int ret = bytecode_push_get_symbol(
	274	&ctx->bytecode,
	275	&ctx->bytecode_reloc,
	276	op->u.symbol);
bff988fa	277
bff988fa MD	278	if (ret) {
	279	return ret;
	280	}
6afbab01	281
bff988fa MD	282	break;
	283	}
	284	case IR_LOAD_EXPRESSION_GET_INDEX:
	285	{
6afbab01	286	const int ret = bytecode_push_get_index_u64(&ctx->bytecode, op->u.index);
bff988fa	287
bff988fa MD	288	if (ret) {
	289	return ret;
	290	}
6afbab01	291
bff988fa MD	292	break;
	293	}
	294	case IR_LOAD_EXPRESSION_LOAD_FIELD:
	295	{
	296	struct load_op *insn;
	297	uint32_t insn_len = sizeof(struct load_op);
	298	int ret;
	299
	300	insn = calloc(insn_len, 1);
	301	if (!insn)
	302	return -ENOMEM;
2b00d462	303	insn->op = BYTECODE_OP_LOAD_FIELD;
bff988fa MD	304	ret = bytecode_push(&ctx->bytecode, insn, 1, insn_len);
	305	free(insn);
	306	if (ret) {
	307	return ret;
	308	}
	309	break;
	310	}
	311	}
	312	}
	313	return 0;
	314	}
	315
953192ba MD	316	static
	317	int visit_node_load(struct filter_parser_ctx ctx, struct ir_op node)
	318	{
	319	int ret;
	320
	321	switch (node->data_type) {
	322	case IR_DATA_UNKNOWN:
	323	default:
	324	fprintf(stderr, "[error] Unknown data type in %s\n",
	325	__func__);
	326	return -EINVAL;
	327
	328	case IR_DATA_STRING:
	329	{
	330	struct load_op *insn;
	331	uint32_t insn_len = sizeof(struct load_op)
9f449915	332	+ strlen(node->u.load.u.string.value) + 1;
953192ba MD	333
	334	insn = calloc(insn_len, 1);
	335	if (!insn)
	336	return -ENOMEM;
9f449915 PP	337
	338	switch (node->u.load.u.string.type) {
	339	case IR_LOAD_STRING_TYPE_GLOB_STAR:
	340	/*
	341	* We explicitly tell the interpreter here that
	342	* this load is a full star globbing pattern so
	343	* that the appropriate matching function can be
	344	* called. Also, see comment below.
	345	*/
2b00d462	346	insn->op = BYTECODE_OP_LOAD_STAR_GLOB_STRING;
9f449915 PP	347	break;
	348	default:
	349	/*
	350	* This is the "legacy" string, which includes
	351	* star globbing patterns with a star only at
	352	* the end. Both "plain" and "star at the end"
	353	* literal strings are handled at the same place
	354	* by the tracer's filter bytecode interpreter,
	355	* whereas full star globbing patterns (stars
	356	* can be anywhere in the string) is a special
	357	* case.
	358	*/
2b00d462	359	insn->op = BYTECODE_OP_LOAD_STRING;
9f449915 PP	360	break;
	361	}
	362
	363	strcpy(insn->data, node->u.load.u.string.value);
953192ba MD	364	ret = bytecode_push(&ctx->bytecode, insn, 1, insn_len);
	365	free(insn);
	366	return ret;
	367	}
	368	case IR_DATA_NUMERIC:
	369	{
	370	struct load_op *insn;
	371	uint32_t insn_len = sizeof(struct load_op)
	372	+ sizeof(struct literal_numeric);
	373
	374	insn = calloc(insn_len, 1);
	375	if (!insn)
	376	return -ENOMEM;
2b00d462	377	insn->op = BYTECODE_OP_LOAD_S64;
58d494e4	378	memcpy(insn->data, &node->u.load.u.num, sizeof(int64_t));
953192ba MD	379	ret = bytecode_push(&ctx->bytecode, insn, 1, insn_len);
	380	free(insn);
	381	return ret;
	382	}
e90d8561 MD	383	case IR_DATA_FLOAT:
	384	{
	385	struct load_op *insn;
	386	uint32_t insn_len = sizeof(struct load_op)
	387	+ sizeof(struct literal_double);
	388
	389	insn = calloc(insn_len, 1);
	390	if (!insn)
	391	return -ENOMEM;
2b00d462	392	insn->op = BYTECODE_OP_LOAD_DOUBLE;
58d494e4	393	memcpy(insn->data, &node->u.load.u.flt, sizeof(double));
e90d8561 MD	394	ret = bytecode_push(&ctx->bytecode, insn, 1, insn_len);
	395	free(insn);
	396	return ret;
	397	}
bff988fa MD	398	case IR_DATA_EXPRESSION:
bff988fa MD	399	return visit_node_load_expression(ctx, node);
953192ba MD	400	}
	401	}
	402
	403	static
	404	int visit_node_unary(struct filter_parser_ctx ctx, struct ir_op node)
	405	{
	406	int ret;
	407	struct unary_op insn;
	408
	409	/* Visit child */
	410	ret = recursive_visit_gen_bytecode(ctx, node->u.unary.child);
	411	if (ret)
	412	return ret;
	413
	414	/* Generate end of bytecode instruction */
	415	switch (node->u.unary.type) {
	416	case AST_UNARY_UNKNOWN:
	417	default:
	418	fprintf(stderr, "[error] Unknown unary node type in %s\n",
	419	__func__);
	420	return -EINVAL;
	421	case AST_UNARY_PLUS:
	422	/* Nothing to do. */
	423	return 0;
	424	case AST_UNARY_MINUS:
2b00d462	425	insn.op = BYTECODE_OP_UNARY_MINUS;
953192ba MD	426	return bytecode_push(&ctx->bytecode, &insn, 1, sizeof(insn));
953192ba MD	427	case AST_UNARY_NOT:
2b00d462	428	insn.op = BYTECODE_OP_UNARY_NOT;
953192ba	429	return bytecode_push(&ctx->bytecode, &insn, 1, sizeof(insn));
116d3c01	430	case AST_UNARY_BIT_NOT:
2b00d462	431	insn.op = BYTECODE_OP_UNARY_BIT_NOT;
116d3c01	432	return bytecode_push(&ctx->bytecode, &insn, 1, sizeof(insn));
953192ba MD	433	}
	434	}
	435
	436	/*
	437	* Binary comparator nesting is disallowed. This allows fitting into
	438	* only 2 registers.
	439	*/
	440	static
	441	int visit_node_binary(struct filter_parser_ctx ctx, struct ir_op node)
	442	{
	443	int ret;
	444	struct binary_op insn;
	445
	446	/* Visit child */
	447	ret = recursive_visit_gen_bytecode(ctx, node->u.binary.left);
	448	if (ret)
	449	return ret;
	450	ret = recursive_visit_gen_bytecode(ctx, node->u.binary.right);
	451	if (ret)
	452	return ret;
	453
	454	switch (node->u.binary.type) {
	455	case AST_OP_UNKNOWN:
	456	default:
	457	fprintf(stderr, "[error] Unknown unary node type in %s\n",
	458	__func__);
	459	return -EINVAL;
	460
	461	case AST_OP_AND:
	462	case AST_OP_OR:
	463	fprintf(stderr, "[error] Unexpected logical node type in %s\n",
	464	__func__);
	465	return -EINVAL;
	466
	467	case AST_OP_MUL:
2b00d462	468	insn.op = BYTECODE_OP_MUL;
953192ba MD	469	break;
953192ba MD	470	case AST_OP_DIV:
2b00d462	471	insn.op = BYTECODE_OP_DIV;
953192ba MD	472	break;
953192ba MD	473	case AST_OP_MOD:
2b00d462	474	insn.op = BYTECODE_OP_MOD;
953192ba MD	475	break;
953192ba MD	476	case AST_OP_PLUS:
2b00d462	477	insn.op = BYTECODE_OP_PLUS;
953192ba MD	478	break;
953192ba MD	479	case AST_OP_MINUS:
2b00d462	480	insn.op = BYTECODE_OP_MINUS;
953192ba	481	break;
116d3c01	482	case AST_OP_BIT_RSHIFT:
2b00d462	483	insn.op = BYTECODE_OP_BIT_RSHIFT;
953192ba	484	break;
116d3c01	485	case AST_OP_BIT_LSHIFT:
2b00d462	486	insn.op = BYTECODE_OP_BIT_LSHIFT;
953192ba	487	break;
bff988fa	488	case AST_OP_BIT_AND:
2b00d462	489	insn.op = BYTECODE_OP_BIT_AND;
953192ba	490	break;
bff988fa	491	case AST_OP_BIT_OR:
2b00d462	492	insn.op = BYTECODE_OP_BIT_OR;
953192ba	493	break;
bff988fa	494	case AST_OP_BIT_XOR:
2b00d462	495	insn.op = BYTECODE_OP_BIT_XOR;
953192ba MD	496	break;
	497
	498	case AST_OP_EQ:
2b00d462	499	insn.op = BYTECODE_OP_EQ;
953192ba MD	500	break;
953192ba MD	501	case AST_OP_NE:
2b00d462	502	insn.op = BYTECODE_OP_NE;
953192ba MD	503	break;
953192ba MD	504	case AST_OP_GT:
2b00d462	505	insn.op = BYTECODE_OP_GT;
953192ba MD	506	break;
953192ba MD	507	case AST_OP_LT:
2b00d462	508	insn.op = BYTECODE_OP_LT;
953192ba MD	509	break;
953192ba MD	510	case AST_OP_GE:
2b00d462	511	insn.op = BYTECODE_OP_GE;
953192ba MD	512	break;
953192ba MD	513	case AST_OP_LE:
2b00d462	514	insn.op = BYTECODE_OP_LE;
953192ba MD	515	break;
	516	}
	517	return bytecode_push(&ctx->bytecode, &insn, 1, sizeof(insn));
	518	}
	519
8cf9540a MD	520	/*
	521	* A logical op always return a s64 (1 or 0).
	522	*/
953192ba MD	523	static
	524	int visit_node_logical(struct filter_parser_ctx ctx, struct ir_op node)
	525	{
	526	int ret;
	527	struct logical_op insn;
	528	uint16_t skip_offset_loc;
	529	uint16_t target_loc;
	530
	531	/* Visit left child */
	532	ret = recursive_visit_gen_bytecode(ctx, node->u.binary.left);
	533	if (ret)
	534	return ret;
8cf9540a	535	/* Cast to s64 if float or field ref */
586dc72f	536	if ((node->u.binary.left->data_type == IR_DATA_FIELD_REF
661dfdd1	537	\|\| node->u.binary.left->data_type == IR_DATA_GET_CONTEXT_REF
bff988fa	538	\|\| node->u.binary.left->data_type == IR_DATA_EXPRESSION)
8cf9540a MD	539	\|\| node->u.binary.left->data_type == IR_DATA_FLOAT) {
	540	struct cast_op cast_insn;
	541
586dc72f	542	if (node->u.binary.left->data_type == IR_DATA_FIELD_REF
661dfdd1	543	\|\| node->u.binary.left->data_type == IR_DATA_GET_CONTEXT_REF
bff988fa	544	\|\| node->u.binary.left->data_type == IR_DATA_EXPRESSION) {
2b00d462	545	cast_insn.op = BYTECODE_OP_CAST_TO_S64;
29fefef8	546	} else {
2b00d462	547	cast_insn.op = BYTECODE_OP_CAST_DOUBLE_TO_S64;
29fefef8	548	}
8cf9540a MD	549	ret = bytecode_push(&ctx->bytecode, &cast_insn,
	550	1, sizeof(cast_insn));
	551	if (ret)
	552	return ret;
	553	}
953192ba MD	554	switch (node->u.logical.type) {
	555	default:
	556	fprintf(stderr, "[error] Unknown node type in %s\n",
	557	__func__);
	558	return -EINVAL;
	559
	560	case AST_OP_AND:
2b00d462	561	insn.op = BYTECODE_OP_AND;
953192ba MD	562	break;
953192ba MD	563	case AST_OP_OR:
2b00d462	564	insn.op = BYTECODE_OP_OR;
953192ba MD	565	break;
	566	}
	567	insn.skip_offset = (uint16_t) -1UL; /* Temporary */
	568	ret = bytecode_push_logical(&ctx->bytecode, &insn, 1, sizeof(insn),
	569	&skip_offset_loc);
	570	if (ret)
	571	return ret;
	572	/* Visit right child */
	573	ret = recursive_visit_gen_bytecode(ctx, node->u.binary.right);
	574	if (ret)
	575	return ret;
8cf9540a	576	/* Cast to s64 if float or field ref */
586dc72f	577	if ((node->u.binary.right->data_type == IR_DATA_FIELD_REF
661dfdd1	578	\|\| node->u.binary.right->data_type == IR_DATA_GET_CONTEXT_REF
bff988fa	579	\|\| node->u.binary.right->data_type == IR_DATA_EXPRESSION)
8cf9540a MD	580	\|\| node->u.binary.right->data_type == IR_DATA_FLOAT) {
	581	struct cast_op cast_insn;
	582
586dc72f	583	if (node->u.binary.right->data_type == IR_DATA_FIELD_REF
661dfdd1	584	\|\| node->u.binary.right->data_type == IR_DATA_GET_CONTEXT_REF
bff988fa	585	\|\| node->u.binary.right->data_type == IR_DATA_EXPRESSION) {
2b00d462	586	cast_insn.op = BYTECODE_OP_CAST_TO_S64;
29fefef8	587	} else {
2b00d462	588	cast_insn.op = BYTECODE_OP_CAST_DOUBLE_TO_S64;
29fefef8	589	}
8cf9540a MD	590	ret = bytecode_push(&ctx->bytecode, &cast_insn,
	591	1, sizeof(cast_insn));
	592	if (ret)
	593	return ret;
	594	}
953192ba MD	595	/* We now know where the logical op can skip. */
	596	target_loc = (uint16_t) bytecode_get_len(&ctx->bytecode->b);
	597	ret = bytecode_patch(&ctx->bytecode,
	598	&target_loc, /* Offset to jump to */
	599	skip_offset_loc, /* Where to patch */
	600	sizeof(uint16_t));
	601	return ret;
	602	}
	603
	604	/*
	605	* Postorder traversal of the tree. We need the children result before
	606	* we can evaluate the parent.
	607	*/
	608	static
	609	int recursive_visit_gen_bytecode(struct filter_parser_ctx *ctx,
	610	struct ir_op *node)
	611	{
	612	switch (node->op) {
	613	case IR_OP_UNKNOWN:
	614	default:
	615	fprintf(stderr, "[error] Unknown node type in %s\n",
	616	__func__);
	617	return -EINVAL;
	618
	619	case IR_OP_ROOT:
	620	return visit_node_root(ctx, node);
	621	case IR_OP_LOAD:
	622	return visit_node_load(ctx, node);
	623	case IR_OP_UNARY:
	624	return visit_node_unary(ctx, node);
	625	case IR_OP_BINARY:
	626	return visit_node_binary(ctx, node);
	627	case IR_OP_LOGICAL:
	628	return visit_node_logical(ctx, node);
	629	}
	630	}
	631
a187da1a	632	LTTNG_HIDDEN
953192ba MD	633	void filter_bytecode_free(struct filter_parser_ctx *ctx)
953192ba MD	634	{
7ca1dc6f DG	635	if (!ctx) {
	636	return;
	637	}
	638
3f0c8837 DG	639	if (ctx->bytecode) {
	640	free(ctx->bytecode);
	641	ctx->bytecode = NULL;
	642	}
	643
	644	if (ctx->bytecode_reloc) {
	645	free(ctx->bytecode_reloc);
	646	ctx->bytecode_reloc = NULL;
	647	}
953192ba MD	648	}
953192ba MD	649
a187da1a	650	LTTNG_HIDDEN
953192ba MD	651	int filter_visitor_bytecode_generate(struct filter_parser_ctx *ctx)
	652	{
	653	int ret;
	654
	655	ret = bytecode_init(&ctx->bytecode);
	656	if (ret)
	657	return ret;
	658	ret = bytecode_init(&ctx->bytecode_reloc);
	659	if (ret)
	660	goto error;
	661	ret = recursive_visit_gen_bytecode(ctx, ctx->ir_root);
	662	if (ret)
	663	goto error;
	664
	665	/* Finally, append symbol table to bytecode */
	666	ctx->bytecode->b.reloc_table_offset = bytecode_get_len(&ctx->bytecode->b);
	667	return bytecode_push(&ctx->bytecode, ctx->bytecode_reloc->b.data,
	668	1, bytecode_get_len(&ctx->bytecode_reloc->b));
	669
	670	error:
	671	filter_bytecode_free(ctx);
	672	return ret;
	673	}