[lttng-tools.git] / src / lib / lttng-ctl / filter / filter-bytecode.h

#ifndef _FILTER_BYTECODE_H
#define _FILTER_BYTECODE_H

/*
 * filter-bytecode.h
 *
 * LTTng filter bytecode
 *
 * Copyright 2012 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
 *
 * This library is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License, version 2.1 only,
 * as published by the Free Software Foundation.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this library; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include <common/sessiond-comm/sessiond-comm.h>

#include "filter-ast.h"

/*
 * offsets are absolute from start of bytecode.
 */

struct field_ref {
	/* Initially, symbol offset. After link, field offset. */
	uint16_t offset;
} LTTNG_PACKED;

struct literal_numeric {
	int64_t v;
} LTTNG_PACKED;

struct literal_double {
	double v;
} LTTNG_PACKED;

struct literal_string {
	char string[0];
} LTTNG_PACKED;

enum filter_op {
	FILTER_OP_UNKNOWN			= 0,

	FILTER_OP_RETURN			= 1,

	/* binary */
	FILTER_OP_MUL				= 2,
	FILTER_OP_DIV				= 3,
	FILTER_OP_MOD				= 4,
	FILTER_OP_PLUS				= 5,
	FILTER_OP_MINUS				= 6,
	FILTER_OP_RSHIFT			= 7,
	FILTER_OP_LSHIFT			= 8,
	FILTER_OP_BIN_AND			= 9,
	FILTER_OP_BIN_OR			= 10,
	FILTER_OP_BIN_XOR			= 11,

	/* binary comparators */
	FILTER_OP_EQ				= 12,
	FILTER_OP_NE				= 13,
	FILTER_OP_GT				= 14,
	FILTER_OP_LT				= 15,
	FILTER_OP_GE				= 16,
	FILTER_OP_LE				= 17,

	/* string binary comparator */
	FILTER_OP_EQ_STRING			= 18,
	FILTER_OP_NE_STRING			= 19,
	FILTER_OP_GT_STRING			= 20,
	FILTER_OP_LT_STRING			= 21,
	FILTER_OP_GE_STRING			= 22,
	FILTER_OP_LE_STRING			= 23,

	/* s64 binary comparator */
	FILTER_OP_EQ_S64			= 24,
	FILTER_OP_NE_S64			= 25,
	FILTER_OP_GT_S64			= 26,
	FILTER_OP_LT_S64			= 27,
	FILTER_OP_GE_S64			= 28,
	FILTER_OP_LE_S64			= 29,

	/* double binary comparator */
	FILTER_OP_EQ_DOUBLE			= 30,
	FILTER_OP_NE_DOUBLE			= 31,
	FILTER_OP_GT_DOUBLE			= 32,
	FILTER_OP_LT_DOUBLE			= 33,
	FILTER_OP_GE_DOUBLE			= 34,
	FILTER_OP_LE_DOUBLE			= 35,

	/* Mixed S64-double binary comparators */
	FILTER_OP_EQ_DOUBLE_S64			= 36,
	FILTER_OP_NE_DOUBLE_S64			= 37,
	FILTER_OP_GT_DOUBLE_S64			= 38,
	FILTER_OP_LT_DOUBLE_S64			= 39,
	FILTER_OP_GE_DOUBLE_S64			= 40,
	FILTER_OP_LE_DOUBLE_S64			= 41,

	FILTER_OP_EQ_S64_DOUBLE			= 42,
	FILTER_OP_NE_S64_DOUBLE			= 43,
	FILTER_OP_GT_S64_DOUBLE			= 44,
	FILTER_OP_LT_S64_DOUBLE			= 45,
	FILTER_OP_GE_S64_DOUBLE			= 46,
	FILTER_OP_LE_S64_DOUBLE			= 47,

	/* unary */
	FILTER_OP_UNARY_PLUS			= 48,
	FILTER_OP_UNARY_MINUS			= 49,
	FILTER_OP_UNARY_NOT			= 50,
	FILTER_OP_UNARY_PLUS_S64		= 51,
	FILTER_OP_UNARY_MINUS_S64		= 52,
	FILTER_OP_UNARY_NOT_S64			= 53,
	FILTER_OP_UNARY_PLUS_DOUBLE		= 54,
	FILTER_OP_UNARY_MINUS_DOUBLE		= 55,
	FILTER_OP_UNARY_NOT_DOUBLE		= 56,

	/* logical */
	FILTER_OP_AND				= 57,
	FILTER_OP_OR				= 58,

	/* load */
	FILTER_OP_LOAD_FIELD_REF		= 59,
	FILTER_OP_LOAD_FIELD_REF_STRING		= 60,
	FILTER_OP_LOAD_FIELD_REF_SEQUENCE	= 61,
	FILTER_OP_LOAD_FIELD_REF_S64		= 62,
	FILTER_OP_LOAD_FIELD_REF_DOUBLE		= 63,

	FILTER_OP_LOAD_STRING			= 64,
	FILTER_OP_LOAD_S64			= 65,
	FILTER_OP_LOAD_DOUBLE			= 66,

