[lttng-tools.git] / src / common / bytecode / bytecode.hpp

/*
 * Copyright 2020 EfficiOS, Inc.
 *
 * SPDX-License-Identifier: LGPL-2.1-only
 *
 */

#ifndef LTTNG_COMMON_BYTECODE_H
#define LTTNG_COMMON_BYTECODE_H

#include "common/macros.hpp"
#include "common/sessiond-comm/sessiond-comm.hpp"

#include <stdint.h>

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

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

struct get_symbol {
	/* Symbol offset. */
	uint16_t offset;
} LTTNG_PACKED;

struct get_index_u16 {
	uint16_t index;
} LTTNG_PACKED;

struct get_index_u64 {
	uint64_t index;
} LTTNG_PACKED;

struct literal_numeric {
	int64_t v;
} LTTNG_PACKED;

struct literal_double {
	double v;
} LTTNG_PACKED;

enum bytecode_op {
	BYTECODE_OP_UNKNOWN = 0,

	BYTECODE_OP_RETURN = 1,

	/* binary */
	BYTECODE_OP_MUL = 2,
	BYTECODE_OP_DIV = 3,
	BYTECODE_OP_MOD = 4,
	BYTECODE_OP_PLUS = 5,
	BYTECODE_OP_MINUS = 6,
	BYTECODE_OP_BIT_RSHIFT = 7,
	BYTECODE_OP_BIT_LSHIFT = 8,
	BYTECODE_OP_BIT_AND = 9,
	BYTECODE_OP_BIT_OR = 10,
	BYTECODE_OP_BIT_XOR = 11,

	/* binary comparators */
	BYTECODE_OP_EQ = 12,
	BYTECODE_OP_NE = 13,
	BYTECODE_OP_GT = 14,
	BYTECODE_OP_LT = 15,
	BYTECODE_OP_GE = 16,
	BYTECODE_OP_LE = 17,

	/* string binary comparator: apply to  */
	BYTECODE_OP_EQ_STRING = 18,
	BYTECODE_OP_NE_STRING = 19,
	BYTECODE_OP_GT_STRING = 20,
	BYTECODE_OP_LT_STRING = 21,
	BYTECODE_OP_GE_STRING = 22,
	BYTECODE_OP_LE_STRING = 23,

	/* s64 binary comparator */
	BYTECODE_OP_EQ_S64 = 24,
	BYTECODE_OP_NE_S64 = 25,
	BYTECODE_OP_GT_S64 = 26,
	BYTECODE_OP_LT_S64 = 27,
	BYTECODE_OP_GE_S64 = 28,
	BYTECODE_OP_LE_S64 = 29,

	/* double binary comparator */
	BYTECODE_OP_EQ_DOUBLE = 30,
	BYTECODE_OP_NE_DOUBLE = 31,
	BYTECODE_OP_GT_DOUBLE = 32,
	BYTECODE_OP_LT_DOUBLE = 33,
	BYTECODE_OP_GE_DOUBLE = 34,
	BYTECODE_OP_LE_DOUBLE = 35,

	/* Mixed S64-double binary comparators */
	BYTECODE_OP_EQ_DOUBLE_S64 = 36,
	BYTECODE_OP_NE_DOUBLE_S64 = 37,
	BYTECODE_OP_GT_DOUBLE_S64 = 38,
	BYTECODE_OP_LT_DOUBLE_S64 = 39,
	BYTECODE_OP_GE_DOUBLE_S64 = 40,
	BYTECODE_OP_LE_DOUBLE_S64 = 41,

	BYTECODE_OP_EQ_S64_DOUBLE = 42,
	BYTECODE_OP_NE_S64_DOUBLE = 43,
	BYTECODE_OP_GT_S64_DOUBLE = 44,
	BYTECODE_OP_LT_S64_DOUBLE = 45,
	BYTECODE_OP_GE_S64_DOUBLE = 46,
	BYTECODE_OP_LE_S64_DOUBLE = 47,

