src/common/bytecode/bytecode.h

   1 /*
   2  * Copyright 2020 EfficiOS, Inc.
   3  *
   4  * SPDX-License-Identifier: LGPL-2.1-only
   5  *
   6  */
   7
   8 #ifndef LTTNG_COMMON_BYTECODE_H
   9 #define LTTNG_COMMON_BYTECODE_H
  10
  11 #include <stdint.h>
  12
  13 #include "common/macros.h"
  14 #include "common/sessiond-comm/sessiond-comm.h"
  15
  16 /*
  17  * offsets are absolute from start of bytecode.
  18  */
  19
  20 struct field_ref {
  21         /* Initially, symbol offset. After link, field offset. */
  22         uint16_t offset;
  23 } LTTNG_PACKED;
  24
  25 struct get_symbol {
  26         /* Symbol offset. */
  27         uint16_t offset;
  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;
  36 } LTTNG_PACKED;
  37
  38 struct literal_numeric {
  39         int64_t v;
  40 } LTTNG_PACKED;
  41
  42 struct literal_double {
  43         double v;
  44 } LTTNG_PACKED;
  45
  46 enum bytecode_op {
  47         BYTECODE_OP_UNKNOWN                             = 0,
  48
  49         BYTECODE_OP_RETURN                              = 1,
  50
  51         /* binary */
  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,
  62
  63         /* binary comparators */
  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,
  70
  71         /* string binary comparator: apply to  */
  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,
  78
  79         /* s64 binary comparator */
  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,
  86
  87         /* double binary comparator */
  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,
  94
  95         /* Mixed S64-double binary comparators */
  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,
 109
 110         /* unary */
 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,
 120
 121         /* logical */
 122         BYTECODE_OP_AND                                 = 57,
 123         BYTECODE_OP_OR                                  = 58,
 124
 125         /* load field ref */
 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,
 131
 132         /* load immediate from operand */
 133         BYTECODE_OP_LOAD_STRING                         = 64,
 134         BYTECODE_OP_LOAD_S64                            = 65,
 135         BYTECODE_OP_LOAD_DOUBLE                         = 66,
 136
 137         /* cast */
 138         BYTECODE_OP_CAST_TO_S64                         = 67,
 139         BYTECODE_OP_CAST_DOUBLE_TO_S64                  = 68,
 140         BYTECODE_OP_CAST_NOP                            = 69,
 141
 142         /* get context ref */
 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,
 147
 148         /* load userspace field ref */
 149         BYTECODE_OP_LOAD_FIELD_REF_USER_STRING          = 74,
 150         BYTECODE_OP_LOAD_FIELD_REF_USER_SEQUENCE        = 75,
 151
 152         /*
 153          * load immediate star globbing pattern (literal string)
 154          * from immediate
 155          */
 156         BYTECODE_OP_LOAD_STAR_GLOB_STRING               = 76,
 157
 158         /* globbing pattern binary operator: apply to */
 159         BYTECODE_OP_EQ_STAR_GLOB_STRING                 = 77,
 160         BYTECODE_OP_NE_STAR_GLOB_STRING                 = 78,
 161
 162         /*
 163          * Instructions for recursive traversal through composed types.
 164          */
 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,
 190
 191         NR_BYTECODE_OPS,
 192 };
 193
 194 typedef uint8_t bytecode_opcode_t;
 195
 196 struct load_op {
 197         bytecode_opcode_t op;
 198
 199         /*
 200          * data to load. Size known by enum bytecode_opcode_t and null-term
 201          * char.
 202          */
 203         char data[0];
 204 } LTTNG_PACKED;
 205
 206 struct binary_op {
 207         bytecode_opcode_t op;
 208 } LTTNG_PACKED;
 209
 210 struct unary_op {
 211         bytecode_opcode_t op;
 212 } LTTNG_PACKED;
 213
 214 /* skip_offset is absolute from start of bytecode */
 215 struct logical_op {
 216         bytecode_opcode_t op;
 217         uint16_t skip_offset;   /* bytecode insn, if skip second test */
 218 } LTTNG_PACKED;
 219
 220 struct cast_op {
 221         bytecode_opcode_t op;
 222 } LTTNG_PACKED;
 223
 224 struct return_op {
 225         bytecode_opcode_t op;
 226 } LTTNG_PACKED;
 227
 228 struct lttng_bytecode_alloc {
 229         uint32_t alloc_len;
 230         struct lttng_bytecode b;
 231 };
 232
 233 int bytecode_init(struct lttng_bytecode_alloc **fb);
 234 int bytecode_push(struct lttng_bytecode_alloc **fb,
 235                 const void *data, uint32_t align, uint32_t len);
 236 int bytecode_push_logical(struct lttng_bytecode_alloc **fb,
 237                 struct logical_op *data, uint32_t align, uint32_t len,
 238                 uint16_t *skip_offset);
 239 struct lttng_bytecode *lttng_bytecode_copy(
 240                 const struct lttng_bytecode *orig_f);
 241
 242 int bytecode_push_get_payload_root(
 243                 struct lttng_bytecode_alloc **bytecode);
 244 int bytecode_push_get_context_root(
 245                 struct lttng_bytecode_alloc **bytecode);
 246 int bytecode_push_get_app_context_root(
 247                 struct lttng_bytecode_alloc **bytecode);
 248 int bytecode_push_get_index_u64(
 249                 struct lttng_bytecode_alloc **bytecode, uint64_t index);
 250 int bytecode_push_get_symbol(
 251                 struct lttng_bytecode_alloc **bytecode,
 252                 struct lttng_bytecode_alloc **bytecode_reloc,
 253                 const char *symbol);
 254
 255 static inline
 256 unsigned int bytecode_get_len(struct lttng_bytecode *bytecode)
 257 {
 258         return bytecode->len;
 259 }
 260
 261 #endif /* LTTNG_COMMON_BYTECODE_H */