collab/polyglot-riscv-arm

what if the same machine code was valid riscv and arm asm

git clone https://git.julia.blue/collab/polyglot-riscv-arm

Jonathan Dönszelmannwebsite start885cc4e

main
39.5 KiB1118 linesraw
1'use strict';
2
3var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
4var capstone$1 = (()=>{
5    var _scriptDir = (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href));
6    return async function(moduleArg = {}) {
7        var Module = moduleArg;
8        var readyPromiseResolve, readyPromiseReject;
9        Module["ready"] = new Promise((resolve, reject)=>{
10            readyPromiseResolve = resolve;
11            readyPromiseReject = reject;
12        });
13        var moduleOverrides = Object.assign({}, Module);
14        var ENVIRONMENT_IS_WEB = typeof window == "object";
15        var ENVIRONMENT_IS_WORKER = typeof importScripts == "function";
16        var ENVIRONMENT_IS_NODE = typeof process == "object" && typeof process.versions == "object" && typeof process.versions.node == "string";
17        var scriptDirectory = "";
18        function locateFile(path) {
19            if (Module["locateFile"]) {
20                return Module["locateFile"](path, scriptDirectory);
21            }
22            return scriptDirectory + path;
23        }
24        var read_, readAsync, readBinary;
25        if (ENVIRONMENT_IS_NODE) {
26            const { createRequire: createRequire } = await import('module');
27            /** @suppress{duplicate} */ var require$1 = createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
28            var fs = require$1("fs");
29            var nodePath = require$1("path");
30            if (ENVIRONMENT_IS_WORKER) {
31                scriptDirectory = nodePath.dirname(scriptDirectory) + "/";
32            } else {
33                scriptDirectory = require$1("url").fileURLToPath(new URL("./", (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href))));
34            }
35            read_ = (filename, binary)=>{
36                filename = isFileURI(filename) ? new URL(filename) : nodePath.normalize(filename);
37                return fs.readFileSync(filename, binary ? undefined : "utf8");
38            };
39            readBinary = (filename)=>{
40                var ret = read_(filename, true);
41                if (!ret.buffer) {
42                    ret = new Uint8Array(ret);
43                }
44                return ret;
45            };
46            readAsync = (filename, onload, onerror, binary = true)=>{
47                filename = isFileURI(filename) ? new URL(filename) : nodePath.normalize(filename);
48                fs.readFile(filename, binary ? undefined : "utf8", (err, data)=>{
49                    if (err) onerror(err);
50                    else onload(binary ? data.buffer : data);
51                });
52            };
53            if (!Module["thisProgram"] && process.argv.length > 1) {
54                process.argv[1].replace(/\\/g, "/");
55            }
56            process.argv.slice(2);
57            Module["inspect"] = ()=>"[Emscripten Module object]";
58        } else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
59            if (ENVIRONMENT_IS_WORKER) {
60                scriptDirectory = self.location.href;
61            } else if (typeof document != "undefined" && document.currentScript) {
62                scriptDirectory = document.currentScript.src;
63            }
64            if (_scriptDir) {
65                scriptDirectory = _scriptDir;
66            }
67            if (scriptDirectory.indexOf("blob:") !== 0) {
68                scriptDirectory = scriptDirectory.substr(0, scriptDirectory.replace(/[?#].*/, "").lastIndexOf("/") + 1);
69            } else {
70                scriptDirectory = "";
71            }
72            {
73                read_ = (url)=>{
74                    var xhr = new XMLHttpRequest;
75                    xhr.open("GET", url, false);
76                    xhr.send(null);
77                    return xhr.responseText;
78                };
79                if (ENVIRONMENT_IS_WORKER) {
80                    readBinary = (url)=>{
81                        var xhr = new XMLHttpRequest;
82                        xhr.open("GET", url, false);
83                        xhr.responseType = "arraybuffer";
84                        xhr.send(null);
85                        return new Uint8Array(/** @type{!ArrayBuffer} */ xhr.response);
86                    };
87                }
88                readAsync = (url, onload, onerror)=>{
89                    var xhr = new XMLHttpRequest;
90                    xhr.open("GET", url, true);
91                    xhr.responseType = "arraybuffer";
92                    xhr.onload = ()=>{
93                        if (xhr.status == 200 || xhr.status == 0 && xhr.response) {
94                            onload(xhr.response);
95                            return;
96                        }
97                        onerror();
98                    };
99                    xhr.onerror = onerror;
100                    xhr.send(null);
101                };
102            }
103        } else ;
104        Module["print"] || console.log.bind(console);
105        var err = Module["printErr"] || console.error.bind(console);
106        Object.assign(Module, moduleOverrides);
107        moduleOverrides = null;
108        if (Module["arguments"]) Module["arguments"];
109        if (Module["thisProgram"]) Module["thisProgram"];
110        if (Module["quit"]) Module["quit"];
111        var wasmBinary;
112        if (Module["wasmBinary"]) wasmBinary = Module["wasmBinary"];
113        Module["noExitRuntime"] || true;
114        if (typeof WebAssembly != "object") {
115            abort("no native wasm support detected");
116        }
117        var wasmMemory;
118        var ABORT = false;
119        var /** @type {!Int8Array} */ HEAP8, /** @type {!Uint8Array} */ HEAPU8, /** @type {!Int16Array} */ HEAP16, /** @type {!Int32Array} */ HEAP32, /** @type {!Uint32Array} */ HEAPU32, /** @type {!Float32Array} */ HEAPF32, /* BigInt64Array type is not correctly defined in closure
120/** not-@type {!BigInt64Array} */ HEAP64, /** @type {!Float64Array} */ HEAPF64;
121        function updateMemoryViews() {
122            var b = wasmMemory.buffer;
123            Module["HEAP8"] = HEAP8 = new Int8Array(b);
124            Module["HEAP16"] = HEAP16 = new Int16Array(b);
125            Module["HEAPU8"] = HEAPU8 = new Uint8Array(b);
126            Module["HEAPU16"] = new Uint16Array(b);
127            Module["HEAP32"] = HEAP32 = new Int32Array(b);
128            Module["HEAPU32"] = HEAPU32 = new Uint32Array(b);
129            Module["HEAPF32"] = HEAPF32 = new Float32Array(b);
130            Module["HEAPF64"] = HEAPF64 = new Float64Array(b);
131            Module["HEAP64"] = HEAP64 = new BigInt64Array(b);
132            Module["HEAPU64"] = new BigUint64Array(b);
133        }
134        var __ATPRERUN__ = [];
135        var __ATINIT__ = [];
136        var __ATPOSTRUN__ = [];
137        function preRun() {
138            if (Module["preRun"]) {
139                if (typeof Module["preRun"] == "function") Module["preRun"] = [
140                    Module["preRun"]
141                ];
142                while(Module["preRun"].length){
143                    addOnPreRun(Module["preRun"].shift());
144                }
145            }
146            callRuntimeCallbacks(__ATPRERUN__);
147        }
148        function initRuntime() {
149            callRuntimeCallbacks(__ATINIT__);
150        }
151        function postRun() {
152            if (Module["postRun"]) {
153                if (typeof Module["postRun"] == "function") Module["postRun"] = [
154                    Module["postRun"]
155                ];
156                while(Module["postRun"].length){
157                    addOnPostRun(Module["postRun"].shift());
158                }
159            }
160            callRuntimeCallbacks(__ATPOSTRUN__);
161        }
162        function addOnPreRun(cb) {
163            __ATPRERUN__.unshift(cb);
164        }
165        function addOnInit(cb) {
166            __ATINIT__.unshift(cb);
167        }
168        function addOnPostRun(cb) {
169            __ATPOSTRUN__.unshift(cb);
170        }
171        var runDependencies = 0;
172        var dependenciesFulfilled = null;
173        function addRunDependency(id) {
174            runDependencies++;
175            if (Module["monitorRunDependencies"]) {
176                Module["monitorRunDependencies"](runDependencies);
177            }
178        }
179        function removeRunDependency(id) {
180            runDependencies--;
181            if (Module["monitorRunDependencies"]) {
182                Module["monitorRunDependencies"](runDependencies);
183            }
184            if (runDependencies == 0) {
185                if (dependenciesFulfilled) {
186                    var callback = dependenciesFulfilled;
187                    dependenciesFulfilled = null;
188                    callback();
189                }
190            }
191        }
192        /** @param {string|number=} what */ function abort(what) {
193            if (Module["onAbort"]) {
194                Module["onAbort"](what);
195            }
196            what = "Aborted(" + what + ")";
197            err(what);
198            ABORT = true;
199            what += ". Build with -sASSERTIONS for more info.";
200            /** @suppress {checkTypes} */ var e = new WebAssembly.RuntimeError(what);
201            readyPromiseReject(e);
202            throw e;
203        }
204        var dataURIPrefix = "data:application/octet-stream;base64,";
205        function isDataURI(filename) {
206            return filename.startsWith(dataURIPrefix);
207        }
208        function isFileURI(filename) {
209            return filename.startsWith("file://");
210        }
211        var wasmBinaryFile;
212        if (Module["locateFile"]) {
213            wasmBinaryFile = "capstone.wasm";
214            if (!isDataURI(wasmBinaryFile)) {
215                wasmBinaryFile = locateFile(wasmBinaryFile);
216            }
217        } else {
218            wasmBinaryFile = new URL("capstone.wasm", (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href))).href;
219        }
220        function getBinarySync(file) {
221            if (file == wasmBinaryFile && wasmBinary) {
222                return new Uint8Array(wasmBinary);
223            }
224            if (readBinary) {
225                return readBinary(file);
226            }
227            throw "both async and sync fetching of the wasm failed";
228        }
229        function getBinaryPromise(binaryFile) {
230            if (!wasmBinary && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER)) {
231                if (typeof fetch == "function" && !isFileURI(binaryFile)) {
232                    return fetch(binaryFile, {
233                        credentials: "same-origin"
234                    }).then((response)=>{
235                        if (!response["ok"]) {
236                            throw "failed to load wasm binary file at '" + binaryFile + "'";
237                        }
238                        return response["arrayBuffer"]();
239                    }).catch(()=>getBinarySync(binaryFile));
240                } else if (readAsync) {
241                    return new Promise((resolve, reject)=>{
242                        readAsync(binaryFile, (response)=>resolve(new Uint8Array(/** @type{!ArrayBuffer} */ response)), reject);
243                    });
244                }
245            }
246            return Promise.resolve().then(()=>getBinarySync(binaryFile));
247        }
248        function instantiateArrayBuffer(binaryFile, imports, receiver) {
249            return getBinaryPromise(binaryFile).then((binary)=>WebAssembly.instantiate(binary, imports)).then((instance)=>instance).then(receiver, (reason)=>{
250                err(`failed to asynchronously prepare wasm: ${reason}`);
251                abort(reason);
252            });
253        }
254        function instantiateAsync(binary, binaryFile, imports, callback) {
255            if (!binary && typeof WebAssembly.instantiateStreaming == "function" && !isDataURI(binaryFile) && !isFileURI(binaryFile) && !ENVIRONMENT_IS_NODE && typeof fetch == "function") {
256                return fetch(binaryFile, {
257                    credentials: "same-origin"
258                }).then((response)=>{
259                    /** @suppress {checkTypes} */ var result = WebAssembly.instantiateStreaming(response, imports);
260                    return result.then(callback, function(reason) {
261                        err(`wasm streaming compile failed: ${reason}`);
262                        err("falling back to ArrayBuffer instantiation");
263                        return instantiateArrayBuffer(binaryFile, imports, callback);
264                    });
265                });
266            }
267            return instantiateArrayBuffer(binaryFile, imports, callback);
268        }
269        function createWasm() {
270            var info = {
271                "a": wasmImports
272            };
273            /** @param {WebAssembly.Module=} module*/ function receiveInstance(instance, module) {
274                wasmExports = instance.exports;
275                wasmMemory = wasmExports["c"];
276                updateMemoryViews();
277                addOnInit(wasmExports["d"]);
278                removeRunDependency();
279                return wasmExports;
280            }
281            addRunDependency();
282            function receiveInstantiationResult(result) {
283                receiveInstance(result["instance"]);
284            }
285            if (Module["instantiateWasm"]) {
286                try {
287                    return Module["instantiateWasm"](info, receiveInstance);
288                } catch (e) {
289                    err(`Module.instantiateWasm callback failed with error: ${e}`);
290                    readyPromiseReject(e);
291                }
292            }
293            instantiateAsync(wasmBinary, wasmBinaryFile, info, receiveInstantiationResult).catch(readyPromiseReject);
294            return {};
295        }
296        var callRuntimeCallbacks = (callbacks)=>{
297            while(callbacks.length > 0){
298                callbacks.shift()(Module);
299            }
300        };
301        /**
302     * @param {number} ptr
303     * @param {string} type
304     */ function getValue(ptr, type = "i8") {
305            if (type.endsWith("*")) type = "*";
306            switch(type){
307                case "i1":
308                    return HEAP8[ptr >> 0];
309                case "i8":
310                    return HEAP8[ptr >> 0];
311                case "i16":
312                    return HEAP16[ptr >> 1];
313                case "i32":
314                    return HEAP32[ptr >> 2];
315                case "i64":
316                    return HEAP64[ptr >> 3];
317                case "float":
318                    return HEAPF32[ptr >> 2];
319                case "double":
320                    return HEAPF64[ptr >> 3];
321                case "*":
322                    return HEAPU32[ptr >> 2];
323                default:
324                    abort(`invalid type for getValue: ${type}`);
325            }
326        }
327        var _emscripten_memcpy_js = (dest, src, num)=>HEAPU8.copyWithin(dest, src, src + num);
328        var abortOnCannotGrowMemory = (requestedSize)=>{
329            abort("OOM");
330        };
331        var _emscripten_resize_heap = (requestedSize)=>{
332            HEAPU8.length;
333            abortOnCannotGrowMemory();
334        };
335        var getCFunc = (ident)=>{
336            var func = Module["_" + ident];
337            return func;
338        };
339        var writeArrayToMemory = (array, buffer)=>{
340            HEAP8.set(array, buffer);
341        };
342        var lengthBytesUTF8 = (str)=>{
343            var len = 0;
344            for(var i = 0; i < str.length; ++i){
345                var c = str.charCodeAt(i);
346                if (c <= 127) {
347                    len++;
348                } else if (c <= 2047) {
349                    len += 2;
350                } else if (c >= 55296 && c <= 57343) {
351                    len += 4;
352                    ++i;
353                } else {
354                    len += 3;
355                }
356            }
357            return len;
358        };
359        var stringToUTF8Array = (str, heap, outIdx, maxBytesToWrite)=>{
360            if (!(maxBytesToWrite > 0)) return 0;
361            var startIdx = outIdx;
362            var endIdx = outIdx + maxBytesToWrite - 1;
363            for(var i = 0; i < str.length; ++i){
364                var u = str.charCodeAt(i);
365                if (u >= 55296 && u <= 57343) {
366                    var u1 = str.charCodeAt(++i);
367                    u = 65536 + ((u & 1023) << 10) | u1 & 1023;
368                }
369                if (u <= 127) {
370                    if (outIdx >= endIdx) break;
371                    heap[outIdx++] = u;
372                } else if (u <= 2047) {
373                    if (outIdx + 1 >= endIdx) break;
374                    heap[outIdx++] = 192 | u >> 6;
375                    heap[outIdx++] = 128 | u & 63;
376                } else if (u <= 65535) {
377                    if (outIdx + 2 >= endIdx) break;
378                    heap[outIdx++] = 224 | u >> 12;
379                    heap[outIdx++] = 128 | u >> 6 & 63;
380                    heap[outIdx++] = 128 | u & 63;
381                } else {
382                    if (outIdx + 3 >= endIdx) break;
383                    heap[outIdx++] = 240 | u >> 18;
384                    heap[outIdx++] = 128 | u >> 12 & 63;
385                    heap[outIdx++] = 128 | u >> 6 & 63;
386                    heap[outIdx++] = 128 | u & 63;
387                }
388            }
389            heap[outIdx] = 0;
390            return outIdx - startIdx;
391        };
392        var stringToUTF8 = (str, outPtr, maxBytesToWrite)=>stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);
393        var stringToUTF8OnStack = (str)=>{
394            var size = lengthBytesUTF8(str) + 1;
395            var ret = stackAlloc(size);
396            stringToUTF8(str, ret, size);
397            return ret;
398        };
399        var UTF8Decoder = typeof TextDecoder != "undefined" ? new TextDecoder("utf8") : undefined;
400        /**
401     * Given a pointer 'idx' to a null-terminated UTF8-encoded string in the given
402     * array that contains uint8 values, returns a copy of that string as a
403     * Javascript String object.
404     * heapOrArray is either a regular array, or a JavaScript typed array view.
405     * @param {number} idx
406     * @param {number=} maxBytesToRead
407     * @return {string}
408     */ var UTF8ArrayToString = (heapOrArray, idx, maxBytesToRead)=>{
409            var endIdx = idx + maxBytesToRead;
410            var endPtr = idx;
411            while(heapOrArray[endPtr] && !(endPtr >= endIdx))++endPtr;
412            if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) {
413                return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr));
414            }
415            var str = "";
416            while(idx < endPtr){
417                var u0 = heapOrArray[idx++];
418                if (!(u0 & 128)) {
419                    str += String.fromCharCode(u0);
420                    continue;
421                }
422                var u1 = heapOrArray[idx++] & 63;
423                if ((u0 & 224) == 192) {
424                    str += String.fromCharCode((u0 & 31) << 6 | u1);
425                    continue;
426                }
427                var u2 = heapOrArray[idx++] & 63;
428                if ((u0 & 240) == 224) {
429                    u0 = (u0 & 15) << 12 | u1 << 6 | u2;
430                } else {
431                    u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | heapOrArray[idx++] & 63;
432                }
433                if (u0 < 65536) {
434                    str += String.fromCharCode(u0);
435                } else {
436                    var ch = u0 - 65536;
437                    str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023);
438                }
439            }
440            return str;
441        };
442        /**
443     * Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the
444     * emscripten HEAP, returns a copy of that string as a Javascript String object.
445     *
446     * @param {number} ptr
447     * @param {number=} maxBytesToRead - An optional length that specifies the
448     *   maximum number of bytes to read. You can omit this parameter to scan the
449     *   string until the first 0 byte. If maxBytesToRead is passed, and the string
450     *   at [ptr, ptr+maxBytesToReadr[ contains a null byte in the middle, then the
451     *   string will cut short at that byte index (i.e. maxBytesToRead will not
452     *   produce a string of exact length [ptr, ptr+maxBytesToRead[) N.B. mixing
453     *   frequent uses of UTF8ToString() with and without maxBytesToRead may throw
454     *   JS JIT optimizations off, so it is worth to consider consistently using one
455     * @return {string}
456     */ var UTF8ToString = (ptr, maxBytesToRead)=>ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : "";
457        /**
458     * @param {string|null=} returnType
459     * @param {Array=} argTypes
460     * @param {Arguments|Array=} args
461     * @param {Object=} opts
462     */ var ccall = (ident, returnType, argTypes, args, opts)=>{
463            var toC = {
464                "string": (str)=>{
465                    var ret = 0;
466                    if (str !== null && str !== undefined && str !== 0) {
467                        ret = stringToUTF8OnStack(str);
468                    }
469                    return ret;
470                },
471                "array": (arr)=>{
472                    var ret = stackAlloc(arr.length);
473                    writeArrayToMemory(arr, ret);
474                    return ret;
475                }
476            };
477            function convertReturnValue(ret) {
478                if (returnType === "string") {
479                    return UTF8ToString(ret);
480                }
481                if (returnType === "boolean") return Boolean(ret);
482                return ret;
483            }
484            var func = getCFunc(ident);
485            var cArgs = [];
486            var stack = 0;
487            if (args) {
488                for(var i = 0; i < args.length; i++){
489                    var converter = toC[argTypes[i]];
490                    if (converter) {
491                        if (stack === 0) stack = stackSave();
492                        cArgs[i] = converter(args[i]);
493                    } else {
494                        cArgs[i] = args[i];
495                    }
496                }
497            }
498            var ret = func.apply(null, cArgs);
499            function onDone(ret) {
500                if (stack !== 0) stackRestore(stack);
501                return convertReturnValue(ret);
502            }
503            ret = onDone(ret);
504            return ret;
505        };
506        /**
507     * @param {string=} returnType
508     * @param {Array=} argTypes
509     * @param {Object=} opts
510     */ var cwrap = (ident, returnType, argTypes, opts)=>{
511            var numericArgs = !argTypes || argTypes.every((type)=>type === "number" || type === "boolean");
512            var numericRet = returnType !== "string";
513            if (numericRet && numericArgs && !opts) {
514                return getCFunc(ident);
515            }
516            return function() {
517                return ccall(ident, returnType, argTypes, arguments);
518            };
519        };
520        var wasmImports = {
521            /** @export */ b: _emscripten_memcpy_js,
522            /** @export */ a: _emscripten_resize_heap
523        };
524        var wasmExports = createWasm();
525        Module["_cs_version"] = (a0, a1)=>(Module["_cs_version"] = wasmExports["e"])(a0, a1);
526        Module["_cs_support"] = (a0)=>(Module["_cs_support"] = wasmExports["f"])(a0);
527        Module["_cs_errno"] = (a0)=>(Module["_cs_errno"] = wasmExports["g"])(a0);
528        Module["_cs_strerror"] = (a0)=>(Module["_cs_strerror"] = wasmExports["h"])(a0);
529        Module["_cs_open"] = (a0, a1, a2)=>(Module["_cs_open"] = wasmExports["i"])(a0, a1, a2);
530        Module["_cs_close"] = (a0)=>(Module["_cs_close"] = wasmExports["j"])(a0);
531        Module["_cs_option"] = (a0, a1, a2)=>(Module["_cs_option"] = wasmExports["k"])(a0, a1, a2);
532        Module["_cs_disasm"] = (a0, a1, a2, a3, a4, a5)=>(Module["_cs_disasm"] = wasmExports["l"])(a0, a1, a2, a3, a4, a5);
533        Module["_cs_free"] = (a0, a1)=>(Module["_cs_free"] = wasmExports["m"])(a0, a1);
534        Module["_cs_malloc"] = (a0)=>(Module["_cs_malloc"] = wasmExports["n"])(a0);
535        Module["_cs_reg_name"] = (a0, a1)=>(Module["_cs_reg_name"] = wasmExports["o"])(a0, a1);
536        Module["_cs_insn_name"] = (a0, a1)=>(Module["_cs_insn_name"] = wasmExports["p"])(a0, a1);
537        Module["_cs_group_name"] = (a0, a1)=>(Module["_cs_group_name"] = wasmExports["q"])(a0, a1);
538        Module["_cs_insn_group"] = (a0, a1, a2)=>(Module["_cs_insn_group"] = wasmExports["r"])(a0, a1, a2);
539        Module["_cs_reg_read"] = (a0, a1, a2)=>(Module["_cs_reg_read"] = wasmExports["s"])(a0, a1, a2);
540        Module["_cs_reg_write"] = (a0, a1, a2)=>(Module["_cs_reg_write"] = wasmExports["t"])(a0, a1, a2);
541        Module["_cs_op_count"] = (a0, a1, a2)=>(Module["_cs_op_count"] = wasmExports["u"])(a0, a1, a2);
542        Module["_cs_op_index"] = (a0, a1, a2, a3)=>(Module["_cs_op_index"] = wasmExports["v"])(a0, a1, a2, a3);
543        Module["_cs_regs_access"] = (a0, a1, a2, a3, a4, a5)=>(Module["_cs_regs_access"] = wasmExports["w"])(a0, a1, a2, a3, a4, a5);
544        Module["_malloc"] = (a0)=>(Module["_malloc"] = wasmExports["x"])(a0);
545        Module["_free"] = (a0)=>(Module["_free"] = wasmExports["y"])(a0);
546        var stackSave = ()=>(stackSave = wasmExports["z"])();
547        var stackRestore = (a0)=>(stackRestore = wasmExports["A"])(a0);
548        var stackAlloc = (a0)=>(stackAlloc = wasmExports["B"])(a0);
549        Module["ccall"] = ccall;
550        Module["cwrap"] = cwrap;
551        Module["getValue"] = getValue;
552        Module["UTF8ToString"] = UTF8ToString;
553        var calledRun;
554        dependenciesFulfilled = function runCaller() {
555            if (!calledRun) run();
556            if (!calledRun) dependenciesFulfilled = runCaller;
557        };
558        function run() {
559            if (runDependencies > 0) {
560                return;
561            }
562            preRun();
563            if (runDependencies > 0) {
564                return;
565            }
566            function doRun() {
567                if (calledRun) return;
568                calledRun = true;
569                Module["calledRun"] = true;
570                if (ABORT) return;
571                initRuntime();
572                readyPromiseResolve(Module);
573                if (Module["onRuntimeInitialized"]) Module["onRuntimeInitialized"]();
574                postRun();
575            }
576            if (Module["setStatus"]) {
577                Module["setStatus"]("Running...");
578                setTimeout(function() {
579                    setTimeout(function() {
580                        Module["setStatus"]("");
581                    }, 1);
582                    doRun();
583                }, 1);
584            } else {
585                doRun();
586            }
587        }
588        if (Module["preInit"]) {
589            if (typeof Module["preInit"] == "function") Module["preInit"] = [
590                Module["preInit"]
591            ];
592            while(Module["preInit"].length > 0){
593                Module["preInit"].pop()();
594            }
595        }
596        run();
597        return moduleArg.ready;
598    };
599})();
600
601// AUTO-GENERATED FILE, DO NOT EDIT
602/* eslint-disable */ const CS_API_MAJOR = 5;
603const CS_API_MINOR = 0;
604const CS_ARCH_ARM = 0;
605const CS_ARCH_ARM64 = 1;
606const CS_ARCH_MIPS = 2;
607const CS_ARCH_X86 = 3;
608const CS_ARCH_PPC = 4;
609const CS_ARCH_SPARC = 5;
610const CS_ARCH_SYSZ = 6;
611const CS_ARCH_XCORE = 7;
612const CS_ARCH_M68K = 8;
613const CS_ARCH_TMS320C64X = 9;
614const CS_ARCH_M680X = 10;
615const CS_ARCH_MAX = 11;
616const CS_ARCH_ALL = 0xFFFF;
617const CS_MODE_LITTLE_ENDIAN = 0;
618const CS_MODE_ARM = 0;
619const CS_MODE_16 = 1 << 1;
620const CS_MODE_32 = 1 << 2;
621const CS_MODE_64 = 1 << 3;
622const CS_MODE_THUMB = 1 << 4;
623const CS_MODE_MCLASS = 1 << 5;
624const CS_MODE_V8 = 1 << 6;
625const CS_MODE_MICRO = 1 << 4;
626const CS_MODE_MIPS3 = 1 << 5;
627const CS_MODE_MIPS32R6 = 1 << 6;
628const CS_MODE_MIPS2 = 1 << 7;
629const CS_MODE_BIG_ENDIAN = 1 << 31;
630const CS_MODE_V9 = 1 << 4;
631const CS_MODE_MIPS32 = CS_MODE_32;
632const CS_MODE_MIPS64 = CS_MODE_64;
633const CS_MODE_QPX = 1 << 4;
634const CS_MODE_M680X_6301 = 1 << 1;
635const CS_MODE_M680X_6309 = 1 << 2;
636const CS_MODE_M680X_6800 = 1 << 3;
637const CS_MODE_M680X_6801 = 1 << 4;
638const CS_MODE_M680X_6805 = 1 << 5;
639const CS_MODE_M680X_6808 = 1 << 6;
640const CS_MODE_M680X_6809 = 1 << 7;
641const CS_MODE_M680X_6811 = 1 << 8;
642const CS_MODE_M680X_CPU12 = 1 << 9;
643const CS_MODE_M680X_HCS08 = 1 << 10;
644const CS_ERR_OK = 0;
645const CS_ERR_MEM = 1;
646const CS_ERR_ARCH = 2;
647const CS_ERR_HANDLE = 3;
648const CS_ERR_CSH = 4;
649const CS_ERR_MODE = 5;
650const CS_ERR_OPTION = 6;
651const CS_ERR_DETAIL = 7;
652const CS_ERR_MEMSETUP = 8;
653const CS_ERR_VERSION = 9;
654const CS_ERR_DIET = 10;
655const CS_ERR_SKIPDATA = 11;
656const CS_ERR_X86_ATT = 12;
657const CS_ERR_X86_INTEL = 13;
658const CS_OPT_SYNTAX = 1;
659const CS_OPT_DETAIL = 2;
660const CS_OPT_MODE = 3;
661const CS_OPT_OFF = 0;
662const CS_OPT_SYNTAX_INTEL = 1;
663const CS_OPT_SYNTAX_ATT = 2;
664const CS_OPT_ON = 3;
665const CS_OPT_SYNTAX_NOREGNAME = 3;
666const CS_OP_INVALID = 0;
667const CS_OP_REG = 1;
668const CS_OP_IMM = 2;
669const CS_OP_MEM = 3;
670const CS_OP_FP = 4;
671const CS_AC_INVALID = 0;
672const CS_AC_READ = 1 << 0;
673const CS_AC_WRITE = 1 << 1;
674const CS_GRP_INVALID = 0;
675const CS_GRP_JUMP = 1;
676const CS_GRP_CALL = 2;
677const CS_GRP_RET = 3;
678const CS_GRP_INT = 4;
679const CS_GRP_IRET = 5;
680const CS_GRP_PRIVILEGE = 6;
681const CS_SUPPORT_DIET = CS_ARCH_ALL + 1;
682const CS_SUPPORT_X86_REDUCE = CS_ARCH_ALL + 2;
683
684var _const = /*#__PURE__*/Object.freeze({
685  __proto__: null,
686  CS_AC_INVALID: CS_AC_INVALID,
687  CS_AC_READ: CS_AC_READ,
688  CS_AC_WRITE: CS_AC_WRITE,
689  CS_API_MAJOR: CS_API_MAJOR,
690  CS_API_MINOR: CS_API_MINOR,
691  CS_ARCH_ALL: CS_ARCH_ALL,
692  CS_ARCH_ARM: CS_ARCH_ARM,
693  CS_ARCH_ARM64: CS_ARCH_ARM64,
694  CS_ARCH_M680X: CS_ARCH_M680X,
695  CS_ARCH_M68K: CS_ARCH_M68K,
696  CS_ARCH_MAX: CS_ARCH_MAX,
697  CS_ARCH_MIPS: CS_ARCH_MIPS,
698  CS_ARCH_PPC: CS_ARCH_PPC,
699  CS_ARCH_SPARC: CS_ARCH_SPARC,
700  CS_ARCH_SYSZ: CS_ARCH_SYSZ,
701  CS_ARCH_TMS320C64X: CS_ARCH_TMS320C64X,
702  CS_ARCH_X86: CS_ARCH_X86,
703  CS_ARCH_XCORE: CS_ARCH_XCORE,
704  CS_ERR_ARCH: CS_ERR_ARCH,
705  CS_ERR_CSH: CS_ERR_CSH,
706  CS_ERR_DETAIL: CS_ERR_DETAIL,
707  CS_ERR_DIET: CS_ERR_DIET,
708  CS_ERR_HANDLE: CS_ERR_HANDLE,
709  CS_ERR_MEM: CS_ERR_MEM,
710  CS_ERR_MEMSETUP: CS_ERR_MEMSETUP,
711  CS_ERR_MODE: CS_ERR_MODE,
712  CS_ERR_OK: CS_ERR_OK,
713  CS_ERR_OPTION: CS_ERR_OPTION,
714  CS_ERR_SKIPDATA: CS_ERR_SKIPDATA,
715  CS_ERR_VERSION: CS_ERR_VERSION,
716  CS_ERR_X86_ATT: CS_ERR_X86_ATT,
717  CS_ERR_X86_INTEL: CS_ERR_X86_INTEL,
718  CS_GRP_CALL: CS_GRP_CALL,
719  CS_GRP_INT: CS_GRP_INT,
720  CS_GRP_INVALID: CS_GRP_INVALID,
721  CS_GRP_IRET: CS_GRP_IRET,
722  CS_GRP_JUMP: CS_GRP_JUMP,
723  CS_GRP_PRIVILEGE: CS_GRP_PRIVILEGE,
724  CS_GRP_RET: CS_GRP_RET,
725  CS_MODE_16: CS_MODE_16,
726  CS_MODE_32: CS_MODE_32,
727  CS_MODE_64: CS_MODE_64,
728  CS_MODE_ARM: CS_MODE_ARM,
729  CS_MODE_BIG_ENDIAN: CS_MODE_BIG_ENDIAN,
730  CS_MODE_LITTLE_ENDIAN: CS_MODE_LITTLE_ENDIAN,
731  CS_MODE_M680X_6301: CS_MODE_M680X_6301,
732  CS_MODE_M680X_6309: CS_MODE_M680X_6309,
733  CS_MODE_M680X_6800: CS_MODE_M680X_6800,
734  CS_MODE_M680X_6801: CS_MODE_M680X_6801,
735  CS_MODE_M680X_6805: CS_MODE_M680X_6805,
736  CS_MODE_M680X_6808: CS_MODE_M680X_6808,
737  CS_MODE_M680X_6809: CS_MODE_M680X_6809,
738  CS_MODE_M680X_6811: CS_MODE_M680X_6811,
739  CS_MODE_M680X_CPU12: CS_MODE_M680X_CPU12,
740  CS_MODE_M680X_HCS08: CS_MODE_M680X_HCS08,
741  CS_MODE_MCLASS: CS_MODE_MCLASS,
742  CS_MODE_MICRO: CS_MODE_MICRO,
743  CS_MODE_MIPS2: CS_MODE_MIPS2,
744  CS_MODE_MIPS3: CS_MODE_MIPS3,
745  CS_MODE_MIPS32: CS_MODE_MIPS32,
746  CS_MODE_MIPS32R6: CS_MODE_MIPS32R6,
747  CS_MODE_MIPS64: CS_MODE_MIPS64,
748  CS_MODE_QPX: CS_MODE_QPX,
749  CS_MODE_THUMB: CS_MODE_THUMB,
750  CS_MODE_V8: CS_MODE_V8,
751  CS_MODE_V9: CS_MODE_V9,
752  CS_OPT_DETAIL: CS_OPT_DETAIL,
753  CS_OPT_MODE: CS_OPT_MODE,
754  CS_OPT_OFF: CS_OPT_OFF,
755  CS_OPT_ON: CS_OPT_ON,
756  CS_OPT_SYNTAX: CS_OPT_SYNTAX,
757  CS_OPT_SYNTAX_ATT: CS_OPT_SYNTAX_ATT,
758  CS_OPT_SYNTAX_INTEL: CS_OPT_SYNTAX_INTEL,
759  CS_OPT_SYNTAX_NOREGNAME: CS_OPT_SYNTAX_NOREGNAME,
760  CS_OP_FP: CS_OP_FP,
761  CS_OP_IMM: CS_OP_IMM,
762  CS_OP_INVALID: CS_OP_INVALID,
763  CS_OP_MEM: CS_OP_MEM,
764  CS_OP_REG: CS_OP_REG,
765  CS_SUPPORT_DIET: CS_SUPPORT_DIET,
766  CS_SUPPORT_X86_REDUCE: CS_SUPPORT_X86_REDUCE
767});
768
769const POINTER_SIZE = 4;
770function defineMethods(obj) {
771    return obj;
772}
773function getNativeTypeSize(type) {
774    switch(type){
775        case '*':
776            return POINTER_SIZE;
777        case 'i1':
778        case 'i8':
779            return 1;
780        case 'i16':
781            return 2;
782        case 'i32':
783            return 4;
784        case 'i64':
785            return 8;
786        case 'float':
787            return 4;
788        case 'double':
789            return 8;
790        default:
791            {
792                throw new Error(`Unsupported type: ${type}`);
793            }
794    }
795}
796function getFieldSize(field) {
797    if (field.type === 'string' || field.type === 'bytes') {
798        return field.size;
799    }
800    return getNativeTypeSize(field.type);
801}
802function getStructFieldPadding(offset, size) {
803    const remainder = offset % size;
804    if (remainder) {
805        return size - remainder;
806    }
807    return 0;
808}
809function sizeOfStruct(fields) {
810    return fields.reduce((acc, field)=>{
811        const size = getFieldSize(field);
812        const padding = field.type === 'string' || field.type === 'bytes' ? 0 : getStructFieldPadding(acc, size);
813        return acc + padding + size;
814    }, 0);
815}
816function readStruct(module, ptr, fields) {
817    let offset = 0;
818    return fields.reduce((obj, field)=>{
819        let value;
820        let size;
821        if (field.type === 'string') {
822            size = field.size;
823            value = module.UTF8ToString(ptr + offset, size);
824        } else if (field.type === 'bytes') {
825            size = field.size;
826            value = module.HEAPU8.slice(ptr + offset, ptr + offset + size);
827        } else {
828            size = getNativeTypeSize(field.type);
829            offset += getStructFieldPadding(offset, size);
830            value = module.getValue(ptr + offset, field.type);
831        }
832        offset += size;
833        if (field.name) {
834            return {
835                ...obj,
836                [field.name]: value
837            };
838        }
839        return obj;
840    }, {});
841}
842
843const METHODS_TYPES = defineMethods({
844    cs_open: {
845        returnType: 'number',
846        argTypes: [
847            'number',
848            'number',
849            'number'
850        ]
851    },
852    cs_disasm: {
853        returnType: 'number',
854        argTypes: [
855            'number',
856            'array',
857            'number',
858            'number',
859            'number',
860            'number'
861        ]
862    },
863    cs_free: {
864        returnType: null,
865        argTypes: [
866            'number',
867            'number'
868        ]
869    },
870    cs_close: {
871        returnType: 'number',
872        argTypes: [
873            'number'
874        ]
875    },
876    cs_option: {
877        returnType: 'number',
878        argTypes: [
879            'number',
880            'number',
881            'number'
882        ]
883    },
884    cs_reg_name: {
885        returnType: 'string',
886        argTypes: [
887            'number',
888            'number'
889        ]
890    },
891    cs_op_count: {
892        returnType: 'number',
893        argTypes: [
894            'number',
895            'number',
896            'number'
897        ]
898    },
899    cs_op_index: {
900        returnType: 'number',
901        argTypes: [
902            'number',
903            'number',
904            'number',
905            'number'
906        ]
907    },
908    cs_insn_name: {
909        returnType: 'string',
910        argTypes: [
911            'number',
912            'number'
913        ]
914    },
915    cs_group_name: {
916        returnType: 'string',
917        argTypes: [
918            'number',
919            'number'
920        ]
921    },
922    cs_insn_group: {
923        returnType: 'boolean',
924        argTypes: [
925            'number',
926            'number',
927            'number'
928        ]
929    },
930    cs_reg_read: {
931        returnType: 'boolean',
932        argTypes: [
933            'number',
934            'number',
935            'number'
936        ]
937    },
938    cs_reg_write: {
939        returnType: 'boolean',
940        argTypes: [
941            'number',
942            'number',
943            'number'
944        ]
945    },
946    cs_errno: {
947        returnType: 'number',
948        argTypes: [
949            'number'
950        ]
951    },
952    cs_version: {
953        returnType: 'number',
954        argTypes: [
955            'number',
956            'number'
957        ]
958    },
959    cs_support: {
960        returnType: 'boolean',
961        argTypes: [
962            'number'
963        ]
964    },
965    cs_strerror: {
966        returnType: 'string',
967        argTypes: [
968            'number'
969        ]
970    },
971    cs_regs_access: {
972        returnType: 'number',
973        argTypes: [
974            'number',
975            'number',
976            'number',
977            'number',
978            'number',
979            'number'
980        ]
981    },
982    malloc: {
983        returnType: 'number',
984        argTypes: [
985            'number'
986        ]
987    },
988    free: {
989        returnType: null,
990        argTypes: [
991            'number'
992        ]
993    }
994});
995let capstone;
996const INSN_FIELDS = [
997    {
998        name: 'id',
999        type: 'i32'
1000    },
1001    {
1002        name: 'address',
1003        type: 'i64'
1004    },
1005    {
1006        name: 'size',
1007        type: 'i16'
1008    },
1009    {
1010        name: 'bytes',
1011        type: 'bytes',
1012        size: 24
1013    },
1014    {
1015        name: 'mnemonic',
1016        type: 'string',
1017        size: 32
1018    },
1019    {
1020        name: 'opStr',
1021        type: 'string',
1022        size: 160
1023    },
1024    {
1025        // detail pointer
1026        type: 'i32'
1027    }
1028];
1029const INSN_SIZE = sizeOfStruct(INSN_FIELDS);
1030class Capstone {
1031    get handle() {
1032        return capstone.getValue(this.handle_ptr, '*');
1033    }
1034    setOption(opt, value) {
1035        return Capstone.call('cs_option', this.handle, opt, value);
1036    }
1037    close() {
1038        const ret = Capstone.call('cs_close', this.handle_ptr);
1039        if (ret !== CS_ERR_OK) {
1040            throw new Error(`Failed to close capstone: ${Capstone.strError(ret)}`);
1041        }
1042        this.handle_ptr = null;
1043    }
1044    static readInsn(insnPtr) {
1045        const insn = readStruct(capstone, insnPtr, INSN_FIELDS);
1046        insn.bytes = insn.bytes.subarray(0, insn.size);
1047        return insn;
1048    }
1049    disasm(data, options = {}) {
1050        const { address = 0, count: maxCount = 0 } = options;
1051        const insnPtrPtr = Capstone.call('malloc', POINTER_SIZE);
1052        const count = Capstone.call('cs_disasm', this.handle, data, data.length, BigInt(address), maxCount, insnPtrPtr);
1053        if (count === 0) {
1054            Capstone.call('free', insnPtrPtr);
1055            throw new Error(`Failed to disassemble, error: ${Capstone.strError(this.errNo())}`);
1056        }
1057        const insnPtr = capstone.getValue(insnPtrPtr, '*');
1058        const instructions = [];
1059        for(let i = 0; i < count; i++){
1060            const insn = Capstone.readInsn(insnPtr + i * INSN_SIZE);
1061            if (insn.address <= Number.MAX_SAFE_INTEGER) {
1062                insn.address = Number(insn.address);
1063            }
1064            instructions.push(insn);
1065        }
1066        Capstone.call('cs_free', insnPtr, count);
1067        Capstone.call('free', insnPtrPtr);
1068        return instructions;
1069    }
1070    getRegName(id) {
1071        return Capstone.call('cs_reg_name', this.handle, id);
1072    }
1073    getInsnName(id) {
1074        return Capstone.call('cs_insn_name', this.handle, id);
1075    }
1076    getGroupName(id) {
1077        return Capstone.call('cs_group_name', this.handle, id);
1078    }
1079    errNo() {
1080        return Capstone.call('cs_errno', this.handle);
1081    }
1082    static call(name, ...args) {
1083        const methodType = METHODS_TYPES[name];
1084        return capstone.ccall(name, methodType.returnType, methodType.argTypes, args);
1085    }
1086    static version() {
1087        const int = this.call('cs_version');
1088        /* eslint-disable no-bitwise */ return {
1089            major: int >> 8,
1090            minor: int & 0xff
1091        };
1092    /* eslint-enable no-bitwise */ }
1093    static support(query) {
1094        return this.call('cs_support', query);
1095    }
1096    static strError(errNo) {
1097        return this.call('cs_strerror', errNo);
1098    }
1099    constructor(arch, mode){
1100        this.arch = arch;
1101        this.mode = mode;
1102        this.handle_ptr = Capstone.call('malloc', POINTER_SIZE);
1103        const ret = Capstone.call('cs_open', arch, mode, this.handle_ptr);
1104        if (ret !== CS_ERR_OK) {
1105            throw new Error(`Failed to initialize capstone: ${Capstone.strError(ret)}`);
1106        }
1107    }
1108}
1109async function factory(args) {
1110    if (capstone) {
1111        return;
1112    }
1113    capstone = await capstone$1(args);
1114}
1115
1116exports.Capstone = Capstone;
1117exports.Const = _const;
1118exports.loadCapstone = factory;