	/* cast */
	FILTER_OP_CAST_TO_S64			= 67,
	FILTER_OP_CAST_DOUBLE_TO_S64		= 68,
	FILTER_OP_CAST_NOP			= 69,

	NR_FILTER_OPS,
};

typedef uint8_t filter_opcode_t;

struct load_op {
	filter_opcode_t op;
	char data[0];
	/* data to load. Size known by enum filter_opcode and null-term char. */
} LTTNG_PACKED;

struct binary_op {
	filter_opcode_t op;
} LTTNG_PACKED;

struct unary_op {
	filter_opcode_t op;
} LTTNG_PACKED;

/* skip_offset is absolute from start of bytecode */
struct logical_op {
	filter_opcode_t op;
	uint16_t skip_offset;	/* bytecode insn, if skip second test */
} LTTNG_PACKED;

struct cast_op {
	filter_opcode_t op;
} LTTNG_PACKED;

struct return_op {
	filter_opcode_t op;
} LTTNG_PACKED;

struct lttng_filter_bytecode_alloc {
	uint32_t alloc_len;
	struct lttng_filter_bytecode b;
};

static inline
unsigned int bytecode_get_len(struct lttng_filter_bytecode *bytecode)
{
	return bytecode->len;
}

#endif /* _FILTER_BYTECODE_H */
Commit	Line	Data
953192ba MD	1	#ifndef _FILTER_BYTECODE_H
	2	#define _FILTER_BYTECODE_H
	3
	4	/*
	5	* filter-bytecode.h
	6	*
	7	* LTTng filter bytecode
	8	*
	9	* Copyright 2012 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
	10	*
	11	* This library is free software; you can redistribute it and/or modify it
	12	* under the terms of the GNU Lesser General Public License, version 2.1 only,
	13	* as published by the Free Software Foundation.
	14	*
	15	* This library is distributed in the hope that it will be useful,
	16	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	17	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	18	* Lesser General Public License for more details.
	19	*
	20	* You should have received a copy of the GNU Lesser General Public License
	21	* along with this library; if not, write to the Free Software Foundation,
	22	* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	23	*/
	24
d00c599e DG	25	#include <common/sessiond-comm/sessiond-comm.h>
d00c599e DG	26
953192ba MD	27	#include "filter-ast.h"
	28
	29	/*
	30	* offsets are absolute from start of bytecode.
	31	*/
	32
