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

			if (ret) {
				return ret;
			}

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

			if (ret) {
				return ret;
			}

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

			if (ret) {
				return ret;
			}

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

			if (ret) {
				return ret;
			}

			break;
		}
		case IR_LOAD_EXPRESSION_GET_INDEX:
		{
			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);

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