llvm.org GIT mirror llvm / 4c09131
More C++ification. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@206722 91177308-0d34-0410-b5e6-96231b3b80d8 Richard Smith 6 years ago
3 changed file(s) with 182 addition(s) and 242 deletion(s). Raw diff Collapse all Expand all
2020 namespace llvm {
2121 namespace X86Disassembler {
2222
23 /*
24 * Accessor functions for various fields of an Intel instruction
25 */
23 // Accessor functions for various fields of an Intel instruction
2624 #define modFromModRM(modRM) (((modRM) & 0xc0) >> 6)
2725 #define regFromModRM(modRM) (((modRM) & 0x38) >> 3)
2826 #define rmFromModRM(modRM) ((modRM) & 0x7)
7270 #define lFromXOP3of3(xop) (((xop) & 0x4) >> 2)
7371 #define ppFromXOP3of3(xop) ((xop) & 0x3)
7472
75 /*
76 * These enums represent Intel registers for use by the decoder.
77 */
78
73 // These enums represent Intel registers for use by the decoder.
7974 #define REGS_8BIT \
8075 ENTRY(AL) \
8176 ENTRY(CL) \
381376 REGS_CONTROL \
382377 ENTRY(RIP)
383378
384 /*
385 * EABase - All possible values of the base field for effective-address
386 * computations, a.k.a. the Mod and R/M fields of the ModR/M byte. We
387 * distinguish between bases (EA_BASE_*) and registers that just happen to be
388 * referred to when Mod == 0b11 (EA_REG_*).
389 */
390 typedef enum {
379 /// \brief All possible values of the base field for effective-address
380 /// computations, a.k.a. the Mod and R/M fields of the ModR/M byte.
381 /// We distinguish between bases (EA_BASE_*) and registers that just happen
382 /// to be referred to when Mod == 0b11 (EA_REG_*).
383 enum EABase {
391384 EA_BASE_NONE,
392385 #define ENTRY(x) EA_BASE_##x,
393386 ALL_EA_BASES
396389 ALL_REGS
397390 #undef ENTRY
398391 EA_max
399 } EABase;
400
401 /*
402 * SIBIndex - All possible values of the SIB index field.
403 * Borrows entries from ALL_EA_BASES with the special case that
404 * sib is synonymous with NONE.
405 * Vector SIB: index can be XMM or YMM.
406 */
407 typedef enum {
392 };
393
394 /// \brief All possible values of the SIB index field.
395 /// borrows entries from ALL_EA_BASES with the special case that
396 /// sib is synonymous with NONE.
397 /// Vector SIB: index can be XMM or YMM.
398 enum SIBIndex {
408399 SIB_INDEX_NONE,
409400 #define ENTRY(x) SIB_INDEX_##x,
410401 ALL_EA_BASES
413404 REGS_ZMM
414405 #undef ENTRY
415406 SIB_INDEX_max
416 } SIBIndex;
417
418 /*
419 * SIBBase - All possible values of the SIB base field.
420 */
421 typedef enum {
407 };
408
409 /// \brief All possible values of the SIB base field.
410 enum SIBBase {
422411 SIB_BASE_NONE,
423412 #define ENTRY(x) SIB_BASE_##x,
424413 ALL_SIB_BASES
425414 #undef ENTRY
426415 SIB_BASE_max
427 } SIBBase;
428
429 /*
430 * EADisplacement - Possible displacement types for effective-address
431 * computations.
432 */
416 };
417
418 /// \brief Possible displacement types for effective-address computations.
433419 typedef enum {
434420 EA_DISP_NONE,
435421 EA_DISP_8,
437423 EA_DISP_32
438424 } EADisplacement;
439425
440 /*
441 * Reg - All possible values of the reg field in the ModR/M byte.
442 */
443 typedef enum {
426 /// \brief All possible values of the reg field in the ModR/M byte.
427 enum Reg {
444428 #define ENTRY(x) MODRM_REG_##x,
445429 ALL_REGS
446430 #undef ENTRY
447431 MODRM_REG_max
448 } Reg;
449
450 /*
451 * SegmentOverride - All possible segment overrides.
452 */
453 typedef enum {
432 };
433
434 /// \brief All possible segment overrides.
435 enum SegmentOverride {
454436 SEG_OVERRIDE_NONE,
455437 SEG_OVERRIDE_CS,
456438 SEG_OVERRIDE_SS,
459441 SEG_OVERRIDE_FS,
460442 SEG_OVERRIDE_GS,
461443 SEG_OVERRIDE_max
462 } SegmentOverride;
463
464 /*
465 * VEXLeadingOpcodeByte - Possible values for the VEX.m-mmmm field
466 */
467
468 typedef enum {
444 };
445
446 /// \brief Possible values for the VEX.m-mmmm field
447 enum VEXLeadingOpcodeByte {
469448 VEX_LOB_0F = 0x1,
470449 VEX_LOB_0F38 = 0x2,
471450 VEX_LOB_0F3A = 0x3
472 } VEXLeadingOpcodeByte;
473
474 typedef enum {
451 };
452
453 enum XOPMapSelect {
475454 XOP_MAP_SELECT_8 = 0x8,
476455 XOP_MAP_SELECT_9 = 0x9,
477456 XOP_MAP_SELECT_A = 0xA
478 } XOPMapSelect;
479
480 /*
481 * VEXPrefixCode - Possible values for the VEX.pp/EVEX.pp field
482 */
483
484 typedef enum {
457 };
458
459 /// \brief Possible values for the VEX.pp/EVEX.pp field
460 enum VEXPrefixCode {
485461 VEX_PREFIX_NONE = 0x0,
486462 VEX_PREFIX_66 = 0x1,
487463 VEX_PREFIX_F3 = 0x2,
488464 VEX_PREFIX_F2 = 0x3
489 } VEXPrefixCode;
490
491 typedef enum {
465 };
466
467 enum VectorExtensionType {
492468 TYPE_NO_VEX_XOP = 0x0,
493469 TYPE_VEX_2B = 0x1,
494470 TYPE_VEX_3B = 0x2,
495471 TYPE_EVEX = 0x3,
496472 TYPE_XOP = 0x4
497 } VectorExtensionType;
473 };
498474
499475 typedef uint8_t BOOL;
500476
501 /*
502 * byteReader_t - Type for the byte reader that the consumer must provide to
503 * the decoder. Reads a single byte from the instruction's address space.
504 * @param arg - A baton that the consumer can associate with any internal
505 * state that it needs.
506 * @param byte - A pointer to a single byte in memory that should be set to
507 * contain the value at address.
508 * @param address - The address in the instruction's address space that should
509 * be read from.
510 * @return - -1 if the byte cannot be read for any reason; 0 otherwise.
511 */
512 typedef int (*byteReader_t)(const void* arg, uint8_t* byte, uint64_t address);
513
514 /*
515 * dlog_t - Type for the logging function that the consumer can provide to
516 * get debugging output from the decoder.
517 * @param arg - A baton that the consumer can associate with any internal
518 * state that it needs.
519 * @param log - A string that contains the message. Will be reused after
520 * the logger returns.
521 */
522 typedef void (*dlog_t)(void* arg, const char *log);
523
524 /*
525 * The specification for how to extract and interpret a full instruction and
526 * its operands.
527 */
477 /// \brief Type for the byte reader that the consumer must provide to
478 /// the decoder. Reads a single byte from the instruction's address space.
479 /// \param arg A baton that the consumer can associate with any internal
480 /// state that it needs.
481 /// \param byte A pointer to a single byte in memory that should be set to
482 /// contain the value at address.
483 /// \param address The address in the instruction's address space that should
484 /// be read from.
485 /// \return -1 if the byte cannot be read for any reason; 0 otherwise.
486 typedef int (*byteReader_t)(const void *arg, uint8_t *byte, uint64_t address);
487
488 /// \brief Type for the logging function that the consumer can provide to
489 /// get debugging output from the decoder.
490 /// \param arg A baton that the consumer can associate with any internal
491 /// state that it needs.
492 /// \param log A string that contains the message. Will be reused after
493 /// the logger returns.
494 typedef void (*dlog_t)(void *arg, const char *log);
495
496 /// The specification for how to extract and interpret a full instruction and
497 /// its operands.
528498 struct InstructionSpecifier {
529499 uint16_t operands;
530500 };
531501
532 /*
533 * The x86 internal instruction, which is produced by the decoder.
534 */
502 /// The x86 internal instruction, which is produced by the decoder.
535503 struct InternalInstruction {
536 /* Reader interface (C) */
504 // Reader interface (C)
537505 byteReader_t reader;
538 /* Opaque value passed to the reader */
506 // Opaque value passed to the reader
539507 const void* readerArg;
540 /* The address of the next byte to read via the reader */
508 // The address of the next byte to read via the reader
541509 uint64_t readerCursor;
542510
543 /* Logger interface (C) */
511 // Logger interface (C)
544512 dlog_t dlog;
545 /* Opaque value passed to the logger */
513 // Opaque value passed to the logger
546514 void* dlogArg;
547515
548 /* General instruction information */
549
550 /* The mode to disassemble for (64-bit, protected, real) */
516 // General instruction information
517
518 // The mode to disassemble for (64-bit, protected, real)
551519 DisassemblerMode mode;
552 /* The start of the instruction, usable with the reader */
520 // The start of the instruction, usable with the reader
553521 uint64_t startLocation;
554 /* The length of the instruction, in bytes */
522 // The length of the instruction, in bytes
555523 size_t length;
556524
557 /* Prefix state */
558
559 /* 1 if the prefix byte corresponding to the entry is present; 0 if not */
525 // Prefix state
526
527 // 1 if the prefix byte corresponding to the entry is present; 0 if not
560528 uint8_t prefixPresent[0x100];
561 /* contains the location (for use with the reader) of the prefix byte */
529 // contains the location (for use with the reader) of the prefix byte
562530 uint64_t prefixLocations[0x100];
563 /* The value of the vector extension prefix(EVEX/VEX/XOP), if present */
531 // The value of the vector extension prefix(EVEX/VEX/XOP), if present
564532 uint8_t vectorExtensionPrefix[4];
565 /* The type of the vector extension prefix */
533 // The type of the vector extension prefix
566534 VectorExtensionType vectorExtensionType;
567 /* The value of the REX prefix, if present */
535 // The value of the REX prefix, if present
568536 uint8_t rexPrefix;
569 /* The location where a mandatory prefix would have to be (i.e., right before
570 the opcode, or right before the REX prefix if one is present) */
537 // The location where a mandatory prefix would have to be (i.e., right before
538 // the opcode, or right before the REX prefix if one is present).
571539 uint64_t necessaryPrefixLocation;
572 /* The segment override type */
540 // The segment override type
573541 SegmentOverride segmentOverride;
574 /* 1 if the prefix byte, 0xf2 or 0xf3 is xacquire or xrelease */
542 // 1 if the prefix byte, 0xf2 or 0xf3 is xacquire or xrelease
575543 BOOL xAcquireRelease;
576544
577 /* Sizes of various critical pieces of data, in bytes */
545 // Sizes of various critical pieces of data, in bytes
578546 uint8_t registerSize;
579547 uint8_t addressSize;
580548 uint8_t displacementSize;
581549 uint8_t immediateSize;
582550
583 /* Offsets from the start of the instruction to the pieces of data, which is
584 needed to find relocation entries for adding symbolic operands */
551 // Offsets from the start of the instruction to the pieces of data, which is
552 // needed to find relocation entries for adding symbolic operands.
585553 uint8_t displacementOffset;
586554 uint8_t immediateOffset;
587555
588 /* opcode state */
589
590 /* The last byte of the opcode, not counting any ModR/M extension */
556 // opcode state
557
558 // The last byte of the opcode, not counting any ModR/M extension
591559 uint8_t opcode;
592 /* The ModR/M byte of the instruction, if it is an opcode extension */
560 // The ModR/M byte of the instruction, if it is an opcode extension
593561 uint8_t modRMExtension;
594562
595 /* decode state */
596
597 /* The type of opcode, used for indexing into the array of decode tables */
563 // decode state
564
565 // The type of opcode, used for indexing into the array of decode tables
598566 OpcodeType opcodeType;
599 /* The instruction ID, extracted from the decode table */
567 // The instruction ID, extracted from the decode table
600568 uint16_t instructionID;
601 /* The specifier for the instruction, from the instruction info table */
569 // The specifier for the instruction, from the instruction info table
602570 const InstructionSpecifier *spec;
603571
604 /* state for additional bytes, consumed during operand decode. Pattern:
605 consumed___ indicates that the byte was already consumed and does not
606 need to be consumed again */
607
608 /* The VEX.vvvv field, which contains a third register operand for some AVX
609 instructions */
572 // state for additional bytes, consumed during operand decode. Pattern:
573 // consumed___ indicates that the byte was already consumed and does not
574 // need to be consumed again.
575
576 // The VEX.vvvv field, which contains a third register operand for some AVX
577 // instructions.
610578 Reg vvvv;
611579
612 /* The writemask for AVX-512 instructions which is contained in EVEX.aaa */
580 // The writemask for AVX-512 instructions which is contained in EVEX.aaa
613581 Reg writemask;
614582
615 /* The ModR/M byte, which contains most register operands and some portion of
616 all memory operands */
583 // The ModR/M byte, which contains most register operands and some portion of
584 // all memory operands.
617585 BOOL consumedModRM;
618586 uint8_t modRM;
619587
620 /* The SIB byte, used for more complex 32- or 64-bit memory operands */
588 // The SIB byte, used for more complex 32- or 64-bit memory operands
621589 BOOL consumedSIB;
622590 uint8_t sib;
623591
624 /* The displacement, used for memory operands */
592 // The displacement, used for memory operands
625593 BOOL consumedDisplacement;
626594 int32_t displacement;
627595
628 /* Immediates. There can be two in some cases */
596 // Immediates. There can be two in some cases
629597 uint8_t numImmediatesConsumed;
630598 uint8_t numImmediatesTranslated;
631599 uint64_t immediates[2];
632600
633 /* A register or immediate operand encoded into the opcode */
601 // A register or immediate operand encoded into the opcode
634602 Reg opcodeRegister;
635603
636 /* Portions of the ModR/M byte */
637
638 /* These fields determine the allowable values for the ModR/M fields, which
639 depend on operand and address widths */
604 // Portions of the ModR/M byte
605
606 // These fields determine the allowable values for the ModR/M fields, which
607 // depend on operand and address widths.
640608 EABase eaBaseBase;
641609 EABase eaRegBase;
642610 Reg regBase;
643611
644 /* The Mod and R/M fields can encode a base for an effective address, or a
645 register. These are separated into two fields here */
612 // The Mod and R/M fields can encode a base for an effective address, or a
613 // register. These are separated into two fields here.
646614 EABase eaBase;
647615 EADisplacement eaDisplacement;
648 /* The reg field always encodes a register */
616 // The reg field always encodes a register
649617 Reg reg;
650618
651 /* SIB state */
619 // SIB state
652620 SIBIndex sibIndex;
653621 uint8_t sibScale;
654622 SIBBase sibBase;
656624 const OperandSpecifier *operands;
657625 };
658626
659 /* decodeInstruction - Decode one instruction and store the decoding results in
660 * a buffer provided by the consumer.
661 * @param insn - The buffer to store the instruction in. Allocated by the
662 * consumer.
663 * @param reader - The byteReader_t for the bytes to be read.
664 * @param readerArg - An argument to pass to the reader for storing context
665 * specific to the consumer. May be NULL.
666 * @param logger - The dlog_t to be used in printing status messages from the
667 * disassembler. May be NULL.
668 * @param loggerArg - An argument to pass to the logger for storing context
669 * specific to the logger. May be NULL.
670 * @param startLoc - The address (in the reader's address space) of the first
671 * byte in the instruction.
672 * @param mode - The mode (16-bit, 32-bit, 64-bit) to decode in.
673 * @return - Nonzero if there was an error during decode, 0 otherwise.
674 */
627 /// \brief Decode one instruction and store the decoding results in
628 /// a buffer provided by the consumer.
629 /// \param insn The buffer to store the instruction in. Allocated by the
630 /// consumer.
631 /// \param reader The byteReader_t for the bytes to be read.
632 /// \param readerArg An argument to pass to the reader for storing context
633 /// specific to the consumer. May be NULL.
634 /// \param logger The dlog_t to be used in printing status messages from the
635 /// disassembler. May be NULL.
636 /// \param loggerArg An argument to pass to the logger for storing context
637 /// specific to the logger. May be NULL.
638 /// \param startLoc The address (in the reader's address space) of the first
639 /// byte in the instruction.
640 /// \param mode The mode (16-bit, 32-bit, 64-bit) to decode in.
641 /// \return Nonzero if there was an error during decode, 0 otherwise.
675642 int decodeInstruction(InternalInstruction *insn,
676643 byteReader_t reader,
677644 const void *readerArg,
681648 uint64_t startLoc,
682649 DisassemblerMode mode);
683650
684 /* \brief Debug - Print a message to debugs()
685 * @param file - The name of the file printing the debug message.
686 * @param line - The line number that printed the debug message.
687 * @param s - The message to print.
688 */
689
651 /// \brief Print a message to debugs()
652 /// \param file The name of the file printing the debug message.
653 /// \param line The line number that printed the debug message.
654 /// \param s The message to print.
690655 void Debug(const char *file, unsigned line, const char *s);
691656
692657 const char *GetInstrName(unsigned Opcode, const void *mii);
4141 #define XOP9_MAP_STR "x86DisassemblerXOP9Opcodes"
4242 #define XOPA_MAP_STR "x86DisassemblerXOPAOpcodes"
4343
44 /*
45 * Attributes of an instruction that must be known before the opcode can be
46 * processed correctly. Most of these indicate the presence of particular
47 * prefixes, but ATTR_64BIT is simply an attribute of the decoding context.
48 */
44 // Attributes of an instruction that must be known before the opcode can be
45 // processed correctly. Most of these indicate the presence of particular
46 // prefixes, but ATTR_64BIT is simply an attribute of the decoding context.
4947 #define ATTRIBUTE_BITS \
5048 ENUM_ENTRY(ATTR_NONE, 0x00) \
5149 ENUM_ENTRY(ATTR_64BIT, (0x1 << 0)) \
7068 };
7169 #undef ENUM_ENTRY
7270
73 /*
74 * Combinations of the above attributes that are relevant to instruction
75 * decode. Although other combinations are possible, they can be reduced to
76 * these without affecting the ultimately decoded instruction.
77 */
78
79 /* Class name Rank Rationale for rank assignment */
71 // Combinations of the above attributes that are relevant to instruction
72 // decode. Although other combinations are possible, they can be reduced to
73 // these without affecting the ultimately decoded instruction.
74
75 // Class name Rank Rationale for rank assignment
8076 #define INSTRUCTION_CONTEXTS \
8177 ENUM_ENTRY(IC, 0, "says nothing about the instruction") \
8278 ENUM_ENTRY(IC_64BIT, 1, "says the instruction applies in " \
277273 };
278274 #undef ENUM_ENTRY
279275
280 /*
281 * Opcode types, which determine which decode table to use, both in the Intel
282 * manual and also for the decoder.
283 */
276 // Opcode types, which determine which decode table to use, both in the Intel
277 // manual and also for the decoder.
284278 enum OpcodeType {
285279 ONEBYTE = 0,
286280 TWOBYTE = 1,
291285 XOPA_MAP = 6
292286 };
293287
294 /*
295 * The following structs are used for the hierarchical decode table. After
296 * determining the instruction's class (i.e., which IC_* constant applies to
297 * it), the decoder reads the opcode. Some instructions require specific
298 * values of the ModR/M byte, so the ModR/M byte indexes into the final table.
299 *
300 * If a ModR/M byte is not required, "required" is left unset, and the values
301 * for each instructionID are identical.
302 */
303
288 // The following structs are used for the hierarchical decode table. After
289 // determining the instruction's class (i.e., which IC_* constant applies to
290 // it), the decoder reads the opcode. Some instructions require specific
291 // values of the ModR/M byte, so the ModR/M byte indexes into the final table.
292 //
293 // If a ModR/M byte is not required, "required" is left unset, and the values
294 // for each instructionID are identical.
304295 typedef uint16_t InstrUID;
305296
306 /*
307 * ModRMDecisionType - describes the type of ModR/M decision, allowing the
308 * consumer to determine the number of entries in it.
309 *
310 * MODRM_ONEENTRY - No matter what the value of the ModR/M byte is, the decoded
311 * instruction is the same.
312 * MODRM_SPLITRM - If the ModR/M byte is between 0x00 and 0xbf, the opcode
313 * corresponds to one instruction; otherwise, it corresponds to
314 * a different instruction.
315 * MODRM_SPLITMISC- If the ModR/M byte is between 0x00 and 0xbf, ModR/M byte
316 * divided by 8 is used to select instruction; otherwise, each
317 * value of the ModR/M byte could correspond to a different
318 * instruction.
319 * MODRM_SPLITREG - ModR/M byte divided by 8 is used to select instruction. This
320 corresponds to instructions that use reg field as opcode
321 * MODRM_FULL - Potentially, each value of the ModR/M byte could correspond
322 * to a different instruction.
323 */
324
297 // ModRMDecisionType - describes the type of ModR/M decision, allowing the
298 // consumer to determine the number of entries in it.
299 //
300 // MODRM_ONEENTRY - No matter what the value of the ModR/M byte is, the decoded
301 // instruction is the same.
302 // MODRM_SPLITRM - If the ModR/M byte is between 0x00 and 0xbf, the opcode
303 // corresponds to one instruction; otherwise, it corresponds to
304 // a different instruction.
305 // MODRM_SPLITMISC- If the ModR/M byte is between 0x00 and 0xbf, ModR/M byte
306 // divided by 8 is used to select instruction; otherwise, each
307 // value of the ModR/M byte could correspond to a different
308 // instruction.
309 // MODRM_SPLITREG - ModR/M byte divided by 8 is used to select instruction. This
310 // corresponds to instructions that use reg field as opcode
311 // MODRM_FULL - Potentially, each value of the ModR/M byte could correspond
312 // to a different instruction.
325313 #define MODRMTYPES \
326314 ENUM_ENTRY(MODRM_ONEENTRY) \
327315 ENUM_ENTRY(MODRM_SPLITRM) \
336324 };
337325 #undef ENUM_ENTRY
338326
339 /*
340 * Physical encodings of instruction operands.
341 */
342
327 // Physical encodings of instruction operands.
343328 #define ENCODINGS \
344329 ENUM_ENTRY(ENCODING_NONE, "") \
345330 ENUM_ENTRY(ENCODING_REG, "Register operand in ModR/M byte.") \
380365 };
381366 #undef ENUM_ENTRY
382367
383 /*
384 * Semantic interpretations of instruction operands.
385 */
386
368 // Semantic interpretations of instruction operands.
387369 #define TYPES \
388370 ENUM_ENTRY(TYPE_NONE, "") \
389371 ENUM_ENTRY(TYPE_REL8, "1-byte immediate address") \
480462 };
481463 #undef ENUM_ENTRY
482464
483 /*
484 * OperandSpecifier - The specification for how to extract and interpret one
485 * operand.
486 */
465 /// \brief The specification for how to extract and interpret one operand.
487466 struct OperandSpecifier {
488467 uint8_t encoding;
489468 uint8_t type;
490469 };
491470
492 /*
493 * Indicates where the opcode modifier (if any) is to be found. Extended
494 * opcodes with AddRegFrm have the opcode modifier in the ModR/M byte.
495 */
496
471 // Indicates where the opcode modifier (if any) is to be found. Extended
472 // opcodes with AddRegFrm have the opcode modifier in the ModR/M byte.
497473 #define MODIFIER_TYPES \
498474 ENUM_ENTRY(MODIFIER_NONE)
499475
504480 };
505481 #undef ENUM_ENTRY
506482
507 #define X86_MAX_OPERANDS 5
508
509 /*
510 * Decoding mode for the Intel disassembler. 16-bit, 32-bit, and 64-bit mode
511 * are supported, and represent real mode, IA-32e, and IA-32e in 64-bit mode,
512 * respectively.
513 */
483 static const int X86_MAX_OPERANDS = 5;
484
485 /// Decoding mode for the Intel disassembler. 16-bit, 32-bit, and 64-bit mode
486 /// are supported, and represent real mode, IA-32e, and IA-32e in 64-bit mode,
487 /// respectively.
514488 enum DisassemblerMode {
515489 MODE_16BIT,
516490 MODE_32BIT,
1515 #include "../../lib/Target/X86/Disassembler/X86DisassemblerDecoderCommon.h"
1616
1717 struct InstructionSpecifier {
18 llvm::X86Disassembler::OperandSpecifier operands[X86_MAX_OPERANDS];
18 llvm::X86Disassembler::OperandSpecifier
19 operands[llvm::X86Disassembler::X86_MAX_OPERANDS];
1920 llvm::X86Disassembler::InstructionContext insnContext;
2021 std::string name;
2122