	/* unary */
	BYTECODE_OP_UNARY_PLUS = 48,
	BYTECODE_OP_UNARY_MINUS = 49,
	BYTECODE_OP_UNARY_NOT = 50,
	BYTECODE_OP_UNARY_PLUS_S64 = 51,
	BYTECODE_OP_UNARY_MINUS_S64 = 52,
	BYTECODE_OP_UNARY_NOT_S64 = 53,
	BYTECODE_OP_UNARY_PLUS_DOUBLE = 54,
	BYTECODE_OP_UNARY_MINUS_DOUBLE = 55,
	BYTECODE_OP_UNARY_NOT_DOUBLE = 56,

	/* logical */
	BYTECODE_OP_AND = 57,
	BYTECODE_OP_OR = 58,

	/* load field ref */
	BYTECODE_OP_LOAD_FIELD_REF = 59,
	BYTECODE_OP_LOAD_FIELD_REF_STRING = 60,
	BYTECODE_OP_LOAD_FIELD_REF_SEQUENCE = 61,
	BYTECODE_OP_LOAD_FIELD_REF_S64 = 62,
	BYTECODE_OP_LOAD_FIELD_REF_DOUBLE = 63,

	/* load immediate from operand */
	BYTECODE_OP_LOAD_STRING = 64,
	BYTECODE_OP_LOAD_S64 = 65,
	BYTECODE_OP_LOAD_DOUBLE = 66,

	/* cast */
	BYTECODE_OP_CAST_TO_S64 = 67,
	BYTECODE_OP_CAST_DOUBLE_TO_S64 = 68,
	BYTECODE_OP_CAST_NOP = 69,

	/* get context ref */
	BYTECODE_OP_GET_CONTEXT_REF = 70,
	BYTECODE_OP_GET_CONTEXT_REF_STRING = 71,
	BYTECODE_OP_GET_CONTEXT_REF_S64 = 72,
	BYTECODE_OP_GET_CONTEXT_REF_DOUBLE = 73,

	/* load userspace field ref */
	BYTECODE_OP_LOAD_FIELD_REF_USER_STRING = 74,
	BYTECODE_OP_LOAD_FIELD_REF_USER_SEQUENCE = 75,

	/*
	 * load immediate star globbing pattern (literal string)
	 * from immediate
	 */
	BYTECODE_OP_LOAD_STAR_GLOB_STRING = 76,

	/* globbing pattern binary operator: apply to */
	BYTECODE_OP_EQ_STAR_GLOB_STRING = 77,
	BYTECODE_OP_NE_STAR_GLOB_STRING = 78,

	/*
	 * Instructions for recursive traversal through composed types.
	 */
	BYTECODE_OP_GET_CONTEXT_ROOT = 79,
	BYTECODE_OP_GET_APP_CONTEXT_ROOT = 80,
	BYTECODE_OP_GET_PAYLOAD_ROOT = 81,

	BYTECODE_OP_GET_SYMBOL = 82,
	BYTECODE_OP_GET_SYMBOL_FIELD = 83,
	BYTECODE_OP_GET_INDEX_U16 = 84,
	BYTECODE_OP_GET_INDEX_U64 = 85,

	BYTECODE_OP_LOAD_FIELD = 86,
	BYTECODE_OP_LOAD_FIELD_S8 = 87,
	BYTECODE_OP_LOAD_FIELD_S16 = 88,
	BYTECODE_OP_LOAD_FIELD_S32 = 89,
	BYTECODE_OP_LOAD_FIELD_S64 = 90,
	BYTECODE_OP_LOAD_FIELD_U8 = 91,
	BYTECODE_OP_LOAD_FIELD_U16 = 92,
	BYTECODE_OP_LOAD_FIELD_U32 = 93,
	BYTECODE_OP_LOAD_FIELD_U64 = 94,
	BYTECODE_OP_LOAD_FIELD_STRING = 95,
	BYTECODE_OP_LOAD_FIELD_SEQUENCE = 96,
	BYTECODE_OP_LOAD_FIELD_DOUBLE = 97,