953192ba MD	33	struct field_ref {
	34	/* Initially, symbol offset. After link, field offset. */
	35	uint16_t offset;
6f30f9b8	36	} LTTNG_PACKED;
953192ba MD	37
	38	struct literal_numeric {
	39	int64_t v;
6f30f9b8	40	} LTTNG_PACKED;
953192ba	41
e90d8561 MD	42	struct literal_double {
e90d8561 MD	43	double v;
6f30f9b8	44	} LTTNG_PACKED;
e90d8561	45
953192ba MD	46	struct literal_string {
953192ba MD	47	char string[0];
6f30f9b8	48	} LTTNG_PACKED;
953192ba MD	49
953192ba MD	50	enum filter_op {
7e6831d1	51	FILTER_OP_UNKNOWN = 0,
953192ba	52
7e6831d1	53	FILTER_OP_RETURN = 1,
953192ba MD	54
953192ba MD	55	/* binary */
7e6831d1 MD	56	FILTER_OP_MUL = 2,
	57	FILTER_OP_DIV = 3,
	58	FILTER_OP_MOD = 4,
	59	FILTER_OP_PLUS = 5,
	60	FILTER_OP_MINUS = 6,
	61	FILTER_OP_RSHIFT = 7,
	62	FILTER_OP_LSHIFT = 8,
	63	FILTER_OP_BIN_AND = 9,
	64	FILTER_OP_BIN_OR = 10,
	65	FILTER_OP_BIN_XOR = 11,
78228322 MD	66
78228322 MD	67	/* binary comparators */
7e6831d1 MD	68	FILTER_OP_EQ = 12,
	69	FILTER_OP_NE = 13,
	70	FILTER_OP_GT = 14,
	71	FILTER_OP_LT = 15,
	72	FILTER_OP_GE = 16,
	73	FILTER_OP_LE = 17,
953192ba	74
78228322	75	/* string binary comparator */
7e6831d1 MD	76	FILTER_OP_EQ_STRING = 18,
	77	FILTER_OP_NE_STRING = 19,
	78	FILTER_OP_GT_STRING = 20,
	79	FILTER_OP_LT_STRING = 21,
	80	FILTER_OP_GE_STRING = 22,
	81	FILTER_OP_LE_STRING = 23,
78228322 MD	82
78228322 MD	83	/* s64 binary comparator */
7e6831d1 MD	84	FILTER_OP_EQ_S64 = 24,
	85	FILTER_OP_NE_S64 = 25,
	86	FILTER_OP_GT_S64 = 26,
	87	FILTER_OP_LT_S64 = 27,
	88	FILTER_OP_GE_S64 = 28,
	89	FILTER_OP_LE_S64 = 29,
78228322 MD	90
78228322 MD	91	/* double binary comparator */
7e6831d1 MD	92	FILTER_OP_EQ_DOUBLE = 30,
	93	FILTER_OP_NE_DOUBLE = 31,
	94	FILTER_OP_GT_DOUBLE = 32,
	95	FILTER_OP_LT_DOUBLE = 33,
	96	FILTER_OP_GE_DOUBLE = 34,
	97	FILTER_OP_LE_DOUBLE = 35,
78228322	98
78370c0c	99	/* Mixed S64-double binary comparators */
7e6831d1 MD	100	FILTER_OP_EQ_DOUBLE_S64 = 36,
	101	FILTER_OP_NE_DOUBLE_S64 = 37,
	102	FILTER_OP_GT_DOUBLE_S64 = 38,
	103	FILTER_OP_LT_DOUBLE_S64 = 39,
	104	FILTER_OP_GE_DOUBLE_S64 = 40,
	105	FILTER_OP_LE_DOUBLE_S64 = 41,
	106
	107	FILTER_OP_EQ_S64_DOUBLE = 42,
	108	FILTER_OP_NE_S64_DOUBLE = 43,
	109	FILTER_OP_GT_S64_DOUBLE = 44,
	110	FILTER_OP_LT_S64_DOUBLE = 45,
	111	FILTER_OP_GE_S64_DOUBLE = 46,
	112	FILTER_OP_LE_S64_DOUBLE = 47,
78370c0c	113
953192ba	114	/* unary */
7e6831d1 MD	115	FILTER_OP_UNARY_PLUS = 48,
	116	FILTER_OP_UNARY_MINUS = 49,
	117	FILTER_OP_UNARY_NOT = 50,
	118	FILTER_OP_UNARY_PLUS_S64 = 51,
	119	FILTER_OP_UNARY_MINUS_S64 = 52,
	120	FILTER_OP_UNARY_NOT_S64 = 53,
	121	FILTER_OP_UNARY_PLUS_DOUBLE = 54,
	122	FILTER_OP_UNARY_MINUS_DOUBLE = 55,
	123	FILTER_OP_UNARY_NOT_DOUBLE = 56,
953192ba MD	124
953192ba MD	125	/* logical */
7e6831d1 MD	126	FILTER_OP_AND = 57,
7e6831d1 MD	127	FILTER_OP_OR = 58,
953192ba MD	128
953192ba MD	129	/* load */
7e6831d1 MD	130	FILTER_OP_LOAD_FIELD_REF = 59,
	131	FILTER_OP_LOAD_FIELD_REF_STRING = 60,
	132	FILTER_OP_LOAD_FIELD_REF_SEQUENCE = 61,
	133	FILTER_OP_LOAD_FIELD_REF_S64 = 62,
	134	FILTER_OP_LOAD_FIELD_REF_DOUBLE = 63,
65775683	135
7e6831d1 MD	136	FILTER_OP_LOAD_STRING = 64,
	137	FILTER_OP_LOAD_S64 = 65,
	138	FILTER_OP_LOAD_DOUBLE = 66,
953192ba	139
8cf9540a	140	/* cast */
7e6831d1 MD	141	FILTER_OP_CAST_TO_S64 = 67,
	142	FILTER_OP_CAST_DOUBLE_TO_S64 = 68,
	143	FILTER_OP_CAST_NOP = 69,
8cf9540a	144
953192ba MD	145	NR_FILTER_OPS,
	146	};
	147
	148	typedef uint8_t filter_opcode_t;
	149
	150	struct load_op {
	151	filter_opcode_t op;
953192ba MD	152	char data[0];
953192ba MD	153	/* data to load. Size known by enum filter_opcode and null-term char. */
6f30f9b8	154	} LTTNG_PACKED;
953192ba MD	155
	156	struct binary_op {
	157	filter_opcode_t op;
6f30f9b8	158	} LTTNG_PACKED;
953192ba MD	159
	160	struct unary_op {
	161	filter_opcode_t op;
6f30f9b8	162	} LTTNG_PACKED;
953192ba MD	163
	164	/* skip_offset is absolute from start of bytecode */
	165	struct logical_op {
	166	filter_opcode_t op;
	167	uint16_t skip_offset; /* bytecode insn, if skip second test */
6f30f9b8	168	} LTTNG_PACKED;
953192ba	169
8cf9540a MD	170	struct cast_op {
8cf9540a MD	171	filter_opcode_t op;
6f30f9b8	172	} LTTNG_PACKED;
8cf9540a	173
953192ba MD	174	struct return_op {
953192ba MD	175	filter_opcode_t op;
6f30f9b8	176	} LTTNG_PACKED;
953192ba	177
53a80697	178	struct lttng_filter_bytecode_alloc {
5ddb0a08	179	uint32_t alloc_len;
53a80697	180	struct lttng_filter_bytecode b;
953192ba MD	181	};
	182
	183	static inline
53a80697	184	unsigned int bytecode_get_len(struct lttng_filter_bytecode *bytecode)
953192ba MD	185	{
	186	return bytecode->len;
	187	}
	188
	189	#endif /* _FILTER_BYTECODE_H */