Merge branch 'next' into neo
diff --git a/CMakeLists.txt b/CMakeLists.txt
index b4a961f..92d4ea1 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -28,8 +28,8 @@
option(CAPSTONE_BUILD_CSTOOL "Build cstool" ON)
option(CAPSTONE_USE_DEFAULT_ALLOC "Use default memory allocation functions" ON)
-set(SUPPORTED_ARCHITECTURES ARM ARM64 M68K MIPS PPC SPARC SYSZ XCORE X86 TMS320C64X M680X EVM)
-set(SUPPORTED_ARCHITECTURE_LABELS ARM ARM64 M68K MIPS PowerPC Sparc SystemZ XCore x86 TMS320C64x M680x EVM)
+set(SUPPORTED_ARCHITECTURES ARM ARM64 M68K MIPS PPC SPARC SYSZ XCORE X86 TMS320C64X M680X EVM NEO)
+set(SUPPORTED_ARCHITECTURE_LABELS ARM ARM64 M68K MIPS PowerPC Sparc SystemZ XCore x86 TMS320C64x M680x EVM NEO)
list(LENGTH SUPPORTED_ARCHITECTURES count)
math(EXPR count "${count}-1")
@@ -382,6 +382,23 @@
set(TEST_SOURCES ${TEST_SOURCES} test_evm.c)
endif ()
+if (CAPSTONE_NEO_SUPPORT)
+ add_definitions(-DCAPSTONE_HAS_NEO)
+ set(SOURCES_NEO
+ arch/NEO/NEODisassembler.c
+ arch/NEO/NEOInstPrinter.c
+ arch/NEO/NEOMapping.c
+ arch/NEO/NEOModule.c
+ )
+ set(HEADERS_NEO
+ arch/NEO/NEODisassembler.h
+ arch/NEO/NEOInstPrinter.h
+ arch/NEO/NEOMapping.h
+ arch/NEO/NEOMappingInsn.inc
+ )
+ set(TEST_SOURCES ${TEST_SOURCES} test_neo.c)
+endif ()
+
if (CAPSTONE_OSXKERNEL_SUPPORT)
add_definitions(-DCAPSTONE_HAS_OSXKERNEL)
endif ()
@@ -400,6 +417,7 @@
${SOURCES_TMS320C64X}
${SOURCES_M680X}
${SOURCES_EVM}
+ ${SOURCES_NEO}
)
set(ALL_HEADERS
@@ -417,6 +435,7 @@
${HEADERS_TMS320C64X}
${HEADERS_M680X}
${HEADERS_EVM}
+ ${HEADERS_NEO}
)
include_directories("${PROJECT_SOURCE_DIR}/include")
@@ -497,6 +516,7 @@
source_group("Source\\TMS320C64x" FILES ${SOURCES_TMS320C64X})
source_group("Source\\M680X" FILES ${SOURCES_M680X})
source_group("Source\\EVM" FILES ${SOURCES_EVM})
+source_group("Source\\NEO" FILES ${SOURCES_NEO})
source_group("Include\\Common" FILES ${HEADERS_COMMON})
source_group("Include\\Engine" FILES ${HEADERS_ENGINE})
@@ -512,6 +532,7 @@
source_group("Include\\TMS320C64x" FILES ${HEADERS_TMS320C64X})
source_group("Include\\M680X" FILES ${HEADERS_MC680X})
source_group("Include\\EVM" FILES ${HEADERS_EVM})
+source_group("Include\\NEO" FILES ${HEADERS_NEO})
### test library 64bit routine:
get_property(LIB64 GLOBAL PROPERTY FIND_LIBRARY_USE_LIB64_PATHS)
diff --git a/COMPILE.TXT b/COMPILE.TXT
index 56aecad..9fa135e 100644
--- a/COMPILE.TXT
+++ b/COMPILE.TXT
@@ -17,12 +17,12 @@
(0) Tailor Capstone to your need.
- Out of 12 archtitectures supported by Capstone (Arm, Arm64, M68K, Mips, PPC,
- Sparc, SystemZ, XCore, X86, M680X, TMS320C64x & EVM), if you just need several
- selected archs, choose the ones you want to compile in by editing "config.mk"
- before going to next steps.
+ Out of 13 archtitectures supported by Capstone (Arm, Arm64, M68K, Mips, PPC,
+ Sparc, SystemZ, XCore, X86, M680X, TMS320C64x, EVM & NEO), if you just need
+ several selected archs, choose the ones you want to compile in by editing
+ "config.mk" before going to next steps.
- By default, all 12 architectures are compiled.
+ By default, all architectures are compiled.
The other way of customize Capstone without having to edit config.mk is to
pass the desired options on the commandline to ./make.sh. Currently,
@@ -91,6 +91,7 @@
/usr/include/capstone/m68k.h
/usr/include/capstone/m680x.h
/usr/include/capstone/mips.h
+ /usr/include/capstone/neo.h
/usr/include/capstone/ppc.h
/usr/include/capstone/sparc.h
/usr/include/capstone/systemz.h
diff --git a/HACK.TXT b/HACK.TXT
index e641c68..a7058d1 100644
--- a/HACK.TXT
+++ b/HACK.TXT
@@ -5,12 +5,15 @@
├── arch <- code handling disasm engine for each arch
│ ├── AArch64 <- ARM64 (aka ARMv8) engine
│ ├── ARM <- ARM engine
+│ ├── EVM <- Ethereum VM engine
│ ├── M680X <- M680X engine
│ ├── M68K <- M68K engine
│ ├── Mips <- Mips engine
+│ ├── NEO <- NEO VM engine
│ ├── PowerPC <- PowerPC engine
│ ├── Sparc <- Sparc engine
│ ├── SystemZ <- SystemZ engine
+│ ├── TMS320C64x <- TMS320C64x engine
│ ├── X86 <- X86 engine
│ └── XCore <- XCore engine
├── bindings <- all bindings are under this dir
diff --git a/MCInst.h b/MCInst.h
index 6a70741..5516246 100644
--- a/MCInst.h
+++ b/MCInst.h
@@ -110,6 +110,7 @@
uint8_t popcode_adjust; // Pseudo X86 instruction adjust
char assembly[8]; // for special instruction, so that we dont need printer
unsigned char evm_data[32]; // for EVM PUSH operand
+ unsigned char neo_data[80]; // for NEO instructions with operands
};
void MCInst_Init(MCInst *inst);
diff --git a/Makefile b/Makefile
index 0118122..0d469a7 100644
--- a/Makefile
+++ b/Makefile
@@ -250,9 +250,20 @@
endif
+DEP_NEO =
+DEP_NEO += $(wildcard arch/NEO/NEO*.inc)
+
+LIBOBJ_NEO =
+ifneq (,$(findstring neo,$(CAPSTONE_ARCHS)))
+ CFLAGS += -DCAPSTONE_HAS_NEO
+ LIBSRC_NEO += $(wildcard arch/NEO/NEO*.c)
+ LIBOBJ_NEO += $(LIBSRC_NEO:%.c=$(OBJDIR)/%.o)
+endif
+
+
LIBOBJ =
LIBOBJ += $(OBJDIR)/cs.o $(OBJDIR)/utils.o $(OBJDIR)/SStream.o $(OBJDIR)/MCInstrDesc.o $(OBJDIR)/MCRegisterInfo.o
-LIBOBJ += $(LIBOBJ_ARM) $(LIBOBJ_ARM64) $(LIBOBJ_M68K) $(LIBOBJ_MIPS) $(LIBOBJ_PPC) $(LIBOBJ_SPARC) $(LIBOBJ_SYSZ) $(LIBOBJ_X86) $(LIBOBJ_XCORE) $(LIBOBJ_TMS320C64X) $(LIBOBJ_M680X) $(LIBOBJ_EVM)
+LIBOBJ += $(LIBOBJ_ARM) $(LIBOBJ_ARM64) $(LIBOBJ_M68K) $(LIBOBJ_MIPS) $(LIBOBJ_PPC) $(LIBOBJ_SPARC) $(LIBOBJ_SYSZ) $(LIBOBJ_X86) $(LIBOBJ_XCORE) $(LIBOBJ_TMS320C64X) $(LIBOBJ_M680X) $(LIBOBJ_EVM) $(LIBOBJ_NEO)
LIBOBJ += $(OBJDIR)/MCInst.o
@@ -379,6 +390,7 @@
$(LIBOBJ_TMS320C64X): $(DEP_TMS320C64X)
$(LIBOBJ_M680X): $(DEP_M680X)
$(LIBOBJ_EVM): $(DEP_EVM)
+$(LIBOBJ_NEO): $(DEP_NEO)
ifeq ($(CAPSTONE_STATIC),yes)
$(ARCHIVE): $(LIBOBJ)
diff --git a/README.md b/README.md
index e25acef..c13acad 100644
--- a/README.md
+++ b/README.md
@@ -11,7 +11,7 @@
Capstone offers some unparalleled features:
- Support multiple hardware architectures: ARM, ARM64 (ARMv8), Ethereum VM, M68K,
- Mips, PPC, Sparc, SystemZ, TMS320C64X, M680X, XCore and X86 (including X86_64).
+ Mips, NEO VM, PPC, Sparc, SystemZ, TMS320C64X, M680X, XCore and X86.
- Having clean/simple/lightweight/intuitive architecture-neutral API.
diff --git a/arch/NEO/NEODisassembler.c b/arch/NEO/NEODisassembler.c
new file mode 100644
index 0000000..0e90c70
--- /dev/null
+++ b/arch/NEO/NEODisassembler.c
@@ -0,0 +1,340 @@
+/* Capstone Disassembly Engine */
+/* By Nguyen Anh Quynh, 2018 */
+
+#include <string.h>
+
+#include "NEODisassembler.h"
+#include "NEOMapping.h"
+
+static short opcodes[256] = {
+ NEO_INS_PUSH0,
+ NEO_INS_PUSHBYTES1,
+ NEO_INS_PUSHBYTES2,
+ NEO_INS_PUSHBYTES3,
+ NEO_INS_PUSHBYTES4,
+ NEO_INS_PUSHBYTES5,
+ NEO_INS_PUSHBYTES6,
+ NEO_INS_PUSHBYTES7,
+ NEO_INS_PUSHBYTES8,
+ NEO_INS_PUSHBYTES9,
+ NEO_INS_PUSHBYTES10,
+ NEO_INS_PUSHBYTES11,
+ NEO_INS_PUSHBYTES12,
+ NEO_INS_PUSHBYTES13,
+ NEO_INS_PUSHBYTES14,
+ NEO_INS_PUSHBYTES15,
+ NEO_INS_PUSHBYTES16,
+ NEO_INS_PUSHBYTES17,
+ NEO_INS_PUSHBYTES18,
+ NEO_INS_PUSHBYTES19,
+ NEO_INS_PUSHBYTES20,
+ NEO_INS_PUSHBYTES21,
+ NEO_INS_PUSHBYTES22,
+ NEO_INS_PUSHBYTES23,
+ NEO_INS_PUSHBYTES24,
+ NEO_INS_PUSHBYTES25,
+ NEO_INS_PUSHBYTES26,
+ NEO_INS_PUSHBYTES27,
+ NEO_INS_PUSHBYTES28,
+ NEO_INS_PUSHBYTES29,
+ NEO_INS_PUSHBYTES30,
+ NEO_INS_PUSHBYTES31,
+ NEO_INS_PUSHBYTES32,
+ NEO_INS_PUSHBYTES33,
+ NEO_INS_PUSHBYTES34,
+ NEO_INS_PUSHBYTES35,
+ NEO_INS_PUSHBYTES36,
+ NEO_INS_PUSHBYTES37,
+ NEO_INS_PUSHBYTES38,
+ NEO_INS_PUSHBYTES39,
+ NEO_INS_PUSHBYTES40,
+ NEO_INS_PUSHBYTES41,
+ NEO_INS_PUSHBYTES42,
+ NEO_INS_PUSHBYTES43,
+ NEO_INS_PUSHBYTES44,
+ NEO_INS_PUSHBYTES45,
+ NEO_INS_PUSHBYTES46,
+ NEO_INS_PUSHBYTES47,
+ NEO_INS_PUSHBYTES48,
+ NEO_INS_PUSHBYTES49,
+ NEO_INS_PUSHBYTES50,
+ NEO_INS_PUSHBYTES51,
+ NEO_INS_PUSHBYTES52,
+ NEO_INS_PUSHBYTES53,
+ NEO_INS_PUSHBYTES54,
+ NEO_INS_PUSHBYTES55,
+ NEO_INS_PUSHBYTES56,
+ NEO_INS_PUSHBYTES57,
+ NEO_INS_PUSHBYTES58,
+ NEO_INS_PUSHBYTES59,
+ NEO_INS_PUSHBYTES60,
+ NEO_INS_PUSHBYTES61,
+ NEO_INS_PUSHBYTES62,
+ NEO_INS_PUSHBYTES63,
+ NEO_INS_PUSHBYTES64,
+ NEO_INS_PUSHBYTES65,
+ NEO_INS_PUSHBYTES66,
+ NEO_INS_PUSHBYTES67,
+ NEO_INS_PUSHBYTES68,
+ NEO_INS_PUSHBYTES69,
+ NEO_INS_PUSHBYTES70,
+ NEO_INS_PUSHBYTES71,
+ NEO_INS_PUSHBYTES72,
+ NEO_INS_PUSHBYTES73,
+ NEO_INS_PUSHBYTES74,
+ NEO_INS_PUSHBYTES75,
+ NEO_INS_PUSHDATA1,
+ NEO_INS_PUSHDATA2,
+ NEO_INS_PUSHDATA4,
+ NEO_INS_PUSHM1,
+ -1,
+ NEO_INS_PUSH1,
+ NEO_INS_PUSH2,
+ NEO_INS_PUSH3,
+ NEO_INS_PUSH4,
+ NEO_INS_PUSH5,
+ NEO_INS_PUSH6,
+ NEO_INS_PUSH7,
+ NEO_INS_PUSH8,
+ NEO_INS_PUSH9,
+ NEO_INS_PUSH10,
+ NEO_INS_PUSH11,
+ NEO_INS_PUSH12,
+ NEO_INS_PUSH13,
+ NEO_INS_PUSH14,
+ NEO_INS_PUSH15,
+ NEO_INS_PUSH16,
+ NEO_INS_NOP,
+ NEO_INS_JMP,
+ NEO_INS_JMPIF,
+ NEO_INS_JMPIFNOT,
+ NEO_INS_CALL,
+ NEO_INS_RET,
+ NEO_INS_APPCALL,
+ NEO_INS_SYSCALL,
+ NEO_INS_TAILCALL,
+ NEO_INS_DUPFROMALTSTACK,
+ NEO_INS_TOALTSTACK,
+ NEO_INS_FROMALTSTACK,
+ NEO_INS_XDROP,
+ -1,
+ -1,
+ -1,
+ -1,
+ NEO_INS_XSWAP,
+ NEO_INS_XTUCK,
+ NEO_INS_DEPTH,
+ NEO_INS_DROP,
+ NEO_INS_DUP,
+ NEO_INS_NIP,
+ NEO_INS_OVER,
+ NEO_INS_PICK,
+ NEO_INS_ROLL,
+ NEO_INS_ROT,
+ NEO_INS_SWAP,
+ NEO_INS_TUCK,
+ NEO_INS_CAT,
+ NEO_INS_SUBSTR,
+ NEO_INS_LEFT,
+ NEO_INS_RIGHT,
+ NEO_INS_SIZE,
+ NEO_INS_INVERT,
+ NEO_INS_AND,
+ NEO_INS_OR,
+ NEO_INS_XOR,
+ NEO_INS_EQUAL,
+ NEO_INS_OP_EQUALVERIFY,
+ NEO_INS_OP_RESERVED1,
+ NEO_INS_OP_RESERVED2,
+ NEO_INS_INC,
+ NEO_INS_DEC,
+ NEO_INS_SIGN,
+ -1,
+ NEO_INS_NEGATE,
+ NEO_INS_ABS,
+ NEO_INS_NOT,
+ NEO_INS_NZ,
+ NEO_INS_ADD,
+ NEO_INS_SUB,
+ NEO_INS_MUL,
+ NEO_INS_DIV,
+ NEO_INS_MOD,
+ NEO_INS_SHL,
+ NEO_INS_SHR,
+ NEO_INS_BOOLAND,
+ NEO_INS_BOOLOR,
+ NEO_INS_NUMEQUAL,
+ -1,
+ NEO_INS_NUMNOTEQUAL,
+ NEO_INS_LT,
+ NEO_INS_GT,
+ NEO_INS_LTE,
+ NEO_INS_GTE,
+ NEO_INS_MIN,
+ NEO_INS_MAX,
+ NEO_INS_WITHIN,
+ -1,
+ NEO_INS_SHA1,
+ NEO_INS_SHA256,
+ NEO_INS_HASH160,
+ NEO_INS_HASH256,
+ -1,
+ NEO_INS_CHECKSIG,
+ NEO_INS_VERIFY,
+ NEO_INS_CHECKMULTISIG,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ NEO_INS_ARRAYSIZE,
+ NEO_INS_PACK,
+ NEO_INS_UNPACK,
+ NEO_INS_PICKITEM,
+ NEO_INS_SETITEM,
+ NEO_INS_NEWARRAY,
+ NEO_INS_NEWSTRUCT,
+ NEO_INS_NEWMAP,
+ NEO_INS_APPEND,
+ NEO_INS_REVERSE,
+ NEO_INS_REMOVE,
+ NEO_INS_HASKEY,
+ NEO_INS_KEYS,
+ NEO_INS_VALUES,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ NEO_INS_THROW,
+ NEO_INS_THROWIFNOT,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+ -1,
+};
+
+bool NEO_getInstruction(csh ud, const uint8_t *code, size_t code_len,
+ MCInst *MI, uint16_t *size, uint64_t address, void *inst_info)
+{
+ unsigned char opcode;
+
+ if (code_len == 0)
+ return false;
+
+ opcode = code[0];
+ if (opcodes[opcode] == -1) {
+ // invalid opcode
+ return false;
+ }
+
+ // valid opcode
+ MI->address = address;
+ MI->OpcodePub = MI->Opcode = opcode;
+
+ *size = neo_insn_opsize(opcode) + 1;
+ if (*size > 1) {
+ if (code_len < *size) {
+ // not enough data
+ return false;
+ }
+
+ // copy operand
+ memcpy(MI->neo_data, code + 1, *size - 1);
+ }
+
+ if (MI->flat_insn->detail) {
+ memset(&MI->flat_insn->detail->neo, 0, sizeof(cs_neo));
+ NEO_get_insn_id((cs_struct *)ud, MI->flat_insn, opcode);
+
+ MI->flat_insn->detail->regs_read_count = 0;
+ MI->flat_insn->detail->regs_write_count = 0;
+ MI->flat_insn->detail->groups_count = 0;
+
+ if (MI->flat_insn->detail->neo.pop) {
+ MI->flat_insn->detail->groups[MI->flat_insn->detail->groups_count] = NEO_GRP_STACK_READ;
+ MI->flat_insn->detail->groups_count++;
+ }
+
+ if (MI->flat_insn->detail->neo.push) {
+ MI->flat_insn->detail->groups[MI->flat_insn->detail->groups_count] = NEO_GRP_STACK_WRITE;
+ MI->flat_insn->detail->groups_count++;
+ }
+
+ // setup groups
+#if 0
+ switch(opcode) {
+ default:
+ break;
+ case NEO_INS_ADD:
+ case NEO_INS_MUL:
+ MI->flat_insn->detail->groups[MI->flat_insn->detail->groups_count] = NEO_GRP_MATH;
+ MI->flat_insn->detail->groups_count++;
+ break;
+
+ case NEO_INS_MSTORE:
+ case NEO_INS_MSTORE8:
+ case NEO_INS_CALLDATACOPY:
+ case NEO_INS_CODECOPY:
+ case NEO_INS_EXTCODECOPY:
+ MI->flat_insn->detail->groups[MI->flat_insn->detail->groups_count] = NEO_GRP_MEM_WRITE;
+ MI->flat_insn->detail->groups_count++;
+ break;
+
+ }
+#endif
+ }
+
+ return true;
+}
diff --git a/arch/NEO/NEODisassembler.h b/arch/NEO/NEODisassembler.h
new file mode 100644
index 0000000..a05a50e
--- /dev/null
+++ b/arch/NEO/NEODisassembler.h
@@ -0,0 +1,12 @@
+/* Capstone Disassembly Engine */
+/* By Nguyen Anh Quynh, 2018 */
+
+#ifndef CS_NEODISASSEMBLER_H
+#define CS_NEODISASSEMBLER_H
+
+#include "../../MCInst.h"
+
+bool NEO_getInstruction(csh ud, const uint8_t *code, size_t code_len,
+ MCInst *instr, uint16_t *size, uint64_t address, void *info);
+
+#endif
diff --git a/arch/NEO/NEOInstPrinter.c b/arch/NEO/NEOInstPrinter.c
new file mode 100644
index 0000000..0b8283d
--- /dev/null
+++ b/arch/NEO/NEOInstPrinter.c
@@ -0,0 +1,25 @@
+/* Capstone Disassembly Engine */
+/* By Nguyen Anh Quynh, 2018 */
+
+#include "NEOInstPrinter.h"
+#include "NEOMapping.h"
+
+
+void NEO_printInst(MCInst *MI, struct SStream *O, void *PrinterInfo)
+{
+ int opsize;
+
+ // print mnemonic
+ SStream_concat(O, NEO_insn_name((csh)MI->csh, MI->Opcode));
+
+ opsize = neo_insn_opsize(MI->Opcode);
+ if (opsize) {
+ // print operand
+ unsigned int i;
+
+ SStream_concat0(O, "\t");
+ for (i = 0; i < opsize; i++) {
+ SStream_concat(O, "%02x", MI->neo_data[i]);
+ }
+ }
+}
diff --git a/arch/NEO/NEOInstPrinter.h b/arch/NEO/NEOInstPrinter.h
new file mode 100644
index 0000000..6034995
--- /dev/null
+++ b/arch/NEO/NEOInstPrinter.h
@@ -0,0 +1,17 @@
+/* Capstone Disassembly Engine */
+/* By Nguyen Anh Quynh, 2018 */
+
+#ifndef CS_NEOINSTPRINTER_H
+#define CS_NEOINSTPRINTER_H
+
+
+#include "capstone/capstone.h"
+#include "../../MCInst.h"
+#include "../../SStream.h"
+#include "../../cs_priv.h"
+
+struct SStream;
+
+void NEO_printInst(MCInst *MI, struct SStream *O, void *Info);
+
+#endif
diff --git a/arch/NEO/NEOMapping.c b/arch/NEO/NEOMapping.c
new file mode 100644
index 0000000..21c46ba
--- /dev/null
+++ b/arch/NEO/NEOMapping.c
@@ -0,0 +1,339 @@
+/* Capstone Disassembly Engine */
+/* By Nguyen Anh Quynh, 2018 */
+
+#ifdef CAPSTONE_HAS_NEO
+
+#include <string.h>
+
+#include "../../cs_priv.h"
+#include "../../utils.h"
+
+#include "NEOMapping.h"
+
+#ifndef CAPSTONE_DIET
+static cs_neo insns[256] = {
+#include "NEOMappingInsn.inc"
+};
+#endif
+
+// look for opsize of @id in @insns, given its size in @max.
+// return -1 if not found
+int neo_insn_opsize(unsigned int id)
+{
+ if (id >= 256)
+ return -1;
+
+ if (insns[id].fee == 255)
+ // unused opcode
+ return -1;
+
+ return insns[id].op_size;
+}
+
+// fill in details
+void NEO_get_insn_id(cs_struct *h, cs_insn *insn, unsigned int id)
+{
+ insn->id = id;
+#ifndef CAPSTONE_DIET
+ if (id < 256 && insns[id].fee != 255) {
+ if (h->detail) {
+ memcpy(&insn->detail->neo, &insns[id], sizeof(insns[id]));
+ }
+ }
+#endif
+}
+
+#ifndef CAPSTONE_DIET
+static name_map insn_name_maps[] = {
+ { NEO_INS_PUSH0, "push0" },
+ { NEO_INS_PUSHBYTES1, "pushbytes1" },
+ { NEO_INS_PUSHBYTES2, "pushbytes2" },
+ { NEO_INS_PUSHBYTES3, "pushbytes3" },
+ { NEO_INS_PUSHBYTES4, "pushbytes4" },
+ { NEO_INS_PUSHBYTES5, "pushbytes5" },
+ { NEO_INS_PUSHBYTES6, "pushbytes6" },
+ { NEO_INS_PUSHBYTES7, "pushbytes7" },
+ { NEO_INS_PUSHBYTES8, "pushbytes8" },
+ { NEO_INS_PUSHBYTES9, "pushbytes9" },
+ { NEO_INS_PUSHBYTES10, "pushbytes10" },
+ { NEO_INS_PUSHBYTES11, "pushbytes11" },
+ { NEO_INS_PUSHBYTES12, "pushbytes12" },
+ { NEO_INS_PUSHBYTES13, "pushbytes13" },
+ { NEO_INS_PUSHBYTES14, "pushbytes14" },
+ { NEO_INS_PUSHBYTES15, "pushbytes15" },
+ { NEO_INS_PUSHBYTES16, "pushbytes16" },
+ { NEO_INS_PUSHBYTES17, "pushbytes17" },
+ { NEO_INS_PUSHBYTES18, "pushbytes18" },
+ { NEO_INS_PUSHBYTES19, "pushbytes19" },
+ { NEO_INS_PUSHBYTES20, "pushbytes20" },
+ { NEO_INS_PUSHBYTES21, "pushbytes21" },
+ { NEO_INS_PUSHBYTES22, "pushbytes22" },
+ { NEO_INS_PUSHBYTES23, "pushbytes23" },
+ { NEO_INS_PUSHBYTES24, "pushbytes24" },
+ { NEO_INS_PUSHBYTES25, "pushbytes25" },
+ { NEO_INS_PUSHBYTES26, "pushbytes26" },
+ { NEO_INS_PUSHBYTES27, "pushbytes27" },
+ { NEO_INS_PUSHBYTES28, "pushbytes28" },
+ { NEO_INS_PUSHBYTES29, "pushbytes29" },
+ { NEO_INS_PUSHBYTES30, "pushbytes30" },
+ { NEO_INS_PUSHBYTES31, "pushbytes31" },
+ { NEO_INS_PUSHBYTES32, "pushbytes32" },
+ { NEO_INS_PUSHBYTES33, "pushbytes33" },
+ { NEO_INS_PUSHBYTES34, "pushbytes34" },
+ { NEO_INS_PUSHBYTES35, "pushbytes35" },
+ { NEO_INS_PUSHBYTES36, "pushbytes36" },
+ { NEO_INS_PUSHBYTES37, "pushbytes37" },
+ { NEO_INS_PUSHBYTES38, "pushbytes38" },
+ { NEO_INS_PUSHBYTES39, "pushbytes39" },
+ { NEO_INS_PUSHBYTES40, "pushbytes40" },
+ { NEO_INS_PUSHBYTES41, "pushbytes41" },
+ { NEO_INS_PUSHBYTES42, "pushbytes42" },
+ { NEO_INS_PUSHBYTES43, "pushbytes43" },
+ { NEO_INS_PUSHBYTES44, "pushbytes44" },
+ { NEO_INS_PUSHBYTES45, "pushbytes45" },
+ { NEO_INS_PUSHBYTES46, "pushbytes46" },
+ { NEO_INS_PUSHBYTES47, "pushbytes47" },
+ { NEO_INS_PUSHBYTES48, "pushbytes48" },
+ { NEO_INS_PUSHBYTES49, "pushbytes49" },
+ { NEO_INS_PUSHBYTES50, "pushbytes50" },
+ { NEO_INS_PUSHBYTES51, "pushbytes51" },
+ { NEO_INS_PUSHBYTES52, "pushbytes52" },
+ { NEO_INS_PUSHBYTES53, "pushbytes53" },
+ { NEO_INS_PUSHBYTES54, "pushbytes54" },
+ { NEO_INS_PUSHBYTES55, "pushbytes55" },
+ { NEO_INS_PUSHBYTES56, "pushbytes56" },
+ { NEO_INS_PUSHBYTES57, "pushbytes57" },
+ { NEO_INS_PUSHBYTES58, "pushbytes58" },
+ { NEO_INS_PUSHBYTES59, "pushbytes59" },
+ { NEO_INS_PUSHBYTES60, "pushbytes60" },
+ { NEO_INS_PUSHBYTES61, "pushbytes61" },
+ { NEO_INS_PUSHBYTES62, "pushbytes62" },
+ { NEO_INS_PUSHBYTES63, "pushbytes63" },
+ { NEO_INS_PUSHBYTES64, "pushbytes64" },
+ { NEO_INS_PUSHBYTES65, "pushbytes65" },
+ { NEO_INS_PUSHBYTES66, "pushbytes66" },
+ { NEO_INS_PUSHBYTES67, "pushbytes67" },
+ { NEO_INS_PUSHBYTES68, "pushbytes68" },
+ { NEO_INS_PUSHBYTES69, "pushbytes69" },
+ { NEO_INS_PUSHBYTES70, "pushbytes70" },
+ { NEO_INS_PUSHBYTES71, "pushbytes71" },
+ { NEO_INS_PUSHBYTES72, "pushbytes72" },
+ { NEO_INS_PUSHBYTES73, "pushbytes73" },
+ { NEO_INS_PUSHBYTES74, "pushbytes74" },
+ { NEO_INS_PUSHBYTES75, "pushbytes75" },
+ { NEO_INS_PUSHDATA1, "pushdata1" },
+ { NEO_INS_PUSHDATA2, "pushdata2" },
+ { NEO_INS_PUSHDATA4, "pushdata4" },
+ { NEO_INS_PUSHM1, "pushm1" },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_PUSH1, "push1" },
+ { NEO_INS_PUSH2, "push2" },
+ { NEO_INS_PUSH3, "push3" },
+ { NEO_INS_PUSH4, "push4" },
+ { NEO_INS_PUSH5, "push5" },
+ { NEO_INS_PUSH6, "push6" },
+ { NEO_INS_PUSH7, "push7" },
+ { NEO_INS_PUSH8, "push8" },
+ { NEO_INS_PUSH9, "push9" },
+ { NEO_INS_PUSH10, "push10" },
+ { NEO_INS_PUSH11, "push11" },
+ { NEO_INS_PUSH12, "push12" },
+ { NEO_INS_PUSH13, "push13" },
+ { NEO_INS_PUSH14, "push14" },
+ { NEO_INS_PUSH15, "push15" },
+ { NEO_INS_PUSH16, "push16" },
+ { NEO_INS_NOP, "nop" },
+ { NEO_INS_JMP, "jmp" },
+ { NEO_INS_JMPIF, "jmpif" },
+ { NEO_INS_JMPIFNOT, "jmpifnot" },
+ { NEO_INS_CALL, "call" },
+ { NEO_INS_RET, "ret" },
+ { NEO_INS_APPCALL, "appcall" },
+ { NEO_INS_SYSCALL, "syscall" },
+ { NEO_INS_TAILCALL, "tailcall" },
+ { NEO_INS_DUPFROMALTSTACK, "dupfromaltstack" },
+ { NEO_INS_TOALTSTACK, "toaltstack" },
+ { NEO_INS_FROMALTSTACK, "fromaltstack" },
+ { NEO_INS_XDROP, "xdrop" },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_XSWAP, "xswap" },
+ { NEO_INS_XTUCK, "xtuck" },
+ { NEO_INS_DEPTH, "depth" },
+ { NEO_INS_DROP, "drop" },
+ { NEO_INS_DUP, "dup" },
+ { NEO_INS_NIP, "nip" },
+ { NEO_INS_OVER, "over" },
+ { NEO_INS_PICK, "pick" },
+ { NEO_INS_ROLL, "roll" },
+ { NEO_INS_ROT, "rot" },
+ { NEO_INS_SWAP, "swap" },
+ { NEO_INS_TUCK, "tuck" },
+ { NEO_INS_CAT, "cat" },
+ { NEO_INS_SUBSTR, "substr" },
+ { NEO_INS_LEFT, "left" },
+ { NEO_INS_RIGHT, "right" },
+ { NEO_INS_SIZE, "size" },
+ { NEO_INS_INVERT, "invert" },
+ { NEO_INS_AND, "and" },
+ { NEO_INS_OR, "or" },
+ { NEO_INS_XOR, "xor" },
+ { NEO_INS_EQUAL, "equal" },
+ { NEO_INS_OP_EQUALVERIFY, "op_equalverify" },
+ { NEO_INS_OP_RESERVED1, "op_reserved1" },
+ { NEO_INS_OP_RESERVED2, "op_reserved2" },
+ { NEO_INS_INC, "inc" },
+ { NEO_INS_DEC, "dec" },
+ { NEO_INS_SIGN, "sign" },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_NEGATE, "negate" },
+ { NEO_INS_ABS, "abs" },
+ { NEO_INS_NOT, "not" },
+ { NEO_INS_NZ, "nz" },
+ { NEO_INS_ADD, "add" },
+ { NEO_INS_SUB, "sub" },
+ { NEO_INS_MUL, "mul" },
+ { NEO_INS_DIV, "div" },
+ { NEO_INS_MOD, "mod" },
+ { NEO_INS_SHL, "shl" },
+ { NEO_INS_SHR, "shr" },
+ { NEO_INS_BOOLAND, "booland" },
+ { NEO_INS_BOOLOR, "boolor" },
+ { NEO_INS_NUMEQUAL, "numequal" },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_NUMNOTEQUAL, "numnotequal" },
+ { NEO_INS_LT, "lt" },
+ { NEO_INS_GT, "gt" },
+ { NEO_INS_LTE, "lte" },
+ { NEO_INS_GTE, "gte" },
+ { NEO_INS_MIN, "min" },
+ { NEO_INS_MAX, "max" },
+ { NEO_INS_WITHIN, "within" },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_SHA1, "sha1" },
+ { NEO_INS_SHA256, "sha256" },
+ { NEO_INS_HASH160, "hash160" },
+ { NEO_INS_HASH256, "hash256" },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_CHECKSIG, "checksig" },
+ { NEO_INS_VERIFY, "verify" },
+ { NEO_INS_CHECKMULTISIG, "checkmultisig" },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_ARRAYSIZE, "arraysize" },
+ { NEO_INS_PACK, "pack" },
+ { NEO_INS_UNPACK, "unpack" },
+ { NEO_INS_PICKITEM, "pickitem" },
+ { NEO_INS_SETITEM, "setitem" },
+ { NEO_INS_NEWARRAY, "newarray" },
+ { NEO_INS_NEWSTRUCT, "newstruct" },
+ { NEO_INS_NEWMAP, "newmap" },
+ { NEO_INS_APPEND, "append" },
+ { NEO_INS_REVERSE, "reverse" },
+ { NEO_INS_REMOVE, "remove" },
+ { NEO_INS_HASKEY, "haskey" },
+ { NEO_INS_KEYS, "keys" },
+ { NEO_INS_VALUES, "values" },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_THROW, "throw" },
+ { NEO_INS_THROWIFNOT, "throwifnot" },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_INVALID, NULL },
+ { NEO_INS_INVALID, NULL },
+};
+#endif
+
+const char *NEO_insn_name(csh handle, unsigned int id)
+{
+#ifndef CAPSTONE_DIET
+ if (id >= ARR_SIZE(insn_name_maps))
+ return NULL;
+ else
+ return insn_name_maps[id].name;
+#else
+ return NULL;
+#endif
+}
+
+#ifndef CAPSTONE_DIET
+static name_map group_name_maps[] = {
+ // generic groups
+ { NEO_GRP_INVALID, NULL },
+ { NEO_GRP_JUMP, "jump" },
+ // special groups
+ { NEO_GRP_MATH, "math" },
+ { NEO_GRP_STACK_WRITE, "stack_write" },
+ { NEO_GRP_STACK_READ, "stack_read" },
+};
+#endif
+
+const char *NEO_group_name(csh handle, unsigned int id)
+{
+#ifndef CAPSTONE_DIET
+ return id2name(group_name_maps, ARR_SIZE(group_name_maps), id);
+#else
+ return NULL;
+#endif
+}
+#endif
diff --git a/arch/NEO/NEOMapping.h b/arch/NEO/NEOMapping.h
new file mode 100644
index 0000000..8d780f2
--- /dev/null
+++ b/arch/NEO/NEOMapping.h
@@ -0,0 +1,9 @@
+/* Capstone Disassembly Engine */
+/* By Nguyen Anh Quynh, 2018 */
+
+#include <capstone/capstone.h>
+
+void NEO_get_insn_id(cs_struct *h, cs_insn *insn, unsigned int id);
+const char *NEO_insn_name(csh handle, unsigned int id);
+const char *NEO_group_name(csh handle, unsigned int id);
+int neo_insn_opsize(unsigned int id);
diff --git a/arch/NEO/NEOMappingInsn.inc b/arch/NEO/NEOMappingInsn.inc
new file mode 100644
index 0000000..80398b3
--- /dev/null
+++ b/arch/NEO/NEOMappingInsn.inc
@@ -0,0 +1,259 @@
+/* Capstone Disassembly Engine */
+/* By Nguyen Anh Quynh, 2018 */
+
+{ 0, 0, 1, NEO_FEE_0 },
+{ 1, 0, 1, NEO_FEE_0 },
+{ 2, 0, 2, NEO_FEE_0 },
+{ 3, 0, 3, NEO_FEE_0 },
+{ 4, 0, 4, NEO_FEE_0 },
+{ 5, 0, 5, NEO_FEE_0 },
+{ 6, 0, 6, NEO_FEE_0 },
+{ 7, 0, 7, NEO_FEE_0 },
+{ 8, 0, 8, NEO_FEE_0 },
+{ 9, 0, 9, NEO_FEE_0 },
+{ 10, 0, 10, NEO_FEE_0 },
+{ 11, 0, 11, NEO_FEE_0 },
+{ 12, 0, 12, NEO_FEE_0 },
+{ 13, 0, 13, NEO_FEE_0 },
+{ 14, 0, 14, NEO_FEE_0 },
+{ 15, 0, 15, NEO_FEE_0 },
+{ 16, 0, 16, NEO_FEE_0 },
+{ 17, 0, 17, NEO_FEE_0 },
+{ 18, 0, 18, NEO_FEE_0 },
+{ 19, 0, 19, NEO_FEE_0 },
+{ 20, 0, 20, NEO_FEE_0 },
+{ 21, 0, 21, NEO_FEE_0 },
+{ 22, 0, 22, NEO_FEE_0 },
+{ 23, 0, 23, NEO_FEE_0 },
+{ 24, 0, 24, NEO_FEE_0 },
+{ 25, 0, 25, NEO_FEE_0 },
+{ 26, 0, 26, NEO_FEE_0 },
+{ 27, 0, 27, NEO_FEE_0 },
+{ 28, 0, 28, NEO_FEE_0 },
+{ 29, 0, 29, NEO_FEE_0 },
+{ 30, 0, 30, NEO_FEE_0 },
+{ 31, 0, 31, NEO_FEE_0 },
+{ 32, 0, 32, NEO_FEE_0 },
+{ 33, 0, 33, NEO_FEE_0 },
+{ 34, 0, 34, NEO_FEE_0 },
+{ 35, 0, 35, NEO_FEE_0 },
+{ 36, 0, 36, NEO_FEE_0 },
+{ 37, 0, 37, NEO_FEE_0 },
+{ 38, 0, 38, NEO_FEE_0 },
+{ 39, 0, 39, NEO_FEE_0 },
+{ 40, 0, 40, NEO_FEE_0 },
+{ 41, 0, 41, NEO_FEE_0 },
+{ 42, 0, 42, NEO_FEE_0 },
+{ 43, 0, 43, NEO_FEE_0 },
+{ 44, 0, 44, NEO_FEE_0 },
+{ 45, 0, 45, NEO_FEE_0 },
+{ 46, 0, 46, NEO_FEE_0 },
+{ 47, 0, 47, NEO_FEE_0 },
+{ 48, 0, 48, NEO_FEE_0 },
+{ 49, 0, 49, NEO_FEE_0 },
+{ 50, 0, 50, NEO_FEE_0 },
+{ 51, 0, 51, NEO_FEE_0 },
+{ 52, 0, 52, NEO_FEE_0 },
+{ 53, 0, 53, NEO_FEE_0 },
+{ 54, 0, 54, NEO_FEE_0 },
+{ 55, 0, 55, NEO_FEE_0 },
+{ 56, 0, 56, NEO_FEE_0 },
+{ 57, 0, 57, NEO_FEE_0 },
+{ 58, 0, 58, NEO_FEE_0 },
+{ 59, 0, 59, NEO_FEE_0 },
+{ 60, 0, 60, NEO_FEE_0 },
+{ 61, 0, 61, NEO_FEE_0 },
+{ 62, 0, 62, NEO_FEE_0 },
+{ 63, 0, 63, NEO_FEE_0 },
+{ 64, 0, 64, NEO_FEE_0 },
+{ 65, 0, 65, NEO_FEE_0 },
+{ 66, 0, 66, NEO_FEE_0 },
+{ 67, 0, 67, NEO_FEE_0 },
+{ 68, 0, 68, NEO_FEE_0 },
+{ 69, 0, 69, NEO_FEE_0 },
+{ 70, 0, 70, NEO_FEE_0 },
+{ 71, 0, 71, NEO_FEE_0 },
+{ 72, 0, 72, NEO_FEE_0 },
+{ 73, 0, 73, NEO_FEE_0 },
+{ 74, 0, 74, NEO_FEE_0 },
+{ 75, 0, 75, NEO_FEE_0 },
+{ 1, 0, 1, NEO_FEE_0 },
+{ 2, 0, 2, NEO_FEE_0 },
+{ 4, 0, 4, NEO_FEE_0 },
+{ 0, 0, 1, NEO_FEE_0 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 1, NEO_FEE_0 },
+{ 0, 0, 1, NEO_FEE_0 },
+{ 0, 0, 1, NEO_FEE_0 },
+{ 0, 0, 1, NEO_FEE_0 },
+{ 0, 0, 1, NEO_FEE_0 },
+{ 0, 0, 1, NEO_FEE_0 },
+{ 0, 0, 1, NEO_FEE_0 },
+{ 0, 0, 1, NEO_FEE_0 },
+{ 0, 0, 1, NEO_FEE_0 },
+{ 0, 0, 1, NEO_FEE_0 },
+{ 0, 0, 1, NEO_FEE_0 },
+{ 0, 0, 1, NEO_FEE_0 },
+{ 0, 0, 1, NEO_FEE_0 },
+{ 0, 0, 1, NEO_FEE_0 },
+{ 0, 0, 1, NEO_FEE_0 },
+{ 0, 0, 1, NEO_FEE_0 },
+{ 0, 0, 0, NEO_FEE_0 },
+{ 2, 0, 0, NEO_FEE_0001 },
+{ 2, 1, 0, NEO_FEE_0001 },
+{ 2, 1, 0, NEO_FEE_0001 },
+{ 2, 0, 0, NEO_FEE_0001 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 32, 0, 0, NEO_FEE_001 },
+{ 1, 0, 0, NEO_FEE_0001 },
+{ 32, 0, 0, NEO_FEE_001 },
+{ 0, 0, 1, NEO_FEE_0001 },
+{ 0, 1, 1, NEO_FEE_0001 },
+{ 0, 1, 1, NEO_FEE_0001 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 1, 0, NEO_FEE_0001 },
+{ 0, 1, 1, NEO_FEE_0001 },
+{ 0, 0, 1, NEO_FEE_0001 },
+{ 0, 1, 0, NEO_FEE_0001 },
+{ 0, 0, 1, NEO_FEE_0001 },
+{ 0, 2, 1, NEO_FEE_0001 },
+{ 0, 1, 2, NEO_FEE_0001 },
+{ 0, 1, 1, NEO_FEE_0001 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 3, 3, NEO_FEE_0001 },
+{ 0, 2, 2, NEO_FEE_0001 },
+{ 0, 2, 3, NEO_FEE_0001 },
+{ 0, 2, 1, NEO_FEE_0001 },
+{ 0, 3, 1, NEO_FEE_0001 },
+{ 0, 2, 1, NEO_FEE_0001 },
+{ 0, 2, 1, NEO_FEE_0001 },
+{ 0, 1, 1, NEO_FEE_0001 },
+{ 0, 1, 1, NEO_FEE_0001 },
+{ 0, 2, 1, NEO_FEE_0001 },
+{ 0, 2, 1, NEO_FEE_0001 },
+{ 0, 2, 1, NEO_FEE_0001 },
+{ 0, 2, 1, NEO_FEE_0001 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 1, 1, NEO_FEE_0001 },
+{ 0, 1, 1, NEO_FEE_0001 },
+{ 0, 1, 1, NEO_FEE_0001 },
+{ 0, 0, 0, 255 },
+{ 0, 1, 1, NEO_FEE_0001 },
+{ 0, 1, 1, NEO_FEE_0001 },
+{ 0, 1, 1, NEO_FEE_0001 },
+{ 0, 1, 1, NEO_FEE_0001 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, NEO_FEE_001 },
+{ 0, 0, 0, NEO_FEE_001 },
+{ 0, 0, 0, NEO_FEE_002 },
+{ 0, 0, 0, NEO_FEE_002 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, NEO_FEE_01 },
+{ 0, 0, 0, NEO_FEE_01 },
+{ 0, 0, 0, NEO_FEE_01 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, NEO_FEE_0001 },
+{ 0, 1, 0, NEO_FEE_0001 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
+{ 0, 0, 0, 255 },
diff --git a/arch/NEO/NEOModule.c b/arch/NEO/NEOModule.c
new file mode 100644
index 0000000..95a2009
--- /dev/null
+++ b/arch/NEO/NEOModule.c
@@ -0,0 +1,33 @@
+/* Capstone Disassembly Engine */
+/* By Nguyen Anh Quynh, 2018 */
+
+#ifdef CAPSTONE_HAS_NEO
+
+#include "../../cs_priv.h"
+#include "NEODisassembler.h"
+#include "NEOInstPrinter.h"
+#include "NEOMapping.h"
+#include "NEOModule.h"
+
+cs_err NEO_global_init(cs_struct *ud)
+{
+ // verify if requested mode is valid
+ if (ud->mode)
+ return CS_ERR_MODE;
+
+ ud->printer = NEO_printInst;
+ ud->printer_info = NULL;
+ ud->insn_id = NEO_get_insn_id;
+ ud->insn_name = NEO_insn_name;
+ ud->group_name = NEO_group_name;
+ ud->disasm = NEO_getInstruction;
+
+ return CS_ERR_OK;
+}
+
+cs_err NEO_option(cs_struct *handle, cs_opt_type type, size_t value)
+{
+ return CS_ERR_OK;
+}
+
+#endif
diff --git a/arch/NEO/NEOModule.h b/arch/NEO/NEOModule.h
new file mode 100644
index 0000000..f552f50
--- /dev/null
+++ b/arch/NEO/NEOModule.h
@@ -0,0 +1,12 @@
+/* Capstone Disassembly Engine */
+/* By Travis Finkenauer <tmfinken@gmail.com>, 2018 */
+
+#ifndef CS_NEO_MODULE_H
+#define CS_NEO_MODULE_H
+
+#include "../../utils.h"
+
+cs_err NEO_global_init(cs_struct *ud);
+cs_err NEO_option(cs_struct *handle, cs_opt_type type, size_t value);
+
+#endif
diff --git a/config.mk b/config.mk
index 3b078a7..12bb00e 100644
--- a/config.mk
+++ b/config.mk
@@ -4,7 +4,7 @@
################################################################################
# Specify which archs you want to compile in. By default, we build all archs.
-CAPSTONE_ARCHS ?= arm aarch64 m68k mips powerpc sparc systemz x86 xcore tms320c64x m680x evm
+CAPSTONE_ARCHS ?= arm aarch64 m68k mips powerpc sparc systemz x86 xcore tms320c64x m680x evm neo
################################################################################
diff --git a/cs.c b/cs.c
index d2ffecc..4f20d13 100644
--- a/cs.c
+++ b/cs.c
@@ -58,6 +58,7 @@
#include "arch/M680X/M680XModule.h"
#include "arch/M68K/M68KModule.h"
#include "arch/Mips/MipsModule.h"
+#include "arch/NEO/NEOModule.h"
#include "arch/PowerPC/PPCModule.h"
#include "arch/Sparc/SparcModule.h"
#include "arch/SystemZ/SystemZModule.h"
@@ -127,6 +128,11 @@
#else
NULL,
#endif
+#ifdef CAPSTONE_HAS_NEO
+ NEO_global_init,
+#else
+ NULL,
+#endif
};
// support cs_option() for all archs
@@ -191,6 +197,11 @@
#else
NULL,
#endif
+#ifdef CAPSTONE_HAS_NEO
+ NEO_option,
+#else
+ NULL,
+#endif
};
// bitmask for finding disallowed modes for an arch:
@@ -263,6 +274,11 @@
#else
0,
#endif
+#ifdef CAPSTONE_HAS_NEO
+ 0,
+#else
+ 0,
+#endif
};
// bitmask of enabled architectures
@@ -303,6 +319,9 @@
#ifdef CAPSTONE_HAS_EVM
| (1 << CS_ARCH_EVM)
#endif
+#ifdef CAPSTONE_HAS_NEO
+ | (1 << CS_ARCH_NEO)
+#endif
;
@@ -375,7 +394,8 @@
(1 << CS_ARCH_PPC) | (1 << CS_ARCH_SPARC) |
(1 << CS_ARCH_SYSZ) | (1 << CS_ARCH_XCORE) |
(1 << CS_ARCH_M68K) | (1 << CS_ARCH_TMS320C64X) |
- (1 << CS_ARCH_M680X) | (1 << CS_ARCH_EVM));
+ (1 << CS_ARCH_M680X) | (1 << CS_ARCH_EVM) |
+ (1 << CS_ARCH_NEO));
if ((unsigned int)query < CS_ARCH_MAX)
return all_arch & (1 << query);
@@ -641,6 +661,9 @@
case CS_ARCH_EVM:
// EVM alignment is 1.
return 1;
+ case CS_ARCH_NEO:
+ // NEO alignment is 1.
+ return 1;
}
}
@@ -1359,6 +1382,13 @@
count++;
#endif
break;
+ case CS_ARCH_NEO:
+#if 0
+ for (i = 0; i < insn->detail->neo.op_count; i++)
+ if (insn->detail->neo.operands[i].type == (neo_op_type)op_type)
+ count++;
+#endif
+ break;
}
return count;
@@ -1494,6 +1524,16 @@
}
#endif
break;
+ case CS_ARCH_NEO:
+#if 0
+ for (i = 0; i < insn->detail->neo.op_count; i++) {
+ if (insn->detail->neo.operands[i].type == (neo_op_type)op_type)
+ count++;
+ if (count == post)
+ return i;
+ }
+#endif
+ break;
}
return -1;
diff --git a/cstool/cstool.c b/cstool/cstool.c
index cd3483e..835e3fe 100644
--- a/cstool/cstool.c
+++ b/cstool/cstool.c
@@ -56,6 +56,7 @@
{ "hd6309", CS_ARCH_M680X, CS_MODE_M680X_6309 },
{ "hcs08", CS_ARCH_M680X, CS_MODE_M680X_HCS08 },
{ "evm", CS_ARCH_EVM, 0 },
+ { "neo", CS_ARCH_NEO, 0 },
{ NULL }
};
@@ -71,6 +72,7 @@
void print_insn_detail_tms320c64x(csh handle, cs_insn *ins);
void print_insn_detail_m680x(csh handle, cs_insn *ins);
void print_insn_detail_evm(csh handle, cs_insn *ins);
+void print_insn_detail_neo(csh handle, cs_insn *ins);
static void print_details(csh handle, cs_arch arch, cs_mode md, cs_insn *ins);
@@ -208,6 +210,10 @@
printf(" evm: Ethereum Virtual Machine\n");
}
+ if (cs_support(CS_ARCH_NEO)) {
+ printf(" neo: NEO Virtual Machine\n");
+ }
+
printf("\nExtra options:\n");
printf(" -d show detailed information of the instructions\n");
printf(" -u show immediates as unsigned\n\n");
@@ -252,6 +258,9 @@
case CS_ARCH_EVM:
print_insn_detail_evm(handle, ins);
break;
+ case CS_ARCH_NEO:
+ print_insn_detail_neo(handle, ins);
+ break;
default: break;
}
diff --git a/cstool/cstool_neo.c b/cstool/cstool_neo.c
new file mode 100644
index 0000000..9943fea
--- /dev/null
+++ b/cstool/cstool_neo.c
@@ -0,0 +1,46 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <capstone/capstone.h>
+
+void print_string_hex(char *comment, unsigned char *str, size_t len);
+
+void print_insn_detail_neo(csh handle, cs_insn *ins)
+{
+ cs_neo *neo;
+ int i;
+
+ // detail can be NULL on "data" instruction if SKIPDATA option is turned ON
+ if (ins->detail == NULL)
+ return;
+
+ neo = &(ins->detail->neo);
+
+ if (neo->pop)
+ printf("\tPop: %u\n", neo->pop);
+
+ if (neo->push)
+ printf("\tPush: %u\n", neo->push);
+
+ if (neo->fee) {
+ switch(neo->fee) {
+ default:
+ break;
+ case NEO_FEE_0:
+ printf("\tGas fee: 0\n");
+ break;
+ case NEO_FEE_01:
+ printf("\tGas fee: 0.1\n");
+ break;
+ case NEO_FEE_001:
+ printf("\tGas fee: 0.01\n");
+ break;
+ case NEO_FEE_002:
+ printf("\tGas fee: 0.02\n");
+ break;
+ case NEO_FEE_0001:
+ printf("\tGas fee: 0.001\n");
+ break;
+ }
+ }
+}
diff --git a/include/capstone/capstone.h b/include/capstone/capstone.h
index 39b18c9..2ebb093 100644
--- a/include/capstone/capstone.h
+++ b/include/capstone/capstone.h
@@ -84,6 +84,7 @@
CS_ARCH_TMS320C64X, // TMS320C64x architecture
CS_ARCH_M680X, // 680X architecture
CS_ARCH_EVM, // Ethereum architecture
+ CS_ARCH_NEO, // Ethereum architecture
CS_ARCH_MAX,
CS_ARCH_ALL = 0xFFFF, // All architectures - for cs_support()
} cs_arch;
@@ -257,6 +258,7 @@
// X86: 1 bytes.
// XCore: 2 bytes.
// EVM: 1 bytes.
+ // NEO: 1 bytes.
cs_skipdata_cb_t callback; // default value is NULL
// User-defined data to be passed to @callback function pointer.
@@ -276,6 +278,7 @@
#include "tms320c64x.h"
#include "m680x.h"
#include "evm.h"
+#include "neo.h"
// NOTE: All information in cs_detail is only available when CS_OPT_DETAIL = CS_OPT_ON
typedef struct cs_detail {
@@ -302,6 +305,7 @@
cs_tms320c64x tms320c64x; // TMS320C64x architecture
cs_m680x m680x; // M680X architecture
cs_evm evm; // Ethereum architecture
+ cs_neo neo; // NEO architecture
};
} cs_detail;
diff --git a/include/capstone/neo.h b/include/capstone/neo.h
new file mode 100644
index 0000000..95843e5
--- /dev/null
+++ b/include/capstone/neo.h
@@ -0,0 +1,239 @@
+#ifndef CAPSTONE_NEO_H
+#define CAPSTONE_NEO_H
+
+/* Capstone Disassembly Engine */
+/* By Nguyen Anh Quynh <aquynh@gmail.com>, 2013-2018 */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "platform.h"
+
+#ifdef _MSC_VER
+#pragma warning(disable:4201)
+#endif
+
+typedef enum neo_fee {
+ NEO_FEE_0, // fee 0
+ NEO_FEE_01, // fee 0.1
+ NEO_FEE_001, // fee 0.01
+ NEO_FEE_002, // fee 0.02
+ NEO_FEE_0001, // fee 0.001
+} neo_fee;
+
+// Instruction structure
+typedef struct cs_neo {
+ unsigned char op_size; // operand size
+ unsigned char pop; // number of items popped from the stack
+ unsigned char push; // number of items pushed into the stack
+ neo_fee fee; // gas fee for the instruction
+} cs_neo;
+
+//> NEO instruction
+typedef enum cs_neo_insn {
+ NEO_INS_PUSH0 = 0,
+ NEO_INS_PUSHBYTES1 = 1,
+ NEO_INS_PUSHBYTES2 = 2,
+ NEO_INS_PUSHBYTES3 = 3,
+ NEO_INS_PUSHBYTES4 = 4,
+ NEO_INS_PUSHBYTES5 = 5,
+ NEO_INS_PUSHBYTES6 = 6,
+ NEO_INS_PUSHBYTES7 = 7,
+ NEO_INS_PUSHBYTES8 = 8,
+ NEO_INS_PUSHBYTES9 = 9,
+ NEO_INS_PUSHBYTES10 = 10,
+ NEO_INS_PUSHBYTES11 = 11,
+ NEO_INS_PUSHBYTES12 = 12,
+ NEO_INS_PUSHBYTES13 = 13,
+ NEO_INS_PUSHBYTES14 = 14,
+ NEO_INS_PUSHBYTES15 = 15,
+ NEO_INS_PUSHBYTES16 = 16,
+ NEO_INS_PUSHBYTES17 = 17,
+ NEO_INS_PUSHBYTES18 = 18,
+ NEO_INS_PUSHBYTES19 = 19,
+ NEO_INS_PUSHBYTES20 = 20,
+ NEO_INS_PUSHBYTES21 = 21,
+ NEO_INS_PUSHBYTES22 = 22,
+ NEO_INS_PUSHBYTES23 = 23,
+ NEO_INS_PUSHBYTES24 = 24,
+ NEO_INS_PUSHBYTES25 = 25,
+ NEO_INS_PUSHBYTES26 = 26,
+ NEO_INS_PUSHBYTES27 = 27,
+ NEO_INS_PUSHBYTES28 = 28,
+ NEO_INS_PUSHBYTES29 = 29,
+ NEO_INS_PUSHBYTES30 = 30,
+ NEO_INS_PUSHBYTES31 = 31,
+ NEO_INS_PUSHBYTES32 = 32,
+ NEO_INS_PUSHBYTES33 = 33,
+ NEO_INS_PUSHBYTES34 = 34,
+ NEO_INS_PUSHBYTES35 = 35,
+ NEO_INS_PUSHBYTES36 = 36,
+ NEO_INS_PUSHBYTES37 = 37,
+ NEO_INS_PUSHBYTES38 = 38,
+ NEO_INS_PUSHBYTES39 = 39,
+ NEO_INS_PUSHBYTES40 = 40,
+ NEO_INS_PUSHBYTES41 = 41,
+ NEO_INS_PUSHBYTES42 = 42,
+ NEO_INS_PUSHBYTES43 = 43,
+ NEO_INS_PUSHBYTES44 = 44,
+ NEO_INS_PUSHBYTES45 = 45,
+ NEO_INS_PUSHBYTES46 = 46,
+ NEO_INS_PUSHBYTES47 = 47,
+ NEO_INS_PUSHBYTES48 = 48,
+ NEO_INS_PUSHBYTES49 = 49,
+ NEO_INS_PUSHBYTES50 = 50,
+ NEO_INS_PUSHBYTES51 = 51,
+ NEO_INS_PUSHBYTES52 = 52,
+ NEO_INS_PUSHBYTES53 = 53,
+ NEO_INS_PUSHBYTES54 = 54,
+ NEO_INS_PUSHBYTES55 = 55,
+ NEO_INS_PUSHBYTES56 = 56,
+ NEO_INS_PUSHBYTES57 = 57,
+ NEO_INS_PUSHBYTES58 = 58,
+ NEO_INS_PUSHBYTES59 = 59,
+ NEO_INS_PUSHBYTES60 = 60,
+ NEO_INS_PUSHBYTES61 = 61,
+ NEO_INS_PUSHBYTES62 = 62,
+ NEO_INS_PUSHBYTES63 = 63,
+ NEO_INS_PUSHBYTES64 = 64,
+ NEO_INS_PUSHBYTES65 = 65,
+ NEO_INS_PUSHBYTES66 = 66,
+ NEO_INS_PUSHBYTES67 = 67,
+ NEO_INS_PUSHBYTES68 = 68,
+ NEO_INS_PUSHBYTES69 = 69,
+ NEO_INS_PUSHBYTES70 = 70,
+ NEO_INS_PUSHBYTES71 = 71,
+ NEO_INS_PUSHBYTES72 = 72,
+ NEO_INS_PUSHBYTES73 = 73,
+ NEO_INS_PUSHBYTES74 = 74,
+ NEO_INS_PUSHBYTES75 = 75,
+ NEO_INS_PUSHDATA1 = 76,
+ NEO_INS_PUSHDATA2 = 77,
+ NEO_INS_PUSHDATA4 = 78,
+ NEO_INS_PUSHM1 = 79,
+ NEO_INS_PUSH1 = 81,
+ NEO_INS_PUSH2 = 82,
+ NEO_INS_PUSH3 = 83,
+ NEO_INS_PUSH4 = 84,
+ NEO_INS_PUSH5 = 85,
+ NEO_INS_PUSH6 = 86,
+ NEO_INS_PUSH7 = 87,
+ NEO_INS_PUSH8 = 88,
+ NEO_INS_PUSH9 = 89,
+ NEO_INS_PUSH10 = 90,
+ NEO_INS_PUSH11 = 91,
+ NEO_INS_PUSH12 = 92,
+ NEO_INS_PUSH13 = 93,
+ NEO_INS_PUSH14 = 94,
+ NEO_INS_PUSH15 = 95,
+ NEO_INS_PUSH16 = 96,
+ NEO_INS_NOP = 97,
+ NEO_INS_JMP = 98,
+ NEO_INS_JMPIF = 99,
+ NEO_INS_JMPIFNOT = 100,
+ NEO_INS_CALL = 101,
+ NEO_INS_RET = 102,
+ NEO_INS_APPCALL = 103,
+ NEO_INS_SYSCALL = 104,
+ NEO_INS_TAILCALL = 105,
+ NEO_INS_DUPFROMALTSTACK = 106,
+ NEO_INS_TOALTSTACK = 107,
+ NEO_INS_FROMALTSTACK = 108,
+ NEO_INS_XDROP = 109,
+ NEO_INS_XSWAP = 114,
+ NEO_INS_XTUCK = 115,
+ NEO_INS_DEPTH = 116,
+ NEO_INS_DROP = 117,
+ NEO_INS_DUP = 118,
+ NEO_INS_NIP = 119,
+ NEO_INS_OVER = 120,
+ NEO_INS_PICK = 121,
+ NEO_INS_ROLL = 122,
+ NEO_INS_ROT = 123,
+ NEO_INS_SWAP = 124,
+ NEO_INS_TUCK = 125,
+ NEO_INS_CAT = 126,
+ NEO_INS_SUBSTR = 127,
+ NEO_INS_LEFT = 128,
+ NEO_INS_RIGHT = 129,
+ NEO_INS_SIZE = 130,
+ NEO_INS_INVERT = 131,
+ NEO_INS_AND = 132,
+ NEO_INS_OR = 133,
+ NEO_INS_XOR = 134,
+ NEO_INS_EQUAL = 135,
+ NEO_INS_OP_EQUALVERIFY = 136,
+ NEO_INS_OP_RESERVED1 = 137,
+ NEO_INS_OP_RESERVED2 = 138,
+ NEO_INS_INC = 139,
+ NEO_INS_DEC = 140,
+ NEO_INS_SIGN = 141,
+ NEO_INS_NEGATE = 143,
+ NEO_INS_ABS = 144,
+ NEO_INS_NOT = 145,
+ NEO_INS_NZ = 146,
+ NEO_INS_ADD = 147,
+ NEO_INS_SUB = 148,
+ NEO_INS_MUL = 149,
+ NEO_INS_DIV = 150,
+ NEO_INS_MOD = 151,
+ NEO_INS_SHL = 152,
+ NEO_INS_SHR = 153,
+ NEO_INS_BOOLAND = 154,
+ NEO_INS_BOOLOR = 155,
+ NEO_INS_NUMEQUAL = 156,
+ NEO_INS_NUMNOTEQUAL = 158,
+ NEO_INS_LT = 159,
+ NEO_INS_GT = 160,
+ NEO_INS_LTE = 161,
+ NEO_INS_GTE = 162,
+ NEO_INS_MIN = 163,
+ NEO_INS_MAX = 164,
+ NEO_INS_WITHIN = 165,
+ NEO_INS_SHA1 = 167,
+ NEO_INS_SHA256 = 168,
+ NEO_INS_HASH160 = 169,
+ NEO_INS_HASH256 = 170,
+ NEO_INS_CHECKSIG = 172,
+ NEO_INS_VERIFY = 173,
+ NEO_INS_CHECKMULTISIG = 174,
+ NEO_INS_ARRAYSIZE = 192,
+ NEO_INS_PACK = 193,
+ NEO_INS_UNPACK = 194,
+ NEO_INS_PICKITEM = 195,
+ NEO_INS_SETITEM = 196,
+ NEO_INS_NEWARRAY = 197,
+ NEO_INS_NEWSTRUCT = 198,
+ NEO_INS_NEWMAP = 199,
+ NEO_INS_APPEND = 200,
+ NEO_INS_REVERSE = 201,
+ NEO_INS_REMOVE = 202,
+ NEO_INS_HASKEY = 203,
+ NEO_INS_KEYS = 204,
+ NEO_INS_VALUES = 205,
+ NEO_INS_THROW = 240,
+ NEO_INS_THROWIFNOT = 241,
+
+ NEO_INS_INVALID = 512,
+ NEO_INS_ENDING, // <-- mark the end of the list of instructions
+} cs_neo_insn;
+
+//> Group of NEO instructions
+typedef enum cs_neo_insn_group {
+ NEO_GRP_INVALID = 0, // = CS_GRP_INVALID
+
+ NEO_GRP_JUMP, // all jump instructions
+
+ NEO_GRP_MATH = 8, // math instructions
+ NEO_GRP_STACK_WRITE,
+ NEO_GRP_STACK_READ,
+
+ NEO_GRP_ENDING, // <-- mark the end of the list of groups
+} cs_neo_insn_group;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