	BYTECODE_OP_UNARY_BIT_NOT = 98,

	BYTECODE_OP_RETURN_S64 = 99,

	NR_BYTECODE_OPS,
};

using bytecode_opcode_t = uint8_t;

struct load_op {
	bytecode_opcode_t op;

	/*
	 * data to load. Size known by enum bytecode_opcode_t and null-term
	 * char.
	 */
	char data[0];
} LTTNG_PACKED;

struct binary_op {
	bytecode_opcode_t op;
} LTTNG_PACKED;

struct unary_op {
	bytecode_opcode_t op;
} LTTNG_PACKED;

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

struct cast_op {
	bytecode_opcode_t op;
} LTTNG_PACKED;

struct return_op {
	bytecode_opcode_t op;
} LTTNG_PACKED;

struct lttng_bytecode_alloc {
	uint32_t alloc_len;
	struct lttng_bytecode b;
};

int bytecode_init(struct lttng_bytecode_alloc **fb);
int bytecode_push(struct lttng_bytecode_alloc **fb, const void *data, uint32_t align, uint32_t len);
int bytecode_push_logical(struct lttng_bytecode_alloc **fb,
			  struct logical_op *data,
			  uint32_t align,
			  uint32_t len,
			  uint16_t *skip_offset);
struct lttng_bytecode *lttng_bytecode_copy(const struct lttng_bytecode *orig_f);

int bytecode_push_get_payload_root(struct lttng_bytecode_alloc **bytecode);
int bytecode_push_get_context_root(struct lttng_bytecode_alloc **bytecode);
int bytecode_push_get_app_context_root(struct lttng_bytecode_alloc **bytecode);
int bytecode_push_get_index_u64(struct lttng_bytecode_alloc **bytecode, uint64_t index);
int bytecode_push_get_symbol(struct lttng_bytecode_alloc **bytecode,
			     struct lttng_bytecode_alloc **bytecode_reloc,
			     const char *symbol);

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

#endif /* LTTNG_COMMON_BYTECODE_H */
Commit	Line	Data
953192ba	1	/*
0ae3cfc6	2	* Copyright 2020 EfficiOS, Inc.
953192ba	3	*
ab5be9fa	4	* SPDX-License-Identifier: LGPL-2.1-only
953192ba	5	*
953192ba MD	6	*/
953192ba MD	7
0ae3cfc6 SM	8	#ifndef LTTNG_COMMON_BYTECODE_H
0ae3cfc6 SM	9	#define LTTNG_COMMON_BYTECODE_H
d00c599e	10
c9e313bc SM	11	#include "common/macros.hpp"
c9e313bc SM	12	#include "common/sessiond-comm/sessiond-comm.hpp"
953192ba	13
28f23191 JG	14	#include <stdint.h>
28f23191 JG	15
953192ba MD	16	/*
	17	* offsets are absolute from start of bytecode.
	18	*/
	19
