[lttng-ust.git] / liblttng-ust / bytecode.h

/*
 * SPDX-License-Identifier: MIT
 *
 * Copyright 2012-2016 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
 */

#ifndef _BYTECODE_H
#define _BYTECODE_H

#include <stdint.h>
#include <lttng/ust-abi.h>

#ifndef LTTNG_PACKED
#error "LTTNG_PACKED should be defined"
#endif

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

struct field_ref {
	/* Initially, symbol offset. After link, field offset. */
	uint16_t offset;
} __attribute__((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;
} __attribute__((packed));

struct literal_double {
	double v;
} __attribute__((packed));

struct literal_string {
	char string[0];
} __attribute__((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,
};

typedef uint8_t bytecode_opcode_t;

struct load_op {
	bytecode_opcode_t op;
	/*
	 * data to load. Size known by enum bytecode_opcode and null-term char.
	 */
	char data[0];
} __attribute__((packed));

struct binary_op {
	bytecode_opcode_t op;
} __attribute__((packed));

struct unary_op {
	bytecode_opcode_t op;
} __attribute__((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 */
} __attribute__((packed));

struct cast_op {
	bytecode_opcode_t op;
} __attribute__((packed));

struct return_op {
	bytecode_opcode_t op;
} __attribute__((packed));

#endif /* _BYTECODE_H */
Commit	Line	Data
04aa13f8	1	/*
c0c0989a	2	* SPDX-License-Identifier: MIT
04aa13f8	3	*
c0c0989a	4	* Copyright 2012-2016 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
04aa13f8 FD	5	*/
04aa13f8 FD	6
c0c0989a MJ	7	#ifndef _BYTECODE_H
	8	#define _BYTECODE_H
	9
04aa13f8 FD	10	#include <stdint.h>
	11	#include <lttng/ust-abi.h>
	12
	13	#ifndef LTTNG_PACKED
	14	#error "LTTNG_PACKED should be defined"
	15	#endif
	16
	17	/*
	18	* offsets are absolute from start of bytecode.
	19	*/
	20
	21	struct field_ref {
	22	/* Initially, symbol offset. After link, field offset. */
	23	uint16_t offset;
	24	} __attribute__((packed));
	25
	26	struct get_symbol {
	27	/* Symbol offset. */
	28	uint16_t offset;
	29	} LTTNG_PACKED;
	30
	31	struct get_index_u16 {
	32	uint16_t index;
	33	} LTTNG_PACKED;
	34
	35	struct get_index_u64 {
	36	uint64_t index;
	37	} LTTNG_PACKED;
	38
	39	struct literal_numeric {
	40	int64_t v;
	41	} __attribute__((packed));
	42
	43	struct literal_double {
	44	double v;
	45	} __attribute__((packed));
	46
	47	struct literal_string {
	48	char string[0];
	49	} __attribute__((packed));
	50
	51	enum bytecode_op {
	52	BYTECODE_OP_UNKNOWN = 0,
	53
	54	BYTECODE_OP_RETURN = 1,
	55
	56	/* binary */
	57	BYTECODE_OP_MUL = 2,
	58	BYTECODE_OP_DIV = 3,
	59	BYTECODE_OP_MOD = 4,
	60	BYTECODE_OP_PLUS = 5,
	61	BYTECODE_OP_MINUS = 6,
	62	BYTECODE_OP_BIT_RSHIFT = 7,
	63	BYTECODE_OP_BIT_LSHIFT = 8,
	64	BYTECODE_OP_BIT_AND = 9,
	65	BYTECODE_OP_BIT_OR = 10,
	66	BYTECODE_OP_BIT_XOR = 11,
	67
	68	/* binary comparators */
	69	BYTECODE_OP_EQ = 12,
	70	BYTECODE_OP_NE = 13,
	71	BYTECODE_OP_GT = 14,
	72	BYTECODE_OP_LT = 15,
	73	BYTECODE_OP_GE = 16,
74	BYTECODE_OP_LE = 17,
75
76	/* string binary comparator: apply to */
77	BYTECODE_OP_EQ_STRING = 18,
78	BYTECODE_OP_NE_STRING = 19,
79	BYTECODE_OP_GT_STRING = 20,
80	BYTECODE_OP_LT_STRING = 21,
81	BYTECODE_OP_GE_STRING = 22,
82	BYTECODE_OP_LE_STRING = 23,
83
84	/* s64 binary comparator */
85	BYTECODE_OP_EQ_S64 = 24,
86	BYTECODE_OP_NE_S64 = 25,
87	BYTECODE_OP_GT_S64 = 26,
88	BYTECODE_OP_LT_S64 = 27,
89	BYTECODE_OP_GE_S64 = 28,
90	BYTECODE_OP_LE_S64 = 29,
91
92	/* double binary comparator */
93	BYTECODE_OP_EQ_DOUBLE = 30,
94	BYTECODE_OP_NE_DOUBLE = 31,
95	BYTECODE_OP_GT_DOUBLE = 32,
96	BYTECODE_OP_LT_DOUBLE = 33,
97	BYTECODE_OP_GE_DOUBLE = 34,
98	BYTECODE_OP_LE_DOUBLE = 35,
99
100	/* Mixed S64-double binary comparators */
101	BYTECODE_OP_EQ_DOUBLE_S64 = 36,
102	BYTECODE_OP_NE_DOUBLE_S64 = 37,
103	BYTECODE_OP_GT_DOUBLE_S64 = 38,
104	BYTECODE_OP_LT_DOUBLE_S64 = 39,
105	BYTECODE_OP_GE_DOUBLE_S64 = 40,
106	BYTECODE_OP_LE_DOUBLE_S64 = 41,
107
108	BYTECODE_OP_EQ_S64_DOUBLE = 42,
109	BYTECODE_OP_NE_S64_DOUBLE = 43,
110	BYTECODE_OP_GT_S64_DOUBLE = 44,
111	BYTECODE_OP_LT_S64_DOUBLE = 45,
112	BYTECODE_OP_GE_S64_DOUBLE = 46,
113	BYTECODE_OP_LE_S64_DOUBLE = 47,
114
115	/* unary */
116	BYTECODE_OP_UNARY_PLUS = 48,
117	BYTECODE_OP_UNARY_MINUS = 49,
118	BYTECODE_OP_UNARY_NOT = 50,
119	BYTECODE_OP_UNARY_PLUS_S64 = 51,
120	BYTECODE_OP_UNARY_MINUS_S64 = 52,
121	BYTECODE_OP_UNARY_NOT_S64 = 53,
122	BYTECODE_OP_UNARY_PLUS_DOUBLE = 54,
123	BYTECODE_OP_UNARY_MINUS_DOUBLE = 55,
124	BYTECODE_OP_UNARY_NOT_DOUBLE = 56,
125
126	/* logical */
127	BYTECODE_OP_AND = 57,
128	BYTECODE_OP_OR = 58,
129
130	/* load field ref */
131	BYTECODE_OP_LOAD_FIELD_REF = 59,
132	BYTECODE_OP_LOAD_FIELD_REF_STRING = 60,
133	BYTECODE_OP_LOAD_FIELD_REF_SEQUENCE = 61,
134	BYTECODE_OP_LOAD_FIELD_REF_S64 = 62,
135	BYTECODE_OP_LOAD_FIELD_REF_DOUBLE = 63,
136
137	/* load immediate from operand */
138	BYTECODE_OP_LOAD_STRING = 64,
139	BYTECODE_OP_LOAD_S64 = 65,
140	BYTECODE_OP_LOAD_DOUBLE = 66,
141
142	/* cast */
143	BYTECODE_OP_CAST_TO_S64 = 67,
144	BYTECODE_OP_CAST_DOUBLE_TO_S64 = 68,
145	BYTECODE_OP_CAST_NOP = 69,
146
147	/* get context ref */
148	BYTECODE_OP_GET_CONTEXT_REF = 70,
149	BYTECODE_OP_GET_CONTEXT_REF_STRING = 71,
150	BYTECODE_OP_GET_CONTEXT_REF_S64 = 72,
151	BYTECODE_OP_GET_CONTEXT_REF_DOUBLE = 73,
152
153	/* load userspace field ref */
154	BYTECODE_OP_LOAD_FIELD_REF_USER_STRING = 74,
155	BYTECODE_OP_LOAD_FIELD_REF_USER_SEQUENCE = 75,
156
157	/*
158	* load immediate star globbing pattern (literal string)
159	* from immediate
160	*/
161	BYTECODE_OP_LOAD_STAR_GLOB_STRING = 76,
162
163	/* globbing pattern binary operator: apply to */
164	BYTECODE_OP_EQ_STAR_GLOB_STRING = 77,
165	BYTECODE_OP_NE_STAR_GLOB_STRING = 78,
166
167	/*
168	* Instructions for recursive traversal through composed types.
169	*/
170	BYTECODE_OP_GET_CONTEXT_ROOT = 79,
171	BYTECODE_OP_GET_APP_CONTEXT_ROOT = 80,
172	BYTECODE_OP_GET_PAYLOAD_ROOT = 81,
173
174	BYTECODE_OP_GET_SYMBOL = 82,
175	BYTECODE_OP_GET_SYMBOL_FIELD = 83,
176	BYTECODE_OP_GET_INDEX_U16 = 84,
177	BYTECODE_OP_GET_INDEX_U64 = 85,
178
179	BYTECODE_OP_LOAD_FIELD = 86,
180	BYTECODE_OP_LOAD_FIELD_S8 = 87,
181	BYTECODE_OP_LOAD_FIELD_S16 = 88,
182	BYTECODE_OP_LOAD_FIELD_S32 = 89,
183	BYTECODE_OP_LOAD_FIELD_S64 = 90,
184	BYTECODE_OP_LOAD_FIELD_U8 = 91,
185	BYTECODE_OP_LOAD_FIELD_U16 = 92,
186	BYTECODE_OP_LOAD_FIELD_U32 = 93,
187	BYTECODE_OP_LOAD_FIELD_U64 = 94,
188	BYTECODE_OP_LOAD_FIELD_STRING = 95,
189	BYTECODE_OP_LOAD_FIELD_SEQUENCE = 96,
190	BYTECODE_OP_LOAD_FIELD_DOUBLE = 97,
191
192	BYTECODE_OP_UNARY_BIT_NOT = 98,
193
194	BYTECODE_OP_RETURN_S64 = 99,
195
196	NR_BYTECODE_OPS,
197	};
198
199	typedef uint8_t bytecode_opcode_t;
200
201	struct load_op {
202	bytecode_opcode_t op;
203	/*
204	* data to load. Size known by enum bytecode_opcode and null-term char.
205	*/
206	char data[0];
207	} __attribute__((packed));
208
209	struct binary_op {
210	bytecode_opcode_t op;
211	} __attribute__((packed));
212
213	struct unary_op {
214	bytecode_opcode_t op;
215	} __attribute__((packed));
216
217	/* skip_offset is absolute from start of bytecode */
218	struct logical_op {
219	bytecode_opcode_t op;
220	uint16_t skip_offset; /* bytecode insn, if skip second test */
221	} __attribute__((packed));
222
223	struct cast_op {
224	bytecode_opcode_t op;
225	} __attribute__((packed));
226
227	struct return_op {
228	bytecode_opcode_t op;
229	} __attribute__((packed));
230
231	#endif /* _BYTECODE_H */