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

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

#ifndef LTTNG_COMMON_BYTECODE_H
#define LTTNG_COMMON_BYTECODE_H

#include <stdint.h>

#include "common/macros.h"
#include "common/sessiond-comm/sessiond-comm.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;

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

typedef uint8_t bytecode_opcode_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;
};

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

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