953192ba MD	20	struct field_ref {
	21	/* Initially, symbol offset. After link, field offset. */
	22	uint16_t offset;
6f30f9b8	23	} LTTNG_PACKED;
953192ba	24
bff988fa MD	25	struct get_symbol {
bff988fa MD	26	/* Symbol offset. */
661dfdd1	27	uint16_t offset;
bff988fa MD	28	} LTTNG_PACKED;
	29
	30	struct get_index_u16 {
	31	uint16_t index;
	32	} LTTNG_PACKED;
	33
	34	struct get_index_u64 {
	35	uint64_t index;
661dfdd1 MD	36	} LTTNG_PACKED;
661dfdd1 MD	37
953192ba MD	38	struct literal_numeric {
953192ba MD	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
2b00d462	46	enum bytecode_op {
28f23191	47	BYTECODE_OP_UNKNOWN = 0,
953192ba	48
28f23191	49	BYTECODE_OP_RETURN = 1,
953192ba MD	50
953192ba MD	51	/* binary */
28f23191 JG	52	BYTECODE_OP_MUL = 2,
	53	BYTECODE_OP_DIV = 3,
	54	BYTECODE_OP_MOD = 4,
	55	BYTECODE_OP_PLUS = 5,
	56	BYTECODE_OP_MINUS = 6,
	57	BYTECODE_OP_BIT_RSHIFT = 7,
	58	BYTECODE_OP_BIT_LSHIFT = 8,
	59	BYTECODE_OP_BIT_AND = 9,
	60	BYTECODE_OP_BIT_OR = 10,
	61	BYTECODE_OP_BIT_XOR = 11,
78228322 MD	62
78228322 MD	63	/* binary comparators */
28f23191 JG	64	BYTECODE_OP_EQ = 12,
	65	BYTECODE_OP_NE = 13,
	66	BYTECODE_OP_GT = 14,
	67	BYTECODE_OP_LT = 15,
	68	BYTECODE_OP_GE = 16,
	69	BYTECODE_OP_LE = 17,
953192ba	70
9f449915	71	/* string binary comparator: apply to */
28f23191 JG	72	BYTECODE_OP_EQ_STRING = 18,
	73	BYTECODE_OP_NE_STRING = 19,
	74	BYTECODE_OP_GT_STRING = 20,
	75	BYTECODE_OP_LT_STRING = 21,
	76	BYTECODE_OP_GE_STRING = 22,
	77	BYTECODE_OP_LE_STRING = 23,
78228322 MD	78
78228322 MD	79	/* s64 binary comparator */
28f23191 JG	80	BYTECODE_OP_EQ_S64 = 24,
	81	BYTECODE_OP_NE_S64 = 25,
	82	BYTECODE_OP_GT_S64 = 26,
	83	BYTECODE_OP_LT_S64 = 27,
	84	BYTECODE_OP_GE_S64 = 28,
	85	BYTECODE_OP_LE_S64 = 29,
78228322 MD	86
78228322 MD	87	/* double binary comparator */
28f23191 JG	88	BYTECODE_OP_EQ_DOUBLE = 30,
	89	BYTECODE_OP_NE_DOUBLE = 31,
	90	BYTECODE_OP_GT_DOUBLE = 32,
	91	BYTECODE_OP_LT_DOUBLE = 33,
	92	BYTECODE_OP_GE_DOUBLE = 34,
	93	BYTECODE_OP_LE_DOUBLE = 35,
78228322	94
78370c0c	95	/* Mixed S64-double binary comparators */
28f23191 JG	96	BYTECODE_OP_EQ_DOUBLE_S64 = 36,
	97	BYTECODE_OP_NE_DOUBLE_S64 = 37,
	98	BYTECODE_OP_GT_DOUBLE_S64 = 38,
	99	BYTECODE_OP_LT_DOUBLE_S64 = 39,
	100	BYTECODE_OP_GE_DOUBLE_S64 = 40,
	101	BYTECODE_OP_LE_DOUBLE_S64 = 41,
	102
	103	BYTECODE_OP_EQ_S64_DOUBLE = 42,
	104	BYTECODE_OP_NE_S64_DOUBLE = 43,
	105	BYTECODE_OP_GT_S64_DOUBLE = 44,
	106	BYTECODE_OP_LT_S64_DOUBLE = 45,
	107	BYTECODE_OP_GE_S64_DOUBLE = 46,
	108	BYTECODE_OP_LE_S64_DOUBLE = 47,
78370c0c	109
953192ba	110	/* unary */
28f23191 JG	111	BYTECODE_OP_UNARY_PLUS = 48,
	112	BYTECODE_OP_UNARY_MINUS = 49,
	113	BYTECODE_OP_UNARY_NOT = 50,
	114	BYTECODE_OP_UNARY_PLUS_S64 = 51,
	115	BYTECODE_OP_UNARY_MINUS_S64 = 52,
	116	BYTECODE_OP_UNARY_NOT_S64 = 53,
	117	BYTECODE_OP_UNARY_PLUS_DOUBLE = 54,
	118	BYTECODE_OP_UNARY_MINUS_DOUBLE = 55,
	119	BYTECODE_OP_UNARY_NOT_DOUBLE = 56,
953192ba MD	120
953192ba MD	121	/* logical */
28f23191 JG	122	BYTECODE_OP_AND = 57,
28f23191 JG	123	BYTECODE_OP_OR = 58,
953192ba	124
586dc72f	125	/* load field ref */
28f23191 JG	126	BYTECODE_OP_LOAD_FIELD_REF = 59,
	127	BYTECODE_OP_LOAD_FIELD_REF_STRING = 60,
	128	BYTECODE_OP_LOAD_FIELD_REF_SEQUENCE = 61,
	129	BYTECODE_OP_LOAD_FIELD_REF_S64 = 62,
	130	BYTECODE_OP_LOAD_FIELD_REF_DOUBLE = 63,
65775683	131
586dc72f	132	/* load immediate from operand */
28f23191 JG	133	BYTECODE_OP_LOAD_STRING = 64,
	134	BYTECODE_OP_LOAD_S64 = 65,
	135	BYTECODE_OP_LOAD_DOUBLE = 66,
953192ba	136
8cf9540a	137	/* cast */
28f23191 JG	138	BYTECODE_OP_CAST_TO_S64 = 67,
	139	BYTECODE_OP_CAST_DOUBLE_TO_S64 = 68,
	140	BYTECODE_OP_CAST_NOP = 69,
8cf9540a	141
586dc72f	142	/* get context ref */
28f23191 JG	143	BYTECODE_OP_GET_CONTEXT_REF = 70,
	144	BYTECODE_OP_GET_CONTEXT_REF_STRING = 71,
	145	BYTECODE_OP_GET_CONTEXT_REF_S64 = 72,
	146	BYTECODE_OP_GET_CONTEXT_REF_DOUBLE = 73,
586dc72f	147
00a62084	148	/* load userspace field ref */
28f23191 JG	149	BYTECODE_OP_LOAD_FIELD_REF_USER_STRING = 74,
28f23191 JG	150	BYTECODE_OP_LOAD_FIELD_REF_USER_SEQUENCE = 75,
00a62084	151
9f449915 PP	152	/*
	153	* load immediate star globbing pattern (literal string)
	154	* from immediate
	155	*/
28f23191	156	BYTECODE_OP_LOAD_STAR_GLOB_STRING = 76,
9f449915 PP	157
9f449915 PP	158	/* globbing pattern binary operator: apply to */
28f23191 JG	159	BYTECODE_OP_EQ_STAR_GLOB_STRING = 77,
28f23191 JG	160	BYTECODE_OP_NE_STAR_GLOB_STRING = 78,
9f449915	161
bff988fa MD	162	/*
	163	* Instructions for recursive traversal through composed types.
	164	*/
28f23191 JG	165	BYTECODE_OP_GET_CONTEXT_ROOT = 79,
	166	BYTECODE_OP_GET_APP_CONTEXT_ROOT = 80,
	167	BYTECODE_OP_GET_PAYLOAD_ROOT = 81,
	168
	169	BYTECODE_OP_GET_SYMBOL = 82,
	170	BYTECODE_OP_GET_SYMBOL_FIELD = 83,
	171	BYTECODE_OP_GET_INDEX_U16 = 84,
	172	BYTECODE_OP_GET_INDEX_U64 = 85,
	173
	174	BYTECODE_OP_LOAD_FIELD = 86,
	175	BYTECODE_OP_LOAD_FIELD_S8 = 87,
	176	BYTECODE_OP_LOAD_FIELD_S16 = 88,
	177	BYTECODE_OP_LOAD_FIELD_S32 = 89,
	178	BYTECODE_OP_LOAD_FIELD_S64 = 90,
	179	BYTECODE_OP_LOAD_FIELD_U8 = 91,
	180	BYTECODE_OP_LOAD_FIELD_U16 = 92,
	181	BYTECODE_OP_LOAD_FIELD_U32 = 93,
	182	BYTECODE_OP_LOAD_FIELD_U64 = 94,
	183	BYTECODE_OP_LOAD_FIELD_STRING = 95,
	184	BYTECODE_OP_LOAD_FIELD_SEQUENCE = 96,
	185	BYTECODE_OP_LOAD_FIELD_DOUBLE = 97,
	186
	187	BYTECODE_OP_UNARY_BIT_NOT = 98,
	188
	189	BYTECODE_OP_RETURN_S64 = 99,
2b00d462 SM	190
2b00d462 SM	191	NR_BYTECODE_OPS,
953192ba MD	192	};
953192ba MD	193
e665dfbc	194	using bytecode_opcode_t = uint8_t;
953192ba MD	195
953192ba MD	196	struct load_op {
2b00d462 SM	197	bytecode_opcode_t op;
	198
	199	/*
	200	* data to load. Size known by enum bytecode_opcode_t and null-term
	201	* char.
	202	*/
953192ba	203	char data[0];
6f30f9b8	204	} LTTNG_PACKED;
953192ba MD	205
953192ba MD	206	struct binary_op {
2b00d462	207	bytecode_opcode_t op;
6f30f9b8	208	} LTTNG_PACKED;
953192ba MD	209
953192ba MD	210	struct unary_op {
2b00d462	211	bytecode_opcode_t op;
6f30f9b8	212	} LTTNG_PACKED;
953192ba MD	213
	214	/* skip_offset is absolute from start of bytecode */
	215	struct logical_op {
2b00d462	216	bytecode_opcode_t op;
28f23191	217	uint16_t skip_offset; /* bytecode insn, if skip second test */
6f30f9b8	218	} LTTNG_PACKED;
953192ba	219
8cf9540a	220	struct cast_op {
2b00d462	221	bytecode_opcode_t op;
6f30f9b8	222	} LTTNG_PACKED;
8cf9540a	223
953192ba	224	struct return_op {
2b00d462	225	bytecode_opcode_t op;
6f30f9b8	226	} LTTNG_PACKED;
953192ba	227
2b00d462	228	struct lttng_bytecode_alloc {
5ddb0a08	229	uint32_t alloc_len;
2b00d462	230	struct lttng_bytecode b;
953192ba MD	231	};
953192ba MD	232
ca806b0b	233	int bytecode_init(struct lttng_bytecode_alloc **fb);
28f23191	234	int bytecode_push(struct lttng_bytecode_alloc *fb, const void data, uint32_t align, uint32_t len);
ca806b0b	235	int bytecode_push_logical(struct lttng_bytecode_alloc **fb,
28f23191 JG	236	struct logical_op *data,
	237	uint32_t align,
	238	uint32_t len,
	239	uint16_t *skip_offset);
	240	struct lttng_bytecode lttng_bytecode_copy(const struct lttng_bytecode orig_f);
	241
	242	int bytecode_push_get_payload_root(struct lttng_bytecode_alloc **bytecode);
	243	int bytecode_push_get_context_root(struct lttng_bytecode_alloc **bytecode);
	244	int bytecode_push_get_app_context_root(struct lttng_bytecode_alloc **bytecode);
	245	int bytecode_push_get_index_u64(struct lttng_bytecode_alloc **bytecode, uint64_t index);
	246	int bytecode_push_get_symbol(struct lttng_bytecode_alloc **bytecode,
	247	struct lttng_bytecode_alloc **bytecode_reloc,
	248	const char *symbol);
	249
	250	static inline unsigned int bytecode_get_len(struct lttng_bytecode *bytecode)
953192ba MD	251	{
	252	return bytecode->len;
	253	}
	254
0ae3cfc6	255	#endif /* LTTNG_COMMON_BYTECODE_H */