muapi.h 48.1 KB
Newer Older
Kunshan Wang's avatar
Kunshan Wang committed
1 2 3 4 5 6 7 8 9
#ifndef __MUAPI_H__
#define __MUAPI_H__

#ifdef __cplusplus
extern "C" {
#endif

#include <stdint.h>

10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45
// ABOUT HEADER PARSERS
//
// This header is designed to be processed by a regular-expression-based parser
// so that it will be convenient to to generate language bindings. There is one
// such parser in the reference implementation v2: muapiparser.py
//
// It can identify the type hierarchies of the typedefs below, so language
// bindings can auto-generate a class hierarchy for MuValue handles if the
// high-level language supports, such as Python. For the convenience of this
// purpose, all typedefs are in the simplest form: "typedef FromTy ToType;"
// where FromTy may end with an asterisk '*'. Typedefs of function pointer types
// are deliberately separated into two steps (see MuCFP below), because
// regexp-based parsers may not be smart enough to parse function pointer types.
//
// It can find all definitions of macro constants. These constants, such as
// MU_BINOP_ADD, all have prefixes to make parsing easy.
//
// It can find methods of MuVM and MuCtx which are structs of function pointers.
// Parameter types use high-level typedef-ed types so that the language binding
// generator has more information (such as MuInstResNode) than the raw C types
// (such as void*).
//
// The "/// MUAPIPARSER" comments provide extra annotations (pragmas) for the
// method just before it. Multiple pragmas are separated by semicolons ';'.
//
//  param:array:sz_param
//      means param is a pointer to an array, and the effective length is
//      determined by the sz_param parameter. param can be NULL, in which case
//      it is considered as a 0-length array.
//  param:optional
//      means param is a pointer and it may be NULL.
//  param:out
//      means param is a pointer and it is supposed to be used as an output
//      parameter. Values should be written in rather than read out of it.


Kunshan Wang's avatar
Kunshan Wang committed
46 47 48 49 50 51 52
// MuValue and MuXxxValue type are opaque handles to values in the Mu type
// system.
//
// The actual values are held by MuCtx. MuValue opaquely refers to one such
// value. Copies of MuValue values refer to the same value. A MuValue instance
// can only be used in the MuCtx holding it.
//
53 54
// Values of subtypes can be cast to/from their abstract parents using the type
// cast expression in C, similar to casting one pointer to another.
55

56 57 58 59 60 61
// Top value type.
typedef void *MuValue;                // Any Mu value

// Abstract value type.
typedef MuValue MuSeqValue;           // array or vector
typedef MuValue MuGenRefValue;        // ref, iref, funcref, threadref, stackref, framecursorref, irnoderef
62 63

// concrete value types
Kunshan Wang's avatar
Kunshan Wang committed
64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80
typedef MuValue MuIntValue;           // int<n>
typedef MuValue MuFloatValue;         // float
typedef MuValue MuDoubleValue;        // double
typedef MuValue MuUPtrValue;          // uptr
typedef MuValue MuUFPValue;           // ufuncptr

typedef MuSeqValue MuStructValue;     // struct<...>
typedef MuSeqValue MuArrayValue;      // array<T l>
typedef MuSeqValue MuVectorValue;     // vector<T l>

typedef MuGenRefValue MuRefValue;           // ref<T>
typedef MuGenRefValue MuIRefValue;          // iref<T>
typedef MuGenRefValue MuTagRef64Value;      // tagref64
typedef MuGenRefValue MuFuncRefValue;       // funcref<sig>
typedef MuGenRefValue MuThreadRefValue;     // threadref
typedef MuGenRefValue MuStackRefValue;      // stackref
typedef MuGenRefValue MuFCRefValue;         // framecursorref
Kunshan Wang's avatar
Kunshan Wang committed
81
typedef MuGenRefValue MuIRNode;             // irnoderef
Kunshan Wang's avatar
Kunshan Wang committed
82 83 84

// Subtypes of MuIRNodeRefValue. These are used in the IR Builder API.

85
// IR node reference hierarchy
Kunshan Wang's avatar
Kunshan Wang committed
86
typedef MuIRNode MuBundleNode;          // Bundle
87 88

// NOTE: All MuChildNode can have ID (ctx->get_id) and name (ctx->set_name)
Kunshan Wang's avatar
Kunshan Wang committed
89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104
typedef MuIRNode MuChildNode;           // All children of bundle
typedef MuChildNode MuTypeNode;             // Type
typedef MuChildNode MuFuncSigNode;          // Function signature
typedef MuChildNode MuVarNode;              // Variable
typedef MuVarNode MuGlobalVarNode;          // Global variable
typedef MuGlobalVarNode MuConstNode;            // Constant
typedef MuGlobalVarNode MuGlobalNode;           // Global cell
typedef MuGlobalVarNode MuFuncNode;             // Function
typedef MuGlobalVarNode MuExpFuncNode;          // Exposed function
typedef MuVarNode MuLocalVarNode;           // Local variable
typedef MuLocalVarNode MuNorParamNode;          // Normal parameter
typedef MuLocalVarNode MuExcParamNode;          // Exception parameter
typedef MuLocalVarNode MuInstResNode;           // Instruction result
typedef MuChildNode MuFuncVerNode;          // Function version
typedef MuChildNode MuBBNode;               // Basic block
typedef MuChildNode MuInstNode;             // Instruction (itself, not result)
Kunshan Wang's avatar
Kunshan Wang committed
105 106 107 108 109 110 111

// Identifiers and names of Mu
typedef uint32_t MuID;
typedef char *MuName;

// Convenient types for the void* type and the void(*)() type in C
typedef void *MuCPtr;
112 113 114 115 116 117 118 119 120 121
typedef void _MuCFP_Func();
typedef _MuCFP_Func* MuCFP;

// Boolean type. The size of the C99 standard bool type seems to vary a lot
// among ABIs. So we use int instead. In C, the result type of relational and
// logical expressions are int.
typedef int MuBool;

// Use uintptr_t for the size of all array parameters.
typedef uintptr_t MuArraySize;
Kunshan Wang's avatar
Kunshan Wang committed
122

123
// Watch point ID
Kunshan Wang's avatar
Kunshan Wang committed
124 125 126 127 128
typedef uint32_t MuWPID;

// Super type for numerical flags used by Mu.
typedef uint32_t MuFlag;

Kunshan Wang's avatar
Kunshan Wang committed
129
// Result of a trap handler
Kunshan Wang's avatar
Kunshan Wang committed
130
typedef MuFlag MuTrapHandlerResult;
131 132

// Values or MuTrapHandlerResult
Kunshan Wang's avatar
Kunshan Wang committed
133 134 135
#define MU_THREAD_EXIT          ((MuTrapHandlerResult)0x00)
#define MU_REBIND_PASS_VALUES   ((MuTrapHandlerResult)0x01)
#define MU_REBIND_THROW_EXC     ((MuTrapHandlerResult)0x02)
Kunshan Wang's avatar
Kunshan Wang committed
136

137
// Used by MuTrapHandler
138 139
typedef void _MuValuesFreer_Func(MuValue *values, MuCPtr freerdata);
typedef _MuValuesFreer_Func* MuValuesFreer;
140

Kunshan Wang's avatar
Kunshan Wang committed
141 142 143 144 145
// Declare the types here because they are used in the following signatures.
typedef struct MuVM MuVM;
typedef struct MuCtx MuCtx;

// Signature of the trap handler
146 147
typedef void _MuTrapHandler_Func(
        // input parameters
148 149 150
        MuCtx *ctx,
        MuThreadRefValue thread,
        MuStackRefValue stack,
Kunshan Wang's avatar
Kunshan Wang committed
151
        MuWPID wpid,
152 153 154 155
        // output parameters
        MuTrapHandlerResult *result,
        MuStackRefValue *new_stack,
        MuValue **values,
156
        MuArraySize *nvalues,
157 158 159 160
        MuValuesFreer *freer,
        MuCPtr *freerdata,
        MuRefValue *exception,
        // input parameter (userdata)
Kunshan Wang's avatar
Kunshan Wang committed
161
        MuCPtr userdata);
162
typedef _MuTrapHandler_Func* MuTrapHandler;
Kunshan Wang's avatar
Kunshan Wang committed
163

Kunshan Wang's avatar
Kunshan Wang committed
164 165
// Destination kinds
typedef MuFlag MuDestKind;
Kunshan Wang's avatar
Kunshan Wang committed
166 167 168 169 170 171 172
#define MU_DEST_NORMAL      ((MuDestKind)0x01)
#define MU_DEST_EXCEPT      ((MuDestKind)0x02)
#define MU_DEST_TRUE        ((MuDestKind)0x03)
#define MU_DEST_FALSE       ((MuDestKind)0x04)
#define MU_DEST_DEFAULT     ((MuDestKind)0x05)
#define MU_DEST_DISABLED    ((MuDestKind)0x06)
#define MU_DEST_ENABLED     ((MuDestKind)0x07)
Kunshan Wang's avatar
Kunshan Wang committed
173 174 175

// Binary operators
typedef MuFlag MuBinOptr;
Kunshan Wang's avatar
Kunshan Wang committed
176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193
#define MU_BINOP_ADD    ((MuBinOptr)0x01)
#define MU_BINOP_SUB    ((MuBinOptr)0x02)
#define MU_BINOP_MUL    ((MuBinOptr)0x03)
#define MU_BINOP_SDIV   ((MuBinOptr)0x04)
#define MU_BINOP_SREM   ((MuBinOptr)0x05)
#define MU_BINOP_UDIV   ((MuBinOptr)0x06)
#define MU_BINOP_UREM   ((MuBinOptr)0x07)
#define MU_BINOP_SHL    ((MuBinOptr)0x08)
#define MU_BINOP_LSHR   ((MuBinOptr)0x09)
#define MU_BINOP_ASHR   ((MuBinOptr)0x0A)
#define MU_BINOP_AND    ((MuBinOptr)0x0B)
#define MU_BINOP_OR     ((MuBinOptr)0x0C)
#define MU_BINOP_XOR    ((MuBinOptr)0x0D)
#define MU_BINOP_FADD   ((MuBinOptr)0xB0)
#define MU_BINOP_FSUB   ((MuBinOptr)0xB1)
#define MU_BINOP_FMUL   ((MuBinOptr)0xB2)
#define MU_BINOP_FDIV   ((MuBinOptr)0xB3)
#define MU_BINOP_FREM   ((MuBinOptr)0xB4)
Kunshan Wang's avatar
Kunshan Wang committed
194 195 196

// Comparing operators
typedef MuFlag MuCmpOptr;
Kunshan Wang's avatar
Kunshan Wang committed
197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222
#define MU_CMP_EQ       ((MuCmpOptr)0x20)
#define MU_CMP_NE       ((MuCmpOptr)0x21)
#define MU_CMP_SGE      ((MuCmpOptr)0x22)
#define MU_CMP_SGT      ((MuCmpOptr)0x23)
#define MU_CMP_SLE      ((MuCmpOptr)0x24)
#define MU_CMP_SLT      ((MuCmpOptr)0x25)
#define MU_CMP_UGE      ((MuCmpOptr)0x26)
#define MU_CMP_UGT      ((MuCmpOptr)0x27)
#define MU_CMP_ULE      ((MuCmpOptr)0x28)
#define MU_CMP_ULT      ((MuCmpOptr)0x29)
#define MU_CMP_FFALSE   ((MuCmpOptr)0xC0)
#define MU_CMP_FTRUE    ((MuCmpOptr)0xC1)
#define MU_CMP_FUNO     ((MuCmpOptr)0xC2)
#define MU_CMP_FUEQ     ((MuCmpOptr)0xC3)
#define MU_CMP_FUNE     ((MuCmpOptr)0xC4)
#define MU_CMP_FUGT     ((MuCmpOptr)0xC5)
#define MU_CMP_FUGE     ((MuCmpOptr)0xC6)
#define MU_CMP_FULT     ((MuCmpOptr)0xC7)
#define MU_CMP_FULE     ((MuCmpOptr)0xC8)
#define MU_CMP_FORD     ((MuCmpOptr)0xC9)
#define MU_CMP_FOEQ     ((MuCmpOptr)0xCA)
#define MU_CMP_FONE     ((MuCmpOptr)0xCB)
#define MU_CMP_FOGT     ((MuCmpOptr)0xCC)
#define MU_CMP_FOGE     ((MuCmpOptr)0xCD)
#define MU_CMP_FOLT     ((MuCmpOptr)0xCE)
#define MU_CMP_FOLE     ((MuCmpOptr)0xCF)
Kunshan Wang's avatar
Kunshan Wang committed
223 224 225

// Conversion operators
typedef MuFlag MuConvOptr;
Kunshan Wang's avatar
Kunshan Wang committed
226 227 228 229 230 231 232 233 234 235 236 237
#define MU_CONV_TRUNC   ((MuConvOptr)0x30)
#define MU_CONV_ZEXT    ((MuConvOptr)0x31)
#define MU_CONV_SEXT    ((MuConvOptr)0x32)
#define MU_CONV_FPTRUNC ((MuConvOptr)0x33)
#define MU_CONV_FPEXT   ((MuConvOptr)0x34)
#define MU_CONV_FPTOUI  ((MuConvOptr)0x35)
#define MU_CONV_FPTOSI  ((MuConvOptr)0x36)
#define MU_CONV_UITOFP  ((MuConvOptr)0x37)
#define MU_CONV_SITOFP  ((MuConvOptr)0x38)
#define MU_CONV_BITCAST ((MuConvOptr)0x39)
#define MU_CONV_REFCAST ((MuConvOptr)0x3A)
#define MU_CONV_PTRCAST ((MuConvOptr)0x3B)
Kunshan Wang's avatar
Kunshan Wang committed
238

Kunshan Wang's avatar
Kunshan Wang committed
239 240
// Memory orders
typedef MuFlag MuMemOrd;
Kunshan Wang's avatar
Kunshan Wang committed
241 242 243 244 245 246 247
#define MU_ORD_NOT_ATOMIC   ((MuMemOrd)0x00)
#define MU_ORD_RELAXED      ((MuMemOrd)0x01)
#define MU_ORD_CONSUME      ((MuMemOrd)0x02)
#define MU_ORD_ACQUIRE      ((MuMemOrd)0x03)
#define MU_ORD_RELEASE      ((MuMemOrd)0x04)
#define MU_ORD_ACQ_REL      ((MuMemOrd)0x05)
#define MU_ORD_SEQ_CST      ((MuMemOrd)0x06)
Kunshan Wang's avatar
Kunshan Wang committed
248 249

// Operations for the atomicrmw API function
Kunshan Wang's avatar
Kunshan Wang committed
250 251 252 253 254 255 256 257 258 259 260 261
typedef MuFlag MuAtomicRMWOptr;
#define MU_ARMW_XCHG    ((MuAtomicRMWOptr)0x00)
#define MU_ARMW_ADD     ((MuAtomicRMWOptr)0x01)
#define MU_ARMW_SUB     ((MuAtomicRMWOptr)0x02)
#define MU_ARMW_AND     ((MuAtomicRMWOptr)0x03)
#define MU_ARMW_NAND    ((MuAtomicRMWOptr)0x04)
#define MU_ARMW_OR      ((MuAtomicRMWOptr)0x05)
#define MU_ARMW_XOR     ((MuAtomicRMWOptr)0x06)
#define MU_ARMW_MAX     ((MuAtomicRMWOptr)0x07)
#define MU_ARMW_MIN     ((MuAtomicRMWOptr)0x08)
#define MU_ARMW_UMAX    ((MuAtomicRMWOptr)0x09)
#define MU_ARMW_UMIN    ((MuAtomicRMWOptr)0x0A)
Kunshan Wang's avatar
Kunshan Wang committed
262 263

// Calling conventions.
Kunshan Wang's avatar
Kunshan Wang committed
264
typedef MuFlag MuCallConv;
Kunshan Wang's avatar
Kunshan Wang committed
265
#define MU_CC_DEFAULT   ((MuCallConv)0x00)
Kunshan Wang's avatar
Kunshan Wang committed
266 267
// Concrete Mu implementations may define more calling conventions.

Kunshan Wang's avatar
Kunshan Wang committed
268 269 270
// Common instructions.
typedef MuFlag MuCommInst;

Kunshan Wang's avatar
Kunshan Wang committed
271 272 273 274 275 276 277 278 279 280 281 282 283
// NOTE: MuVM and MuCtx are structures with many function pointers. This
// approach loosens the coupling between the client module and the Mu
// implementation.  At compile time, the client does not need to link against
// any dynamic libraries. At run time, more than one Mu implementations can be
// used by the same client.

// A handle and method lists of a micro VM
struct MuVM {
    void *header;   // Refer to internal stuff

    // Create context
    MuCtx*  (*new_context)(MuVM *mvm);
    
284
    // Convert between IDs and names. Cannot be used on the bundles being built.
Kunshan Wang's avatar
Kunshan Wang committed
285 286 287 288 289
    MuID    (*id_of  )(MuVM *mvm, MuName name);
    MuName  (*name_of)(MuVM *mvm, MuID id);

    // Set handlers
    void    (*set_trap_handler      )(MuVM *mvm, MuTrapHandler trap_handler, MuCPtr userdata);
290

291
    // Proprietary API of refimpl2: Let the micro VM execute.
292
    void    (*execute)(MuVM *mvm);
Kunshan Wang's avatar
Kunshan Wang committed
293

294 295 296 297 298
    // Proprietary API of refimpl2: Get the pointer to the internal error
    // number allocate in the micro VM. It is set to non-zero whenever an
    // exception is thrown when the client calls through this C API. This gives
    // the client a chance to terminate because JNI is not able to propagate
    // JVM exceptions to C.
299
    int*    (*get_mu_error_ptr)(MuVM *mvm);
Kunshan Wang's avatar
Kunshan Wang committed
300 301 302 303
};

// A local context. It can only be used by one thread at a time. It holds many
// states which are typically held by a Mu thread, such as object references,
Kunshan Wang's avatar
Kunshan Wang committed
304
// local heap allocation pool, and an object-pinning set. It also holds many Mu
Kunshan Wang's avatar
Kunshan Wang committed
305 306 307 308 309
// values and expose them to the client as opaque handles (MuValue and its
// subtypes).
struct MuCtx {
    void *header;   // Refer to internal stuff

310
    // Convert between IDs and names. Cannot be used on the bundles being built.
Kunshan Wang's avatar
Kunshan Wang committed
311 312 313 314 315 316 317
    MuID        (*id_of  )(MuCtx *ctx, MuName name);
    MuName      (*name_of)(MuCtx *ctx, MuID id);

    // Close the current context, releasing all resources
    void        (*close_context)(MuCtx *ctx);

    // Load bundles and HAIL scripts
318 319
    void        (*load_bundle)(MuCtx *ctx, char *buf, MuArraySize sz); /// MUAPIPARSER buf:array:sz
    void        (*load_hail  )(MuCtx *ctx, char *buf, MuArraySize sz); /// MUAPIPARSER buf:array:sz
Kunshan Wang's avatar
Kunshan Wang committed
320 321

    // Convert from C values to Mu values
322 323 324 325 326 327 328 329 330 331 332 333 334
    MuIntValue      (*handle_from_sint8  )(MuCtx *ctx, int8_t     num, int len);
    MuIntValue      (*handle_from_uint8  )(MuCtx *ctx, uint8_t    num, int len);
    MuIntValue      (*handle_from_sint16 )(MuCtx *ctx, int16_t    num, int len);
    MuIntValue      (*handle_from_uint16 )(MuCtx *ctx, uint16_t   num, int len);
    MuIntValue      (*handle_from_sint32 )(MuCtx *ctx, int32_t    num, int len);
    MuIntValue      (*handle_from_uint32 )(MuCtx *ctx, uint32_t   num, int len);
    MuIntValue      (*handle_from_sint64 )(MuCtx *ctx, int64_t    num, int len);
    MuIntValue      (*handle_from_uint64 )(MuCtx *ctx, uint64_t   num, int len);
    MuIntValue      (*handle_from_uint64s)(MuCtx *ctx, uint64_t *nums, MuArraySize nnums, int len); /// MUAPIPARSER nums:array:nnums
    MuFloatValue    (*handle_from_float  )(MuCtx *ctx, float      num);
    MuDoubleValue   (*handle_from_double )(MuCtx *ctx, double     num);
    MuUPtrValue     (*handle_from_ptr    )(MuCtx *ctx, MuID mu_type, MuCPtr ptr);
    MuUFPValue      (*handle_from_fp     )(MuCtx *ctx, MuID mu_type, MuCFP fp);
Kunshan Wang's avatar
Kunshan Wang committed
335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361

    // Convert from Mu values to C values
    int8_t      (*handle_to_sint8 )(MuCtx *ctx, MuIntValue    opnd);
    uint8_t     (*handle_to_uint8 )(MuCtx *ctx, MuIntValue    opnd);
    int16_t     (*handle_to_sint16)(MuCtx *ctx, MuIntValue    opnd);
    uint16_t    (*handle_to_uint16)(MuCtx *ctx, MuIntValue    opnd);
    int32_t     (*handle_to_sint32)(MuCtx *ctx, MuIntValue    opnd);
    uint32_t    (*handle_to_uint32)(MuCtx *ctx, MuIntValue    opnd);
    int64_t     (*handle_to_sint64)(MuCtx *ctx, MuIntValue    opnd);
    uint64_t    (*handle_to_uint64)(MuCtx *ctx, MuIntValue    opnd);
    float       (*handle_to_float )(MuCtx *ctx, MuFloatValue  opnd);
    double      (*handle_to_double)(MuCtx *ctx, MuDoubleValue opnd);
    MuCPtr      (*handle_to_ptr   )(MuCtx *ctx, MuUPtrValue   opnd);
    MuCFP       (*handle_to_fp    )(MuCtx *ctx, MuUFPValue    opnd);

    // Make MuValue instances from Mu global SSA variables
    MuValue         (*handle_from_const )(MuCtx *ctx, MuID id);
    MuIRefValue     (*handle_from_global)(MuCtx *ctx, MuID id);
    MuFuncRefValue  (*handle_from_func  )(MuCtx *ctx, MuID id);
    MuValue         (*handle_from_expose)(MuCtx *ctx, MuID id);

    // Delete the value held by the MuCtx, making it unusable, but freeing up
    // the resource.
    void        (*delete_value)(MuCtx *ctx, MuValue opnd);

    // Compare reference or general reference types.
    // EQ. Available for ref, iref, funcref, threadref and stackref.
362
    MuBool      (*ref_eq )(MuCtx *ctx, MuGenRefValue lhs, MuGenRefValue rhs);
Kunshan Wang's avatar
Kunshan Wang committed
363
    // ULT. Available for iref only.
364
    MuBool      (*ref_ult)(MuCtx *ctx, MuIRefValue lhs, MuIRefValue rhs);
Kunshan Wang's avatar
Kunshan Wang committed
365 366

    // Manipulate Mu values of the struct<...> type
Kunshan Wang's avatar
Kunshan Wang committed
367 368
    MuValue         (*extract_value)(MuCtx *ctx, MuStructValue str, int index);
    MuStructValue   (*insert_value )(MuCtx *ctx, MuStructValue str, int index, MuValue newval);
Kunshan Wang's avatar
Kunshan Wang committed
369 370 371

    // Manipulate Mu values of the array or vector type
    // str can be MuArrayValue or MuVectorValue
372 373
    MuValue     (*extract_element)(MuCtx *ctx, MuSeqValue str, MuIntValue index);
    MuSeqValue  (*insert_element )(MuCtx *ctx, MuSeqValue str, MuIntValue index, MuValue newval);
Kunshan Wang's avatar
Kunshan Wang committed
374 375 376 377 378 379

    // Heap allocation
    MuRefValue  (*new_fixed )(MuCtx *ctx, MuID mu_type);
    MuRefValue  (*new_hybrid)(MuCtx *ctx, MuID mu_type, MuIntValue length);

    // Change the T or sig in ref<T>, iref<T> or func<sig>
380
    MuGenRefValue   (*refcast)(MuCtx *ctx, MuGenRefValue opnd, MuID new_type);
Kunshan Wang's avatar
Kunshan Wang committed
381 382 383 384 385 386 387 388 389 390 391 392

    // Memory addressing
    MuIRefValue     (*get_iref           )(MuCtx *ctx, MuRefValue opnd);
    MuIRefValue     (*get_field_iref     )(MuCtx *ctx, MuIRefValue opnd, int field);
    MuIRefValue     (*get_elem_iref      )(MuCtx *ctx, MuIRefValue opnd, MuIntValue index);
    MuIRefValue     (*shift_iref         )(MuCtx *ctx, MuIRefValue opnd, MuIntValue offset);
    MuIRefValue     (*get_var_part_iref  )(MuCtx *ctx, MuIRefValue opnd);

    // Memory accessing
    MuValue     (*load     )(MuCtx *ctx, MuMemOrd ord, MuIRefValue loc);
    void        (*store    )(MuCtx *ctx, MuMemOrd ord, MuIRefValue loc, MuValue newval);
    MuValue     (*cmpxchg  )(MuCtx *ctx, MuMemOrd ord_succ, MuMemOrd ord_fail,
393 394
                        MuBool weak, MuIRefValue loc, MuValue expected, MuValue desired,
                        MuBool *is_succ); /// MUAPIPARSER is_succ:out
Kunshan Wang's avatar
Kunshan Wang committed
395
    MuValue     (*atomicrmw)(MuCtx *ctx, MuMemOrd ord, MuAtomicRMWOptr op,
Kunshan Wang's avatar
Kunshan Wang committed
396 397 398 399 400
                        MuIRefValue loc, MuValue opnd);
    void        (*fence    )(MuCtx *ctx, MuMemOrd ord);

    // Thread and stack creation and stack destruction
    MuStackRefValue     (*new_stack )(MuCtx *ctx, MuFuncRefValue func);
Kunshan Wang's avatar
Kunshan Wang committed
401 402
    MuThreadRefValue    (*new_thread_nor)(MuCtx *ctx, MuStackRefValue stack,
                            MuRefValue threadlocal,
Kunshan Wang's avatar
Kunshan Wang committed
403
                            MuValue *vals, MuArraySize nvals); /// MUAPIPARSER threadlocal:optional;vals:array:nvals
Kunshan Wang's avatar
Kunshan Wang committed
404
    MuThreadRefValue    (*new_thread_exc)(MuCtx *ctx, MuStackRefValue stack,
Kunshan Wang's avatar
Kunshan Wang committed
405
                            MuRefValue threadlocal,
406
                            MuRefValue exc); /// MUAPIPARSER threadlocal:optional
Kunshan Wang's avatar
Kunshan Wang committed
407 408
    void                (*kill_stack)(MuCtx *ctx, MuStackRefValue stack);

Kunshan Wang's avatar
Kunshan Wang committed
409 410 411 412 413
    // Thread-local object reference
    void        (*set_threadlocal)(MuCtx *ctx, MuThreadRefValue thread,
                    MuRefValue threadlocal);
    MuRefValue  (*get_threadlocal)(MuCtx *ctx, MuThreadRefValue thread);

Kunshan Wang's avatar
Kunshan Wang committed
414 415 416 417 418 419 420 421 422 423
    // Frame cursor operations
    MuFCRefValue    (*new_cursor  )(MuCtx *ctx, MuStackRefValue stack);
    void            (*next_frame  )(MuCtx *ctx, MuFCRefValue cursor);
    MuFCRefValue    (*copy_cursor )(MuCtx *ctx, MuFCRefValue cursor);
    void            (*close_cursor)(MuCtx *ctx, MuFCRefValue cursor);

    // Stack introspection
    MuID        (*cur_func       )(MuCtx *ctx, MuFCRefValue cursor);
    MuID        (*cur_func_ver   )(MuCtx *ctx, MuFCRefValue cursor);
    MuID        (*cur_inst       )(MuCtx *ctx, MuFCRefValue cursor);
Kunshan Wang's avatar
Kunshan Wang committed
424
    void        (*dump_keepalives)(MuCtx *ctx, MuFCRefValue cursor, MuValue *results); /// MUAPIPARSER results:out
Kunshan Wang's avatar
Kunshan Wang committed
425 426 427 428 429 430
    
    // On-stack replacement
    void        (*pop_frames_to)(MuCtx *ctx, MuFCRefValue cursor);
    void        (*push_frame   )(MuCtx *ctx, MuStackRefValue stack, MuFuncRefValue func);

    // 64-bit tagged reference operations
431 432 433
    MuBool          (*tr64_is_fp   )(MuCtx *ctx, MuTagRef64Value value);
    MuBool          (*tr64_is_int  )(MuCtx *ctx, MuTagRef64Value value);
    MuBool          (*tr64_is_ref  )(MuCtx *ctx, MuTagRef64Value value);
Kunshan Wang's avatar
Kunshan Wang committed
434 435 436 437 438 439 440 441 442
    MuDoubleValue   (*tr64_to_fp   )(MuCtx *ctx, MuTagRef64Value value);
    MuIntValue      (*tr64_to_int  )(MuCtx *ctx, MuTagRef64Value value);
    MuRefValue      (*tr64_to_ref  )(MuCtx *ctx, MuTagRef64Value value);
    MuIntValue      (*tr64_to_tag  )(MuCtx *ctx, MuTagRef64Value value);
    MuTagRef64Value (*tr64_from_fp )(MuCtx *ctx, MuDoubleValue value);
    MuTagRef64Value (*tr64_from_int)(MuCtx *ctx, MuIntValue value);
    MuTagRef64Value (*tr64_from_ref)(MuCtx *ctx, MuRefValue ref, MuIntValue tag);

    // Watchpoint operations
Kunshan Wang's avatar
Kunshan Wang committed
443 444
    void        (*enable_watchpoint )(MuCtx *ctx, MuWPID wpid);
    void        (*disable_watchpoint)(MuCtx *ctx, MuWPID wpid);
Kunshan Wang's avatar
Kunshan Wang committed
445 446 447 448 449 450 451 452

    // Mu memory pinning, usually object pinning
    MuUPtrValue (*pin  )(MuCtx *ctx, MuValue loc);      // loc is either MuRefValue or MuIRefValue
    void        (*unpin)(MuCtx *ctx, MuValue loc);      // loc is either MuRefValue or MuIRefValue

    // Expose Mu functions as native callable things, usually function pointers
    MuValue     (*expose  )(MuCtx *ctx, MuFuncRefValue func, MuCallConv call_conv, MuIntValue cookie);
    void        (*unexpose)(MuCtx *ctx, MuCallConv call_conv, MuValue value);
Kunshan Wang's avatar
Kunshan Wang committed
453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469

    /// IR Builder API from here on.

    // Create bundle
    MuBundleNode    (*new_bundle)(MuCtx *ctx);

    // Load a bundle built from an IR Builder into the micro VM
    void        (*load_bundle_from_node )(MuCtx *ctx, MuBundleNode b);
    // Call this function before the node is loaded to release all of its resources.
    void        (*abort_bundle_node     )(MuCtx *ctx, MuBundleNode b);

    // Get a MuChildNode that refers to an existing node that has the "id".
    // The returned handle is only usable within the bundle "b".
    // Can only get top-level definitions.
    MuChildNode (*get_node  )(MuCtx *ctx, MuBundleNode b, MuID id);

    // Get the ID of the IR node "node".
Kunshan Wang's avatar
Kunshan Wang committed
470
    MuID        (*get_id    )(MuCtx *ctx, MuBundleNode b, MuChildNode node);
Kunshan Wang's avatar
Kunshan Wang committed
471 472

    // Set the name of the IR node. MuName is '\0' terminated char*.
Kunshan Wang's avatar
Kunshan Wang committed
473
    void        (*set_name  )(MuCtx *ctx, MuBundleNode b, MuChildNode node, MuName name);
Kunshan Wang's avatar
Kunshan Wang committed
474 475 476 477 478 479 480 481 482 483 484 485

    /// Create top-level definitions. When created, they are added to the bundle "b".
    
    // Create types
    MuTypeNode  (*new_type_int      )(MuCtx *ctx, MuBundleNode b, int len);
    MuTypeNode  (*new_type_float    )(MuCtx *ctx, MuBundleNode b);
    MuTypeNode  (*new_type_double   )(MuCtx *ctx, MuBundleNode b);
    MuTypeNode  (*new_type_uptr     )(MuCtx *ctx, MuBundleNode b);
    void        (*set_type_uptr     )(MuCtx *ctx, MuTypeNode uptr, MuTypeNode ty);
    MuTypeNode  (*new_type_ufuncptr )(MuCtx *ctx, MuBundleNode b);
    void        (*set_type_ufuncptr )(MuCtx *ctx, MuTypeNode ufuncptr, MuFuncSigNode sig);

486
    MuTypeNode  (*new_type_struct   )(MuCtx *ctx, MuBundleNode b, MuTypeNode *fieldtys, MuArraySize nfieldtys);
Kunshan Wang's avatar
Kunshan Wang committed
487
                /// MUAPIPARSER fieldtys:array:nfieldtys
488
    MuTypeNode  (*new_type_hybrid   )(MuCtx *ctx, MuBundleNode b, MuTypeNode *fixedtys, MuArraySize nfixedtys, MuTypeNode varty);
Kunshan Wang's avatar
Kunshan Wang committed
489
                /// MUAPIPARSER fixedtys:array:nfixedtys
Kunshan Wang's avatar
Kunshan Wang committed
490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509
    MuTypeNode  (*new_type_array    )(MuCtx *ctx, MuBundleNode b, MuTypeNode elemty, uint64_t len);
    MuTypeNode  (*new_type_vector   )(MuCtx *ctx, MuBundleNode b, MuTypeNode elemty, uint64_t len);
    MuTypeNode  (*new_type_void     )(MuCtx *ctx, MuBundleNode b);

    MuTypeNode  (*new_type_ref      )(MuCtx *ctx, MuBundleNode b);
    void        (*set_type_ref      )(MuCtx *ctx, MuTypeNode ref, MuTypeNode ty);
    MuTypeNode  (*new_type_iref     )(MuCtx *ctx, MuBundleNode b);
    void        (*set_type_iref     )(MuCtx *ctx, MuTypeNode iref, MuTypeNode ty);
    MuTypeNode  (*new_type_weakref  )(MuCtx *ctx, MuBundleNode b);
    void        (*set_type_weakref  )(MuCtx *ctx, MuTypeNode weakref, MuTypeNode ty);
    MuTypeNode  (*new_type_funcref  )(MuCtx *ctx, MuBundleNode b);
    void        (*set_type_funcref  )(MuCtx *ctx, MuTypeNode funcref, MuFuncSigNode sig);
    MuTypeNode  (*new_type_tagref64 )(MuCtx *ctx, MuBundleNode b);

    MuTypeNode  (*new_type_threadref     )(MuCtx *ctx, MuBundleNode b);
    MuTypeNode  (*new_type_stackref      )(MuCtx *ctx, MuBundleNode b);
    MuTypeNode  (*new_type_framecursorref)(MuCtx *ctx, MuBundleNode b);
    MuTypeNode  (*new_type_irnoderef     )(MuCtx *ctx, MuBundleNode b);

    // Create function signatures
510
    MuFuncSigNode   (*new_funcsig   )(MuCtx *ctx, MuBundleNode b, MuTypeNode *paramtys, MuArraySize nparamtys, MuTypeNode *rettys, MuArraySize nrettys);
Kunshan Wang's avatar
Kunshan Wang committed
511
                    /// MUAPIPARSER paramtys:array:nparamtys;rettys:array:nrettys
Kunshan Wang's avatar
Kunshan Wang committed
512 513

    // Create constants
514
    // new_const_int works for int<n> with n <= 64, uptr and ufuncptr.
Kunshan Wang's avatar
Kunshan Wang committed
515 516
    MuConstNode (*new_const_int     )(MuCtx *ctx, MuBundleNode b, MuTypeNode ty, uint64_t value);
    // new_const_int_ex works for int<n> with n > 64. The number is segmented into 64-bit words, lower word first.
517
    MuConstNode (*new_const_int_ex  )(MuCtx *ctx, MuBundleNode b, MuTypeNode ty, uint64_t *values, MuArraySize nvalues); /// MUAPIPARSER values:array:nvalues
Kunshan Wang's avatar
Kunshan Wang committed
518 519 520 521 522
    // TODO: There is only one 'float' type and one 'double' type. Theoretically the 'ty' param is unnecessary
    // It is just added to mirror the text form. Eliminate them when we are ready to change the text form.
    MuConstNode (*new_const_float   )(MuCtx *ctx, MuBundleNode b, MuTypeNode ty, float value);
    MuConstNode (*new_const_double  )(MuCtx *ctx, MuBundleNode b, MuTypeNode ty, double value);
    // new_const_null works for all general reference types, but not uptr or ufuncptr.
Kunshan Wang's avatar
Kunshan Wang committed
523
    MuConstNode (*new_const_null    )(MuCtx *ctx, MuBundleNode b, MuTypeNode ty);
524 525
    // new_const_seq works for structs, arrays and vectors. Constants are non-recursive, so there is no set_const_seq.
    MuConstNode (*new_const_seq     )(MuCtx *ctx, MuBundleNode b, MuTypeNode ty, MuConstNode *elems, MuArraySize nelems); /// MUAPIPARSER elems:array:nelems
Kunshan Wang's avatar
Kunshan Wang committed
526 527 528 529 530 531 532 533 534
    
    // Create global cell
    MuGlobalNode (*new_global_cell  )(MuCtx *ctx, MuBundleNode b, MuTypeNode ty);

    // Create function
    MuFuncNode  (*new_func          )(MuCtx *ctx, MuBundleNode b, MuFuncSigNode sig);

    // Create function version
    // In order to declare and define a new function, the client must create
535
    // both a function node and a function version node.
Kunshan Wang's avatar
Kunshan Wang committed
536 537 538 539 540 541 542
    MuFuncVerNode   (*new_func_ver  )(MuCtx *ctx, MuBundleNode b, MuFuncNode func);

    // Create exposed function
    MuExpFuncNode   (*new_exp_func  )(MuCtx *ctx, MuBundleNode b, MuFuncNode func, MuCallConv callconv, MuConstNode cookie);

    /// Create CFG
    
543
    // Create basic block and add it to function version "fv".
Kunshan Wang's avatar
Kunshan Wang committed
544 545 546 547 548 549 550 551 552 553 554
    MuBBNode        (*new_bb        )(MuCtx *ctx, MuFuncVerNode fv);

    // Basic block parameters and instruction results are appended to the basic
    // block or instruction.

    // Create a normal parameter node and add it to the basic block "bb".
    MuNorParamNode  (*new_nor_param )(MuCtx *ctx, MuBBNode bb, MuTypeNode ty);

    // Create an exception parameter node and add it to the basic block "bb".
    MuExcParamNode  (*new_exc_param )(MuCtx *ctx, MuBBNode bb);

555
    // Create an instruction result. It becomes the next result of "inst".
Kunshan Wang's avatar
Kunshan Wang committed
556 557 558 559
    MuInstResNode   (*new_inst_res  )(MuCtx *ctx, MuInstNode inst);

    /// Create common clauses for instructions.

560 561
    // Create a destination clause and add it to instruction "inst".
    void    (*add_dest      )(MuCtx *ctx, MuInstNode inst, MuDestKind kind, MuBBNode dest, MuVarNode *vars, MuArraySize nvars); /// MUAPIPARSER vars:array:nvars
Kunshan Wang's avatar
Kunshan Wang committed
562

563 564
    // Create a destination clause and add it to instruction "inst".
    void    (*add_keepalives)(MuCtx *ctx, MuInstNode inst, MuLocalVarNode *vars, MuArraySize nvars); /// MUAPIPARSER vars:array:nvars
Kunshan Wang's avatar
Kunshan Wang committed
565 566 567 568 569 570 571 572 573 574
    
    /// Create instructions. Instructions are appended to the basic block "bb".

    MuInstNode  (*new_binop         )(MuCtx *ctx, MuBBNode bb, MuBinOptr  optr,    MuTypeNode ty,      MuVarNode  opnd1, MuVarNode opnd2);
    MuInstNode  (*new_cmp           )(MuCtx *ctx, MuBBNode bb, MuCmpOptr  optr,    MuTypeNode ty,      MuVarNode  opnd1, MuVarNode opnd2);
    MuInstNode  (*new_conv          )(MuCtx *ctx, MuBBNode bb, MuConvOptr optr,    MuTypeNode from_ty, MuTypeNode to_ty, MuVarNode opnd);
    MuInstNode  (*new_select        )(MuCtx *ctx, MuBBNode bb, MuTypeNode cond_ty, MuTypeNode opnd_ty, MuVarNode  cond,  MuVarNode if_true, MuVarNode if_false);

    MuInstNode  (*new_branch        )(MuCtx *ctx, MuBBNode bb);
    MuInstNode  (*new_branch2       )(MuCtx *ctx, MuBBNode bb, MuVarNode cond);
Kunshan Wang's avatar
Kunshan Wang committed
575
    MuInstNode  (*new_switch        )(MuCtx *ctx, MuBBNode bb, MuTypeNode opnd_ty, MuVarNode opnd);
576
    void        (*add_switch_dest   )(MuCtx *ctx, MuInstNode sw, MuConstNode key, MuBBNode dest, MuVarNode *vars, MuArraySize nvars); /// MUAPIPARSER vars:array:nvars
Kunshan Wang's avatar
Kunshan Wang committed
577

578 579 580
    MuInstNode  (*new_call          )(MuCtx *ctx, MuBBNode bb, MuFuncSigNode sig, MuVarNode callee, MuVarNode *args, MuArraySize nargs); /// MUAPIPARSER args:array:nargs
    MuInstNode  (*new_tailcall      )(MuCtx *ctx, MuBBNode bb, MuFuncSigNode sig, MuVarNode callee, MuVarNode *args, MuArraySize nargs); /// MUAPIPARSER args:array:nargs
    MuInstNode  (*new_ret           )(MuCtx *ctx, MuBBNode bb, MuVarNode *rvs, MuArraySize nrvs); /// MUAPIPARSER rvs:array:nrvs
Kunshan Wang's avatar
Kunshan Wang committed
581 582 583 584 585 586 587 588 589 590 591 592 593 594
    MuInstNode  (*new_throw         )(MuCtx *ctx, MuBBNode bb, MuVarNode exc);

    MuInstNode  (*new_extractvalue  )(MuCtx *ctx, MuBBNode bb, MuTypeNode strty, int index,         MuVarNode opnd);
    MuInstNode  (*new_insertvalue   )(MuCtx *ctx, MuBBNode bb, MuTypeNode strty, int index,         MuVarNode opnd, MuVarNode newval);
    MuInstNode  (*new_extractelement)(MuCtx *ctx, MuBBNode bb, MuTypeNode seqty, MuTypeNode indty,  MuVarNode opnd, MuVarNode index);
    MuInstNode  (*new_insertelement )(MuCtx *ctx, MuBBNode bb, MuTypeNode seqty, MuTypeNode indty,  MuVarNode opnd, MuVarNode index, MuVarNode newval);
    MuInstNode  (*new_shufflevector )(MuCtx *ctx, MuBBNode bb, MuTypeNode vecty, MuTypeNode maskty, MuVarNode vec1, MuVarNode vec2,  MuVarNode mask);

    MuInstNode  (*new_new           )(MuCtx *ctx, MuBBNode bb, MuTypeNode allocty);
    MuInstNode  (*new_newhybrid     )(MuCtx *ctx, MuBBNode bb, MuTypeNode allocty, MuTypeNode lenty, MuVarNode length);
    MuInstNode  (*new_alloca        )(MuCtx *ctx, MuBBNode bb, MuTypeNode allocty);
    MuInstNode  (*new_allocahybrid  )(MuCtx *ctx, MuBBNode bb, MuTypeNode allocty, MuTypeNode lenty, MuVarNode length);

    MuInstNode  (*new_getiref       )(MuCtx *ctx, MuBBNode bb, MuTypeNode refty, MuVarNode opnd);
595 596 597 598 599 600 601 602 603
    MuInstNode  (*new_getfieldiref  )(MuCtx *ctx, MuBBNode bb, MuBool is_ptr, MuTypeNode refty, int index, MuVarNode opnd);
    MuInstNode  (*new_getelemiref   )(MuCtx *ctx, MuBBNode bb, MuBool is_ptr, MuTypeNode refty, MuTypeNode indty, MuVarNode opnd, MuVarNode index);
    MuInstNode  (*new_shiftiref     )(MuCtx *ctx, MuBBNode bb, MuBool is_ptr, MuTypeNode refty, MuTypeNode offty, MuVarNode opnd, MuVarNode offset);
    MuInstNode  (*new_getvarpartiref)(MuCtx *ctx, MuBBNode bb, MuBool is_ptr, MuTypeNode refty, MuVarNode opnd);

    MuInstNode  (*new_load          )(MuCtx *ctx, MuBBNode bb, MuBool is_ptr, MuMemOrd ord, MuTypeNode refty,   MuVarNode loc);
    MuInstNode  (*new_store         )(MuCtx *ctx, MuBBNode bb, MuBool is_ptr, MuMemOrd ord, MuTypeNode refty,   MuVarNode loc,     MuVarNode newval);
    MuInstNode  (*new_cmpxchg       )(MuCtx *ctx, MuBBNode bb, MuBool is_ptr, MuBool is_weak,  MuMemOrd ord_succ,  MuMemOrd ord_fail, MuTypeNode refty, MuVarNode loc, MuVarNode expected, MuVarNode desired);
    MuInstNode  (*new_atomicrmw     )(MuCtx *ctx, MuBBNode bb, MuBool is_ptr, MuMemOrd ord, MuAtomicRMWOptr optr, MuTypeNode refTy,  MuVarNode loc,    MuVarNode opnd);
Kunshan Wang's avatar
Kunshan Wang committed
604 605
    MuInstNode  (*new_fence         )(MuCtx *ctx, MuBBNode bb, MuMemOrd ord);
    
606 607
    MuInstNode  (*new_trap          )(MuCtx *ctx, MuBBNode bb, MuTypeNode *rettys, MuArraySize nrettys); /// MUAPIPARSER rettys:array:nrettys
    MuInstNode  (*new_watchpoint    )(MuCtx *ctx, MuBBNode bb, MuWPID wpid, MuTypeNode *rettys, MuArraySize nrettys); /// MUAPIPARSER rettys:array:nrettys
Kunshan Wang's avatar
Kunshan Wang committed
608 609
    MuInstNode  (*new_wpbranch      )(MuCtx *ctx, MuBBNode bb, MuWPID wpid);

610
    MuInstNode  (*new_ccall         )(MuCtx *ctx, MuBBNode bb, MuCallConv callconv, MuTypeNode callee_ty, MuFuncSigNode sig, MuVarNode callee, MuVarNode *args, MuArraySize nargs); /// MUAPIPARSER args:array:nargs
Kunshan Wang's avatar
Kunshan Wang committed
611 612

    MuInstNode  (*new_newthread     )(MuCtx *ctx, MuBBNode bb, MuVarNode stack, MuVarNode threadlocal);
613
    MuInstNode  (*new_swapstack_ret )(MuCtx *ctx, MuBBNode bb, MuVarNode swappee, MuTypeNode *ret_tys, MuArraySize nret_tys); /// MUAPIPARSER ret_tys:array:nret_tys
Kunshan Wang's avatar
Kunshan Wang committed
614 615
    MuInstNode  (*new_swapstack_kill)(MuCtx *ctx, MuBBNode bb, MuVarNode swappee);

616
    void        (*set_newstack_pass_values)(MuCtx *ctx, MuInstNode inst, MuTypeNode *tys, MuVarNode *vars, MuArraySize nvars); /// MUAPIPARSER tys:array:nvars;vars:array:nvars
Kunshan Wang's avatar
Kunshan Wang committed
617 618 619
    void        (*set_newstack_throw_exc  )(MuCtx *ctx, MuInstNode inst, MuVarNode exc);

    MuInstNode  (*new_comminst      )(MuCtx *ctx, MuBBNode bb, MuCommInst opcode,
620 621 622 623
                                        MuFlag        *flags, MuArraySize nflags,
                                        MuTypeNode    *tys,   MuArraySize ntys,
                                        MuFuncSigNode *sigs,  MuArraySize nsigs,
                                        MuVarNode     *args,  MuArraySize nargs);
Kunshan Wang's avatar
Kunshan Wang committed
624
                 /// MUAPIPARSER flags:array:nflags;tys:array:ntys;sigs:array:nsigs;args:array:nargs
Kunshan Wang's avatar
Kunshan Wang committed
625 626
};

Kunshan Wang's avatar
Kunshan Wang committed
627
// Common instruction opcodes
Kunshan Wang's avatar
Kunshan Wang committed
628
/// SCRIPT: GENERATED COMMINSTS BEGIN
Kunshan Wang's avatar
Kunshan Wang committed
629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760
#define MU_CI_UVM_NEW_STACK                          ((MuCommInst)0x201) /// MUAPIPARSER muname:@uvm.new_stack
#define MU_CI_UVM_KILL_STACK                         ((MuCommInst)0x202) /// MUAPIPARSER muname:@uvm.kill_stack
#define MU_CI_UVM_THREAD_EXIT                        ((MuCommInst)0x203) /// MUAPIPARSER muname:@uvm.thread_exit
#define MU_CI_UVM_CURRENT_STACK                      ((MuCommInst)0x204) /// MUAPIPARSER muname:@uvm.current_stack
#define MU_CI_UVM_SET_THREADLOCAL                    ((MuCommInst)0x205) /// MUAPIPARSER muname:@uvm.set_threadlocal
#define MU_CI_UVM_GET_THREADLOCAL                    ((MuCommInst)0x206) /// MUAPIPARSER muname:@uvm.get_threadlocal
#define MU_CI_UVM_TR64_IS_FP                         ((MuCommInst)0x211) /// MUAPIPARSER muname:@uvm.tr64.is_fp
#define MU_CI_UVM_TR64_IS_INT                        ((MuCommInst)0x212) /// MUAPIPARSER muname:@uvm.tr64.is_int
#define MU_CI_UVM_TR64_IS_REF                        ((MuCommInst)0x213) /// MUAPIPARSER muname:@uvm.tr64.is_ref
#define MU_CI_UVM_TR64_FROM_FP                       ((MuCommInst)0x214) /// MUAPIPARSER muname:@uvm.tr64.from_fp
#define MU_CI_UVM_TR64_FROM_INT                      ((MuCommInst)0x215) /// MUAPIPARSER muname:@uvm.tr64.from_int
#define MU_CI_UVM_TR64_FROM_REF                      ((MuCommInst)0x216) /// MUAPIPARSER muname:@uvm.tr64.from_ref
#define MU_CI_UVM_TR64_TO_FP                         ((MuCommInst)0x217) /// MUAPIPARSER muname:@uvm.tr64.to_fp
#define MU_CI_UVM_TR64_TO_INT                        ((MuCommInst)0x218) /// MUAPIPARSER muname:@uvm.tr64.to_int
#define MU_CI_UVM_TR64_TO_REF                        ((MuCommInst)0x219) /// MUAPIPARSER muname:@uvm.tr64.to_ref
#define MU_CI_UVM_TR64_TO_TAG                        ((MuCommInst)0x21a) /// MUAPIPARSER muname:@uvm.tr64.to_tag
#define MU_CI_UVM_FUTEX_WAIT                         ((MuCommInst)0x220) /// MUAPIPARSER muname:@uvm.futex.wait
#define MU_CI_UVM_FUTEX_WAIT_TIMEOUT                 ((MuCommInst)0x221) /// MUAPIPARSER muname:@uvm.futex.wait_timeout
#define MU_CI_UVM_FUTEX_WAKE                         ((MuCommInst)0x222) /// MUAPIPARSER muname:@uvm.futex.wake
#define MU_CI_UVM_FUTEX_CMP_REQUEUE                  ((MuCommInst)0x223) /// MUAPIPARSER muname:@uvm.futex.cmp_requeue
#define MU_CI_UVM_KILL_DEPENDENCY                    ((MuCommInst)0x230) /// MUAPIPARSER muname:@uvm.kill_dependency
#define MU_CI_UVM_NATIVE_PIN                         ((MuCommInst)0x240) /// MUAPIPARSER muname:@uvm.native.pin
#define MU_CI_UVM_NATIVE_UNPIN                       ((MuCommInst)0x241) /// MUAPIPARSER muname:@uvm.native.unpin
#define MU_CI_UVM_NATIVE_EXPOSE                      ((MuCommInst)0x242) /// MUAPIPARSER muname:@uvm.native.expose
#define MU_CI_UVM_NATIVE_UNEXPOSE                    ((MuCommInst)0x243) /// MUAPIPARSER muname:@uvm.native.unexpose
#define MU_CI_UVM_NATIVE_GET_COOKIE                  ((MuCommInst)0x244) /// MUAPIPARSER muname:@uvm.native.get_cookie
#define MU_CI_UVM_META_ID_OF                         ((MuCommInst)0x250) /// MUAPIPARSER muname:@uvm.meta.id_of
#define MU_CI_UVM_META_NAME_OF                       ((MuCommInst)0x251) /// MUAPIPARSER muname:@uvm.meta.name_of
#define MU_CI_UVM_META_LOAD_BUNDLE                   ((MuCommInst)0x252) /// MUAPIPARSER muname:@uvm.meta.load_bundle
#define MU_CI_UVM_META_LOAD_HAIL                     ((MuCommInst)0x253) /// MUAPIPARSER muname:@uvm.meta.load_hail
#define MU_CI_UVM_META_NEW_CURSOR                    ((MuCommInst)0x254) /// MUAPIPARSER muname:@uvm.meta.new_cursor
#define MU_CI_UVM_META_NEXT_FRAME                    ((MuCommInst)0x255) /// MUAPIPARSER muname:@uvm.meta.next_frame
#define MU_CI_UVM_META_COPY_CURSOR                   ((MuCommInst)0x256) /// MUAPIPARSER muname:@uvm.meta.copy_cursor
#define MU_CI_UVM_META_CLOSE_CURSOR                  ((MuCommInst)0x257) /// MUAPIPARSER muname:@uvm.meta.close_cursor
#define MU_CI_UVM_META_CUR_FUNC                      ((MuCommInst)0x258) /// MUAPIPARSER muname:@uvm.meta.cur_func
#define MU_CI_UVM_META_CUR_FUNC_VER                  ((MuCommInst)0x259) /// MUAPIPARSER muname:@uvm.meta.cur_func_Ver
#define MU_CI_UVM_META_CUR_INST                      ((MuCommInst)0x25a) /// MUAPIPARSER muname:@uvm.meta.cur_inst
#define MU_CI_UVM_META_DUMP_KEEPALIVES               ((MuCommInst)0x25b) /// MUAPIPARSER muname:@uvm.meta.dump_keepalives
#define MU_CI_UVM_META_POP_FRAMES_TO                 ((MuCommInst)0x25c) /// MUAPIPARSER muname:@uvm.meta.pop_frames_to
#define MU_CI_UVM_META_PUSH_FRAME                    ((MuCommInst)0x25d) /// MUAPIPARSER muname:@uvm.meta.push_frame
#define MU_CI_UVM_META_ENABLE_WATCHPOINT             ((MuCommInst)0x25e) /// MUAPIPARSER muname:@uvm.meta.enable_watchpoint
#define MU_CI_UVM_META_DISABLE_WATCHPOINT            ((MuCommInst)0x25f) /// MUAPIPARSER muname:@uvm.meta.disable_watchpoint
#define MU_CI_UVM_META_SET_TRAP_HANDLER              ((MuCommInst)0x260) /// MUAPIPARSER muname:@uvm.meta.set_trap_handler
#define MU_CI_UVM_IRBUILDER_NEW_BUNDLE               ((MuCommInst)0x300) /// MUAPIPARSER muname:@uvm.irbuilder.new_bundle
#define MU_CI_UVM_IRBUILDER_LOAD_BUNDLE_FROM_NODE    ((MuCommInst)0x301) /// MUAPIPARSER muname:@uvm.irbuilder.load_bundle_from_node
#define MU_CI_UVM_IRBUILDER_ABORT_BUNDLE_NODE        ((MuCommInst)0x302) /// MUAPIPARSER muname:@uvm.irbuilder.abort_bundle_node
#define MU_CI_UVM_IRBUILDER_GET_NODE                 ((MuCommInst)0x303) /// MUAPIPARSER muname:@uvm.irbuilder.get_node
#define MU_CI_UVM_IRBUILDER_GET_ID                   ((MuCommInst)0x304) /// MUAPIPARSER muname:@uvm.irbuilder.get_id
#define MU_CI_UVM_IRBUILDER_SET_NAME                 ((MuCommInst)0x305) /// MUAPIPARSER muname:@uvm.irbuilder.set_name
#define MU_CI_UVM_IRBUILDER_NEW_TYPE_INT             ((MuCommInst)0x306) /// MUAPIPARSER muname:@uvm.irbuilder.new_type_int
#define MU_CI_UVM_IRBUILDER_NEW_TYPE_FLOAT           ((MuCommInst)0x307) /// MUAPIPARSER muname:@uvm.irbuilder.new_type_float
#define MU_CI_UVM_IRBUILDER_NEW_TYPE_DOUBLE          ((MuCommInst)0x308) /// MUAPIPARSER muname:@uvm.irbuilder.new_type_double
#define MU_CI_UVM_IRBUILDER_NEW_TYPE_UPTR            ((MuCommInst)0x309) /// MUAPIPARSER muname:@uvm.irbuilder.new_type_uptr
#define MU_CI_UVM_IRBUILDER_SET_TYPE_UPTR            ((MuCommInst)0x30a) /// MUAPIPARSER muname:@uvm.irbuilder.set_type_uptr
#define MU_CI_UVM_IRBUILDER_NEW_TYPE_UFUNCPTR        ((MuCommInst)0x30b) /// MUAPIPARSER muname:@uvm.irbuilder.new_type_ufuncptr
#define MU_CI_UVM_IRBUILDER_SET_TYPE_UFUNCPTR        ((MuCommInst)0x30c) /// MUAPIPARSER muname:@uvm.irbuilder.set_type_ufuncptr
#define MU_CI_UVM_IRBUILDER_NEW_TYPE_STRUCT          ((MuCommInst)0x30d) /// MUAPIPARSER muname:@uvm.irbuilder.new_type_struct
#define MU_CI_UVM_IRBUILDER_NEW_TYPE_HYBRID          ((MuCommInst)0x30e) /// MUAPIPARSER muname:@uvm.irbuilder.new_type_hybrid
#define MU_CI_UVM_IRBUILDER_NEW_TYPE_ARRAY           ((MuCommInst)0x30f) /// MUAPIPARSER muname:@uvm.irbuilder.new_type_array
#define MU_CI_UVM_IRBUILDER_NEW_TYPE_VECTOR          ((MuCommInst)0x310) /// MUAPIPARSER muname:@uvm.irbuilder.new_type_vector
#define MU_CI_UVM_IRBUILDER_NEW_TYPE_VOID            ((MuCommInst)0x311) /// MUAPIPARSER muname:@uvm.irbuilder.new_type_void
#define MU_CI_UVM_IRBUILDER_NEW_TYPE_REF             ((MuCommInst)0x312) /// MUAPIPARSER muname:@uvm.irbuilder.new_type_ref
#define MU_CI_UVM_IRBUILDER_SET_TYPE_REF             ((MuCommInst)0x313) /// MUAPIPARSER muname:@uvm.irbuilder.set_type_ref
#define MU_CI_UVM_IRBUILDER_NEW_TYPE_IREF            ((MuCommInst)0x314) /// MUAPIPARSER muname:@uvm.irbuilder.new_type_iref
#define MU_CI_UVM_IRBUILDER_SET_TYPE_IREF            ((MuCommInst)0x315) /// MUAPIPARSER muname:@uvm.irbuilder.set_type_iref
#define MU_CI_UVM_IRBUILDER_NEW_TYPE_WEAKREF         ((MuCommInst)0x316) /// MUAPIPARSER muname:@uvm.irbuilder.new_type_weakref
#define MU_CI_UVM_IRBUILDER_SET_TYPE_WEAKREF         ((MuCommInst)0x317) /// MUAPIPARSER muname:@uvm.irbuilder.set_type_weakref
#define MU_CI_UVM_IRBUILDER_NEW_TYPE_FUNCREF         ((MuCommInst)0x318) /// MUAPIPARSER muname:@uvm.irbuilder.new_type_funcref
#define MU_CI_UVM_IRBUILDER_SET_TYPE_FUNCREF         ((MuCommInst)0x319) /// MUAPIPARSER muname:@uvm.irbuilder.set_type_funcref
#define MU_CI_UVM_IRBUILDER_NEW_TYPE_TAGREF64        ((MuCommInst)0x31a) /// MUAPIPARSER muname:@uvm.irbuilder.new_type_tagref64
#define MU_CI_UVM_IRBUILDER_NEW_TYPE_THREADREF       ((MuCommInst)0x31b) /// MUAPIPARSER muname:@uvm.irbuilder.new_type_threadref
#define MU_CI_UVM_IRBUILDER_NEW_TYPE_STACKREF        ((MuCommInst)0x31c) /// MUAPIPARSER muname:@uvm.irbuilder.new_type_stackref
#define MU_CI_UVM_IRBUILDER_NEW_TYPE_FRAMECURSORREF  ((MuCommInst)0x31d) /// MUAPIPARSER muname:@uvm.irbuilder.new_type_framecursorref
#define MU_CI_UVM_IRBUILDER_NEW_TYPE_IRNODEREF       ((MuCommInst)0x31e) /// MUAPIPARSER muname:@uvm.irbuilder.new_type_irnoderef
#define MU_CI_UVM_IRBUILDER_NEW_FUNCSIG              ((MuCommInst)0x31f) /// MUAPIPARSER muname:@uvm.irbuilder.new_funcsig
#define MU_CI_UVM_IRBUILDER_NEW_CONST_INT            ((MuCommInst)0x320) /// MUAPIPARSER muname:@uvm.irbuilder.new_const_int
#define MU_CI_UVM_IRBUILDER_NEW_CONST_INT_EX         ((MuCommInst)0x321) /// MUAPIPARSER muname:@uvm.irbuilder.new_const_int_ex
#define MU_CI_UVM_IRBUILDER_NEW_CONST_FLOAT          ((MuCommInst)0x322) /// MUAPIPARSER muname:@uvm.irbuilder.new_const_float
#define MU_CI_UVM_IRBUILDER_NEW_CONST_DOUBLE         ((MuCommInst)0x323) /// MUAPIPARSER muname:@uvm.irbuilder.new_const_double
#define MU_CI_UVM_IRBUILDER_NEW_CONST_NULL           ((MuCommInst)0x324) /// MUAPIPARSER muname:@uvm.irbuilder.new_const_null
#define MU_CI_UVM_IRBUILDER_NEW_CONST_SEQ            ((MuCommInst)0x325) /// MUAPIPARSER muname:@uvm.irbuilder.new_const_seq
#define MU_CI_UVM_IRBUILDER_NEW_GLOBAL_CELL          ((MuCommInst)0x326) /// MUAPIPARSER muname:@uvm.irbuilder.new_global_cell
#define MU_CI_UVM_IRBUILDER_NEW_FUNC                 ((MuCommInst)0x327) /// MUAPIPARSER muname:@uvm.irbuilder.new_func
#define MU_CI_UVM_IRBUILDER_NEW_FUNC_VER             ((MuCommInst)0x328) /// MUAPIPARSER muname:@uvm.irbuilder.new_func_ver
#define MU_CI_UVM_IRBUILDER_NEW_EXP_FUNC             ((MuCommInst)0x329) /// MUAPIPARSER muname:@uvm.irbuilder.new_exp_func
#define MU_CI_UVM_IRBUILDER_NEW_BB                   ((MuCommInst)0x32a) /// MUAPIPARSER muname:@uvm.irbuilder.new_bb
#define MU_CI_UVM_IRBUILDER_NEW_NOR_PARAM            ((MuCommInst)0x32b) /// MUAPIPARSER muname:@uvm.irbuilder.new_nor_param
#define MU_CI_UVM_IRBUILDER_NEW_EXC_PARAM            ((MuCommInst)0x32c) /// MUAPIPARSER muname:@uvm.irbuilder.new_exc_param
#define MU_CI_UVM_IRBUILDER_NEW_INST_RES             ((MuCommInst)0x32d) /// MUAPIPARSER muname:@uvm.irbuilder.new_inst_res
#define MU_CI_UVM_IRBUILDER_ADD_DEST                 ((MuCommInst)0x32e) /// MUAPIPARSER muname:@uvm.irbuilder.add_dest
#define MU_CI_UVM_IRBUILDER_ADD_KEEPALIVES           ((MuCommInst)0x32f) /// MUAPIPARSER muname:@uvm.irbuilder.add_keepalives
#define MU_CI_UVM_IRBUILDER_NEW_BINOP                ((MuCommInst)0x330) /// MUAPIPARSER muname:@uvm.irbuilder.new_binop
#define MU_CI_UVM_IRBUILDER_NEW_CMP                  ((MuCommInst)0x331) /// MUAPIPARSER muname:@uvm.irbuilder.new_cmp
#define MU_CI_UVM_IRBUILDER_NEW_CONV                 ((MuCommInst)0x332) /// MUAPIPARSER muname:@uvm.irbuilder.new_conv
#define MU_CI_UVM_IRBUILDER_NEW_SELECT               ((MuCommInst)0x333) /// MUAPIPARSER muname:@uvm.irbuilder.new_select
#define MU_CI_UVM_IRBUILDER_NEW_BRANCH               ((MuCommInst)0x334) /// MUAPIPARSER muname:@uvm.irbuilder.new_branch
#define MU_CI_UVM_IRBUILDER_NEW_BRANCH2              ((MuCommInst)0x335) /// MUAPIPARSER muname:@uvm.irbuilder.new_branch2
#define MU_CI_UVM_IRBUILDER_NEW_SWITCH               ((MuCommInst)0x336) /// MUAPIPARSER muname:@uvm.irbuilder.new_switch
#define MU_CI_UVM_IRBUILDER_ADD_SWITCH_DEST          ((MuCommInst)0x337) /// MUAPIPARSER muname:@uvm.irbuilder.add_switch_dest
#define MU_CI_UVM_IRBUILDER_NEW_CALL                 ((MuCommInst)0x338) /// MUAPIPARSER muname:@uvm.irbuilder.new_call
#define MU_CI_UVM_IRBUILDER_NEW_TAILCALL             ((MuCommInst)0x339) /// MUAPIPARSER muname:@uvm.irbuilder.new_tailcall
#define MU_CI_UVM_IRBUILDER_NEW_RET                  ((MuCommInst)0x33a) /// MUAPIPARSER muname:@uvm.irbuilder.new_ret
#define MU_CI_UVM_IRBUILDER_NEW_THROW                ((MuCommInst)0x33b) /// MUAPIPARSER muname:@uvm.irbuilder.new_throw
#define MU_CI_UVM_IRBUILDER_NEW_EXTRACTVALUE         ((MuCommInst)0x33c) /// MUAPIPARSER muname:@uvm.irbuilder.new_extractvalue
#define MU_CI_UVM_IRBUILDER_NEW_INSERTVALUE          ((MuCommInst)0x33d) /// MUAPIPARSER muname:@uvm.irbuilder.new_insertvalue
#define MU_CI_UVM_IRBUILDER_NEW_EXTRACTELEMENT       ((MuCommInst)0x33e) /// MUAPIPARSER muname:@uvm.irbuilder.new_extractelement
#define MU_CI_UVM_IRBUILDER_NEW_INSERTELEMENT        ((MuCommInst)0x33f) /// MUAPIPARSER muname:@uvm.irbuilder.new_insertelement
#define MU_CI_UVM_IRBUILDER_NEW_SHUFFLEVECTOR        ((MuCommInst)0x340) /// MUAPIPARSER muname:@uvm.irbuilder.new_shufflevector
#define MU_CI_UVM_IRBUILDER_NEW_NEW                  ((MuCommInst)0x341) /// MUAPIPARSER muname:@uvm.irbuilder.new_new
#define MU_CI_UVM_IRBUILDER_NEW_NEWHYBRID            ((MuCommInst)0x342) /// MUAPIPARSER muname:@uvm.irbuilder.new_newhybrid
#define MU_CI_UVM_IRBUILDER_NEW_ALLOCA               ((MuCommInst)0x343) /// MUAPIPARSER muname:@uvm.irbuilder.new_alloca
#define MU_CI_UVM_IRBUILDER_NEW_ALLOCAHYBRID         ((MuCommInst)0x344) /// MUAPIPARSER muname:@uvm.irbuilder.new_allocahybrid
#define MU_CI_UVM_IRBUILDER_NEW_GETIREF              ((MuCommInst)0x345) /// MUAPIPARSER muname:@uvm.irbuilder.new_getiref
#define MU_CI_UVM_IRBUILDER_NEW_GETFIELDIREF         ((MuCommInst)0x346) /// MUAPIPARSER muname:@uvm.irbuilder.new_getfieldiref
#define MU_CI_UVM_IRBUILDER_NEW_GETELEMIREF          ((MuCommInst)0x347) /// MUAPIPARSER muname:@uvm.irbuilder.new_getelemiref
#define MU_CI_UVM_IRBUILDER_NEW_SHIFTIREF            ((MuCommInst)0x348) /// MUAPIPARSER muname:@uvm.irbuilder.new_shiftiref
#define MU_CI_UVM_IRBUILDER_NEW_GETVARPARTIREF       ((MuCommInst)0x349) /// MUAPIPARSER muname:@uvm.irbuilder.new_getvarpartiref
#define MU_CI_UVM_IRBUILDER_NEW_LOAD                 ((MuCommInst)0x34a) /// MUAPIPARSER muname:@uvm.irbuilder.new_load
#define MU_CI_UVM_IRBUILDER_NEW_STORE                ((MuCommInst)0x34b) /// MUAPIPARSER muname:@uvm.irbuilder.new_store
#define MU_CI_UVM_IRBUILDER_NEW_CMPXCHG              ((MuCommInst)0x34c) /// MUAPIPARSER muname:@uvm.irbuilder.new_cmpxchg
#define MU_CI_UVM_IRBUILDER_NEW_ATOMICRMW            ((MuCommInst)0x34d) /// MUAPIPARSER muname:@uvm.irbuilder.new_atomicrmw
#define MU_CI_UVM_IRBUILDER_NEW_FENCE                ((MuCommInst)0x34e) /// MUAPIPARSER muname:@uvm.irbuilder.new_fence
#define MU_CI_UVM_IRBUILDER_NEW_TRAP                 ((MuCommInst)0x34f) /// MUAPIPARSER muname:@uvm.irbuilder.new_trap
#define MU_CI_UVM_IRBUILDER_NEW_WATCHPOINT           ((MuCommInst)0x350) /// MUAPIPARSER muname:@uvm.irbuilder.new_watchpoint
#define MU_CI_UVM_IRBUILDER_NEW_WPBRANCH             ((MuCommInst)0x351) /// MUAPIPARSER muname:@uvm.irbuilder.new_wpbranch
#define MU_CI_UVM_IRBUILDER_NEW_CCALL                ((MuCommInst)0x352) /// MUAPIPARSER muname:@uvm.irbuilder.new_ccall
#define MU_CI_UVM_IRBUILDER_NEW_NEWTHREAD            ((MuCommInst)0x353) /// MUAPIPARSER muname:@uvm.irbuilder.new_newthread
#define MU_CI_UVM_IRBUILDER_NEW_SWAPSTACK_RET        ((MuCommInst)0x354) /// MUAPIPARSER muname:@uvm.irbuilder.new_swapstack_ret
#define MU_CI_UVM_IRBUILDER_NEW_SWAPSTACK_KILL       ((MuCommInst)0x355) /// MUAPIPARSER muname:@uvm.irbuilder.new_swapstack_kill
#define MU_CI_UVM_IRBUILDER_SET_NEWSTACK_PASS_VALUES ((MuCommInst)0x356) /// MUAPIPARSER muname:@uvm.irbuilder.set_newstack_pass_values
#define MU_CI_UVM_IRBUILDER_SET_NEWSTACK_THROW_EXC   ((MuCommInst)0x357) /// MUAPIPARSER muname:@uvm.irbuilder.set_newstack_throw_exc
#define MU_CI_UVM_IRBUILDER_NEW_COMMINST             ((MuCommInst)0x358) /// MUAPIPARSER muname:@uvm.irbuilder.new_comminst
Kunshan Wang's avatar
Kunshan Wang committed
761
/// SCRIPT: GENERATED COMMINSTS END
Kunshan Wang's avatar
Kunshan Wang committed
762

Kunshan Wang's avatar
Kunshan Wang committed
763 764 765 766 767
#ifdef __cplusplus
}
#endif

#endif // __MUAPI_H__