python_code
stringlengths 0
679k
| repo_name
stringlengths 9
41
| file_path
stringlengths 6
149
|
|---|---|---|
#!/usr/bin/env python3
import shutil, sys, subprocess, argparse, pathlib
import platform
parser = argparse.ArgumentParser()
parser.add_argument('--private-dir', required=True)
parser.add_argument('-o', required=True)
parser.add_argument('cmparr', nargs='+')
contents = '''#include<stdio.h>
void flob(void) {
printf("Now flobbing.\\n");
}
'''
def get_pic_args():
platname = platform.system().lower()
if platname in ['windows', 'darwin'] or sys.platform == 'cygwin':
return []
return ['-fPIC']
def generate_lib_gnulike(outfile, c_file, private_dir, compiler_array):
if shutil.which('ar'):
static_linker = 'ar'
elif shutil.which('llvm-ar'):
static_linker = 'llvm-ar'
elif shutil.which('gcc-ar'):
static_linker = 'gcc-ar'
else:
sys.exit('Could not detect a static linker.')
o_file = c_file.with_suffix('.o')
compile_cmd = compiler_array + ['-c', '-g', '-O2', '-o', str(o_file), str(c_file)]
compile_cmd += get_pic_args()
subprocess.check_call(compile_cmd)
out_file = pathlib.Path(outfile)
if out_file.exists():
out_file.unlink()
link_cmd = [static_linker, 'csr', outfile, str(o_file)]
subprocess.check_call(link_cmd)
return 0
def generate_lib_msvc(outfile, c_file, private_dir, compiler_array):
static_linker = 'lib'
o_file = c_file.with_suffix('.obj')
compile_cmd = compiler_array + ['/MDd',
'/nologo',
'/ZI',
'/Ob0',
'/Od',
'/c',
'/Fo' + str(o_file),
str(c_file)]
subprocess.check_call(compile_cmd)
out_file = pathlib.Path(outfile)
if out_file.exists():
out_file.unlink()
link_cmd = [static_linker,
'/nologo',
'/OUT:' + str(outfile),
str(o_file)]
subprocess.check_call(link_cmd)
return 0
def generate_lib(outfile, private_dir, compiler_array):
private_dir = pathlib.Path(private_dir)
if not private_dir.exists():
private_dir.mkdir()
c_file = private_dir / 'flob.c'
c_file.write_text(contents)
for i in compiler_array:
if (i.endswith('cl') or i.endswith('cl.exe')) and 'clang-cl' not in i:
return generate_lib_msvc(outfile, c_file, private_dir, compiler_array)
return generate_lib_gnulike(outfile, c_file, private_dir, compiler_array)
if __name__ == '__main__':
options = parser.parse_args()
sys.exit(generate_lib(options.o, options.private_dir, options.cmparr))
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/test cases/common/208 link custom/custom_stlib.py
|
#!/usr/bin/env python3
import shutil, sys
if __name__ == '__main__':
shutil.copyfile(sys.argv[1], sys.argv[2])
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/test cases/common/208 link custom/custom_target.py
|
#!/usr/bin/env python3
# NOTE: this file does not have the executable bit set. This tests that
# Meson can automatically parse shebang lines.
import sys
template = '#define RET_VAL %s\n'
with open(sys.argv[1]) as f:
output = template % (f.readline().strip(), )
with open(sys.argv[2], 'w') as f:
f.write(output)
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/test cases/common/57 custom header generator/makeheader.py
|
#!/usr/bin/env python3
if __name__ == '__main__':
pass
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/test cases/common/83 identical target name in subproject/true.py
|
#!/usr/bin/env python3
if __name__ == '__main__':
pass
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/test cases/common/83 identical target name in subproject/subprojects/foo/true.py
|
#!/usr/bin/env python3
import sys
if len(sys.argv) != 2 or sys.argv[1] != '--version':
exit(1)
print('Version: 1.0')
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/test cases/common/26 find program/print-version-with-prefix.py
|
#!/usr/bin/env python3
import sys
if len(sys.argv) != 2 or sys.argv[1] != '--version':
exit(1)
print('1.0')
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/test cases/common/26 find program/print-version.py
|
#!/usr/bin/env python3
exit(0)
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/test cases/common/26 find program/scripts/test_subdir.py
|
#!/usr/bin/env python3
# Mimic a binary that generates an object file (e.g. windres).
import sys, subprocess
if __name__ == '__main__':
if len(sys.argv) != 4:
print(sys.argv[0], 'compiler input_file output_file')
sys.exit(1)
compiler = sys.argv[1]
ifile = sys.argv[2]
ofile = sys.argv[3]
if compiler.endswith('cl'):
cmd = [compiler, '/nologo', '/MDd', '/Fo' + ofile, '/c', ifile]
elif sys.platform == 'sunos5':
cmd = [compiler, '-fpic', '-c', ifile, '-o', ofile]
else:
cmd = [compiler, '-c', ifile, '-o', ofile]
sys.exit(subprocess.call(cmd))
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/test cases/common/121 object only target/obj_generator.py
|
#!/usr/bin/env python3
import os
import sys
out = sys.argv[1]
try:
os.mkdir(out)
except FileExistsError:
pass
for name in ('a', 'b', 'c'):
with open(os.path.join(out, name + '.html'), 'w') as f:
f.write(name)
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/test cases/common/123 custom target directory install/docgen.py
|
#!/usr/bin/env python3
import os
import os.path
import sys
def main():
name = os.path.splitext(os.path.basename(sys.argv[1]))[0]
out = sys.argv[2]
hname = os.path.join(out, name + '.h')
cname = os.path.join(out, name + '.c')
print(os.getcwd(), hname)
with open(hname, 'w') as hfile:
hfile.write('''
#pragma once
#include "export.h"
int DLL_PUBLIC {name}(void);
'''.format(name=name))
with open(cname, 'w') as cfile:
cfile.write('''
#include "{name}.h"
int {name}(void) {{
return {size};
}}
'''.format(name=name, size=len(name)))
if __name__ == '__main__':
main()
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/test cases/common/170 generator link whole/generator.py
|
#!/usr/bin/env python3
from pathlib import Path
import sys
if __name__ == '__main__':
Path(sys.argv[1]).write_text('Hello World\n')
raise SystemExit(0)
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/test cases/common/178 bothlibraries/dummy.py
|
#!/usr/bin/env python3
import sys
import argparse
parser = argparse.ArgumentParser()
parser.add_argument('input',
help='the input file')
options = parser.parse_args(sys.argv[1:])
with open(options.input) as f:
content = f.read().strip()
print(content)
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/test cases/common/90 gen extra/srcgen3.py
|
#!/usr/bin/env python3
import os
import sys
import argparse
parser = argparse.ArgumentParser()
parser.add_argument('target_dir',
help='the target dir')
parser.add_argument('stem',
help='the stem')
parser.add_argument('input',
help='the input file')
options = parser.parse_args(sys.argv[1:])
with open(options.input) as f:
content = f.read()
output_c = os.path.join(options.target_dir, options.stem + ".tab.c")
with open(output_c, 'w') as f:
f.write(content)
output_h = os.path.join(options.target_dir, options.stem + ".tab.h")
h_content = '''#pragma once
int myfun(void);
'''
with open(output_h, 'w') as f:
f.write(h_content)
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/test cases/common/90 gen extra/srcgen2.py
|
#!/usr/bin/env python3
import sys
import argparse
parser = argparse.ArgumentParser()
parser.add_argument('--input', dest='input',
help='the input file')
parser.add_argument('--output', dest='output',
help='the output file')
parser.add_argument('--upper', dest='upper', action='store_true', default=False,
help='Convert to upper case.')
c_templ = '''int %s(void) {
return 0;
}
'''
options = parser.parse_args(sys.argv[1:])
with open(options.input) as f:
funcname = f.readline().strip()
if options.upper:
funcname = funcname.upper()
with open(options.output, 'w') as f:
f.write(c_templ % funcname)
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/test cases/common/90 gen extra/srcgen.py
|
#!/usr/bin/env python3
import sys
if sys.argv[1] == 'correct':
print('Argument is correct.')
sys.exit(0)
print('Argument is incorrect:', sys.argv[1])
sys.exit(1)
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/test cases/common/70 external test program/mytest.py
|
#!/usr/bin/env python3
import sys
import shutil
shutil.copyfile(sys.argv[1], sys.argv[2])
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/test cases/common/127 generated assembly/copyfile.py
|
#!/usr/bin/env python3
import sys, os
if len(sys.argv) != 2:
print(sys.argv[0], '<output dir>')
odir = sys.argv[1]
with open(os.path.join(odir, 'mylib.h'), 'w') as f:
f.write('int func(void);\n')
with open(os.path.join(odir, 'mylib.c'), 'w') as f:
f.write('''int func(void) {
return 0;
}
''')
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/test cases/common/54 custom target source output/generator.py
|
#!/usr/bin/env python3
import sys
if __name__ == '__main__':
if len(sys.argv) != 3:
print(sys.argv[0], 'input_file output_file')
sys.exit(1)
with open(sys.argv[1]) as f:
ifile = f.read()
if ifile != 'This is a text only input file.\n':
print('Malformed input')
sys.exit(1)
with open(sys.argv[2], 'w') as ofile:
ofile.write('This is a binary output file.\n')
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/test cases/common/50 custom target chain/my_compiler.py
|
#!/usr/bin/env python3
import sys
if __name__ == '__main__':
if len(sys.argv) != 3:
print(sys.argv[0], 'input_file output_file')
sys.exit(1)
with open(sys.argv[1]) as f:
ifile = f.read()
if ifile != 'This is a binary output file.\n':
print('Malformed input')
sys.exit(1)
with open(sys.argv[2], 'w') as ofile:
ofile.write('This is a different binary output file.\n')
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/test cases/common/50 custom target chain/my_compiler2.py
|
#!/usr/bin/env python3
import sys
with open(sys.argv[1], 'rb') as ifile:
with open(sys.argv[2], 'w') as ofile:
ofile.write('Everything ok.\n')
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/test cases/common/50 custom target chain/usetarget/subcomp.py
|
#!/usr/bin/env python3
import sys
import argparse
def main():
parser = argparse.ArgumentParser()
parser.add_argument('file', nargs=1, type=str)
parser.add_argument('text', nargs=1, type=str)
args = parser.parse_args()
text = args.text[0]
with open(args.file[0], encoding='utf-8') as f:
for line in f:
if line.strip() == text:
return 0
return 1
if __name__ == '__main__':
sys.exit(main())
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/test cases/common/14 configure file/file_contains.py
|
#!/usr/bin/env python3
import sys, os
from pathlib import Path
if len(sys.argv) != 3:
print("Wrong amount of parameters.")
build_dir = Path(os.environ['MESON_BUILD_ROOT'])
subdir = Path(os.environ['MESON_SUBDIR'])
inputf = Path(sys.argv[1])
outputf = Path(sys.argv[2])
assert(inputf.exists())
with outputf.open('w') as ofile:
ofile.write("#define ZERO_RESULT 0\n")
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/test cases/common/14 configure file/generator.py
|
#!/usr/bin/env python3
import sys
import argparse
import os
def main():
parser = argparse.ArgumentParser()
parser.add_argument('text', nargs='*', type=str)
args = parser.parse_args()
text = args.text if isinstance(args.text, list) else [args.text]
output = ''
for t in text:
t = os.path.basename(t)
if not output:
output += t
else:
output += ' ' + t
output += '\n'
sys.stdout.write(output)
if __name__ == '__main__':
sys.exit(main())
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/test cases/common/14 configure file/basename.py
|
#!/usr/bin/env python3
import sys
import argparse
from pathlib import Path
def main():
parser = argparse.ArgumentParser()
parser.add_argument('files', nargs='*', type=str)
args = parser.parse_args()
for filepath in args.files:
Path(filepath).touch()
if __name__ == '__main__':
sys.exit(main())
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/test cases/common/14 configure file/touch.py
|
#!/usr/bin/env python3
import sys, os
from pathlib import Path
if len(sys.argv) != 3:
print("Wrong amount of parameters.")
build_dir = Path(os.environ['MESON_BUILD_ROOT'])
subdir = Path(os.environ['MESON_SUBDIR'])
outputf = Path(sys.argv[1])
with outputf.open('w') as ofile:
ofile.write("#define ZERO_RESULT 0\n")
depf = Path(sys.argv[2])
if not depf.exists():
with depf.open('w') as ofile:
ofile.write(f"{outputf.name}: depfile\n")
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/test cases/common/14 configure file/generator-deps.py
|
#!/usr/bin/env python3
import sys, os
from pathlib import Path
if len(sys.argv) != 2:
print("Wrong amount of parameters.")
build_dir = Path(os.environ['MESON_BUILD_ROOT'])
subdir = Path(os.environ['MESON_SUBDIR'])
outputf = Path(sys.argv[1])
with outputf.open('w') as ofile:
ofile.write("#define ZERO_RESULT 0\n")
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/test cases/common/14 configure file/generator-without-input-file.py
|
#!/usr/bin/env python3
import os
import sys
def permit_osx_workaround(m1, m2):
import platform
if platform.system().lower() != 'darwin':
return False
if m2 % 10000 != 0:
return False
if m1//10000 != m2//10000:
return False
return True
if len(sys.argv) == 2:
assert(os.path.exists(sys.argv[1]))
elif len(sys.argv) == 3:
f1 = sys.argv[1]
f2 = sys.argv[2]
m1 = os.stat(f1).st_mtime_ns
m2 = os.stat(f2).st_mtime_ns
# Compare only os.stat()
if m1 != m2:
# Under macOS the lower four digits sometimes get assigned
# zero, even though shutil.copy2 should preserve metadata.
# Just have to accept it, I guess.
if not permit_osx_workaround(m1, m2):
raise RuntimeError(f'mtime of {f1!r} ({m1!r}) != mtime of {f2!r} ({m2!r})')
import filecmp
if not filecmp.cmp(f1, f2):
raise RuntimeError(f'{f1!r} != {f2!r}')
else:
raise AssertionError
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/test cases/common/14 configure file/check_file.py
|
#!/usr/bin/env python3
import sys
from pathlib import Path
files = [Path(f) for f in sys.argv[1:]]
names = [f.name for f in files]
assert names == ['check_inputs.txt', 'prog.c', 'prog.c', 'prog2.c', 'prog4.c', 'prog5.c']
for f in files[1:]:
assert f.exists()
with files[0].open('w') as ofile:
ofile.write("#define ZERO_RESULT 0\n")
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/test cases/common/14 configure file/check_inputs.py
|
#!/usr/bin/env python3
import sys
data = open(sys.argv[1], 'rb').read()
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/test cases/common/92 test workdir/subdir/checker.py
|
#! /usr/bin/env python3
import json
import sys
import os
cc = None
output = None
# Only the ninja backend produces compile_commands.json
if sys.argv[1] == 'ninja':
with open('compile_commands.json', 'r') as f:
cc = json.load(f)
output = set((x['output'] for x in cc))
for obj in sys.argv[2:]:
if not os.path.exists(obj):
sys.exit(1)
if sys.argv[1] == 'ninja' and obj not in output:
sys.exit(1)
print('Verified', obj)
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/test cases/common/22 object extraction/check-obj.py
|
#!/usr/bin/env python3
import sys
import shutil
shutil.copyfile(sys.argv[1], sys.argv[2])
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/test cases/common/88 dep fallback/gensrc.py
|
#!/usr/bin/env python3
import sys
with open(sys.argv[1], 'w') as f:
f.write('')
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/test cases/common/88 dep fallback/subprojects/boblib/genbob.py
|
# Copyright © 2017 Intel Corporation
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import argparse
import textwrap
HEADER = textwrap.dedent('''\
void stringify(int foo, char * buffer);
''')
CODE = textwrap.dedent('''\
#include <stdio.h>
#ifndef WORKS
# error "This shouldn't have been included"
#endif
void stringify(int foo, char * buffer) {
sprintf(buffer, "%i", foo);
}
''')
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--header')
parser.add_argument('--code')
args = parser.parse_args()
with open(args.header, 'w') as f:
f.write(HEADER)
with open(args.code, 'w') as f:
f.write(CODE)
if __name__ == '__main__':
main()
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/test cases/common/152 index customtarget/gen_sources.py
|
#!python3
import sys
from pathlib import Path
def main():
if len(sys.argv) != 2:
print(sys.argv)
return 1
if sys.argv[1] != 'gen.c':
print(sys.argv)
return 2
Path('foo').touch()
return 0
if __name__ == '__main__':
sys.exit(main())
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/test cases/common/152 index customtarget/check_args.py
|
#!/usr/bin/env python3
import sys
with open(sys.argv[1], 'w') as f:
print('# this file does nothing', file=f)
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/test cases/common/144 link depends custom target/make_file.py
|
#!/usr/bin/env python3
import sys, os
dirname = sys.argv[1]
fname = os.path.join(dirname, 'file.txt')
os.makedirs(dirname, exist_ok=True)
open(fname, 'w').close()
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/test cases/common/8 install/gendir.py
|
#!/usr/bin/env python3
import sys
with open(sys.argv[1], 'w') as f:
f.write('Test')
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/test cases/common/128 build by default targets in tests/write_file.py
|
#!/usr/bin/env python3
import sys, os
assert(len(sys.argv) == 3)
h_templ = '''#pragma once
unsigned int %s(void);
'''
c_templ = '''#include"%s.h"
unsigned int %s(void) {
return 0;
}
'''
ifile = sys.argv[1]
outdir = sys.argv[2]
base = os.path.splitext(os.path.split(ifile)[-1])[0]
cfile = os.path.join(outdir, base + '.c')
hfile = os.path.join(outdir, base + '.h')
c_code = c_templ % (base, base)
h_code = h_templ % base
with open(cfile, 'w') as f:
f.write(c_code)
with open(hfile, 'w') as f:
f.write(h_code)
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/test cases/common/86 private include/stlib/compiler.py
|
#!/usr/bin/env python3
import shutil, sys, subprocess, argparse, pathlib
parser = argparse.ArgumentParser()
parser.add_argument('--private-dir', required=True)
parser.add_argument('-o', nargs='+', required=True)
parser.add_argument('cmparr', nargs='+')
contents = ['''#include<stdio.h>
void flob_1() {
printf("Now flobbing #1.\\n");
}
''', '''#include<stdio.h>
void flob_2() {
printf("Now flobbing #2.\\n");
}
''']
def generate_lib_gnulike(outfile, c_file, private_dir, compiler_array):
if shutil.which('ar'):
static_linker = 'ar'
elif shutil.which('llvm-ar'):
static_linker = 'llvm-ar'
elif shutil.which('gcc-ar'):
static_linker = 'gcc-ar'
else:
sys.exit('Could not detect a static linker.')
o_file = c_file.with_suffix('.o')
compile_cmd = compiler_array + ['-c', '-g', '-O2', '-o', str(o_file), str(c_file)]
subprocess.check_call(compile_cmd)
out_file = pathlib.Path(outfile)
if out_file.exists():
out_file.unlink()
link_cmd = [static_linker, 'csr', outfile, str(o_file)]
subprocess.check_call(link_cmd)
return 0
def generate_lib_msvc(outfile, c_file, private_dir, compiler_array):
static_linker = 'lib'
o_file = c_file.with_suffix('.obj')
compile_cmd = compiler_array + ['/MDd',
'/nologo',
'/ZI',
'/Ob0',
'/Od',
'/c',
'/Fo' + str(o_file),
str(c_file)]
subprocess.check_call(compile_cmd)
out_file = pathlib.Path(outfile)
if out_file.exists():
out_file.unlink()
link_cmd = [static_linker,
'/nologo',
'/OUT:' + str(outfile),
str(o_file)]
subprocess.check_call(link_cmd)
return 0
def generate_lib(outfiles, private_dir, compiler_array):
private_dir = pathlib.Path(private_dir)
if not private_dir.exists():
private_dir.mkdir()
for i, content in enumerate(contents):
c_file = private_dir / ('flob_' + str(i + 1) + '.c')
c_file.write_text(content)
outfile = outfiles[i]
cl_found = False
for cl_arg in compiler_array:
if (cl_arg.endswith('cl') or cl_arg.endswith('cl.exe')) and 'clang-cl' not in cl_arg:
ret = generate_lib_msvc(outfile, c_file, private_dir, compiler_array)
if ret > 0:
return ret
else:
cl_found = True
break
if not cl_found:
ret = generate_lib_gnulike(outfile, c_file, private_dir, compiler_array)
if ret > 0:
return ret
return 0
if __name__ == '__main__':
options = parser.parse_args()
sys.exit(generate_lib(options.o, options.private_dir, options.cmparr))
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/test cases/common/210 link custom_i multiple from multiple/generate_stlibs.py
|
#!/usr/bin/env python3
import sys
import shutil
if '@INPUT1@' in sys.argv[1]:
shutil.copyfile(sys.argv[2], sys.argv[3])
else:
sys.exit('String @INPUT1@ not found in "{}"'.format(sys.argv[1]))
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/test cases/common/160 custom target template substitution/checkcopy.py
|
#!/usr/bin/env python3
"""
generate sequence of filename that does not exceed MAX_LEN=260
for Python < 3.6 and Windows without modified registry
"""
import sys
import string
name_len = 260 - len(sys.argv[2]) - 4 - 39 - 4 - 2
if name_len < 1:
raise ValueError('The meson build directory pathname is so long '
'that we cannot generate filenames within 260 characters.')
# leave room for suffix and file separators, and meson generated text
# e.g. ".c.obj.d" and other decorators added by Meson at configuration
# for intermediate files
base = string.ascii_letters * 5 # 260 characters
max_num_len = len(str(sys.argv[1]))
base = base[: name_len - max_num_len]
for i in range(int(sys.argv[1])):
print("{base}{i:0{max_num_len}d}".format(base=base, max_num_len=max_num_len, i=i))
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/test cases/common/227 very long commmand line/name_gen.py
|
#!/usr/bin/env python3
import sys
from pathlib import Path
Path(sys.argv[2]).write_text(
'int func{n}(void) {{ return {n}; }}'.format(n=sys.argv[1]))
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/test cases/common/227 very long commmand line/codegen.py
|
#!/usr/bin/env python3
import sys
def main():
with open(sys.argv[1], 'w') as out:
out.write(sys.argv[2])
out.write('\n')
if __name__ == '__main__':
main()
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/test cases/common/186 test depends/gen.py
|
#!/usr/bin/env python3
import os
import os.path
import sys
def main():
print('Looking in:', os.getcwd())
not_found = list()
for f in sys.argv[1:]:
if not os.path.exists(f):
not_found.append(f)
if not_found:
print('Not found:', ', '.join(not_found))
sys.exit(1)
if __name__ == '__main__':
main()
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/test cases/common/186 test depends/test.py
|
#!/usr/bin/env python3
import sys
expected = {
'newline': '\n',
'dollar': '$',
'colon': ':',
'space': ' ',
'multi1': ' ::$$ ::$$',
'multi2': ' ::$$\n\n \n\n::$$',
}
output = None
for arg in sys.argv[1:]:
try:
name, value = arg.split('=', 1)
except ValueError:
output = arg
continue
if expected[name] != value:
raise RuntimeError('{!r} is {!r} but should be {!r}'.format(name, value, expected[name]))
if output is not None:
with open(output, 'w') as f:
f.write('Success!')
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/test cases/common/141 special characters/check_quoting.py
|
#!/usr/bin/env python3
import sys
ifile = sys.argv[1]
ofile = sys.argv[2]
with open(ifile) as f:
resname = f.readline().strip()
templ = 'const char %s[] = "%s";\n'
with open(ofile, 'w') as f:
f.write(templ % (resname, resname))
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/test cases/common/105 generatorcustom/gen.py
|
#!/usr/bin/env python3
import sys
output = sys.argv[-1]
inputs = sys.argv[1:-1]
with open(output, 'w') as ofile:
ofile.write('#pragma once\n')
for i in inputs:
with open(i) as ifile:
content = ifile.read()
ofile.write(content)
ofile.write('\n')
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/test cases/common/105 generatorcustom/catter.py
|
#!/usr/bin/env python3
import sys
ofile = sys.argv[1]
num = sys.argv[2]
with open(ofile, 'w') as f:
f.write(f'res{num}\n')
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/test cases/common/105 generatorcustom/gen-resx.py
|
#!/usr/bin/env python3
# Mimic a binary that generates an object file (e.g. windres).
import sys, subprocess
if __name__ == '__main__':
if len(sys.argv) != 4:
print(sys.argv[0], 'compiler input_file output_file')
sys.exit(1)
compiler = sys.argv[1]
ifile = sys.argv[2]
ofile = sys.argv[3]
if compiler.endswith('cl'):
cmd = [compiler, '/nologo', '/MDd', '/Fo' + ofile, '/c', ifile]
else:
cmd = [compiler, '-c', ifile, '-o', ofile]
sys.exit(subprocess.call(cmd))
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/test cases/common/135 custom target object output/obj_generator.py
|
#!/usr/bin/env python3
import sys
if __name__ == '__main__':
if len(sys.argv) != 2:
print(sys.argv[0], 'input_file')
sys.exit(1)
with open(sys.argv[1]) as f:
ifile = f.read()
if ifile != 'This is a text only input file.\n':
print('Malformed input')
sys.exit(1)
print('This is a binary output file.')
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/test cases/common/109 custom target capture/my_compiler.py
|
#!/usr/bin/env python3
import sys
import shutil
shutil.copyfile(sys.argv[1], sys.argv[2])
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/test cases/vala/8 generated sources/src/copy_file.py
|
#!/usr/bin/env python3
import sys
contents = '''
void print_wrapper(string arg) {
print (arg);
}
'''
with open(sys.argv[1], 'w') as f:
f.write(contents)
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/test cases/vala/8 generated sources/src/write_wrapper.py
|
#!/usr/bin/env python3
import sys
c = '''int
retval(void) {
return 0;
}
'''
with open(sys.argv[1], 'w') as f:
f.write(c)
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/test cases/vala/10 mixed sources/c/writec.py
|
#!/usr/bin/env python3
import sys
with open(sys.argv[1], 'w') as f:
print('EXPORTS', file=f)
print(' somedllfunc', file=f)
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/test cases/windows/10 vs module defs generated custom target/subdir/make_def.py
|
#!/usr/bin/env python3
import sys
with open(sys.argv[1], 'rb') as infile, open(sys.argv[2], 'wb') as outfile:
outfile.write(infile.read())
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/test cases/windows/14 resources with custom target depend_files/ico/gen-ico.py
|
#!/usr/bin/env python3
import sys
import shutil
shutil.copyfile(sys.argv[1], sys.argv[2])
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/test cases/windows/7 dll versioning/copyfile.py
|
#!/usr/bin/env python3
import os
import sys
try:
import pefile
except ImportError:
if 'CI' in os.environ:
raise
# Skip the test if not on CI
sys.exit(77)
executable = sys.argv[1]
expected = int(sys.argv[2])
actual = pefile.PE(executable).dump_dict()['OPTIONAL_HEADER']['Subsystem']['Value']
print('subsystem expected: %d, actual: %d' % (expected, actual))
sys.exit(0 if (expected == actual) else 1)
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/test cases/windows/16 gui app/gui_app_tester.py
|
import subprocess
import argparse
import sys
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('prog')
args = parser.parse_args()
res = subprocess.run(args.prog)
sys.exit(res.returncode - 42)
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/test cases/windows/13 test argument extra paths/test/test_run_exe.py
|
#!/usr/bin/env python3
print('ext/noext')
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/test cases/windows/8 find program/test-script-ext.py
|
#!/usr/bin/env python3
import sys
with open(sys.argv[1]) as infile, open(sys.argv[2], 'w') as outfile:
outfile.write(infile.read().format(icon=sys.argv[3]))
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/test cases/windows/12 resources with custom targets/res/gen-res.py
|
#!/usr/bin/env python3
import sys
import shutil
shutil.copy(sys.argv[1], sys.argv[2])
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/test cases/frameworks/7 gnome/resources/copyfile.py
|
#!/usr/bin/env python3
import os
from gi.repository import Gio
if __name__ == '__main__':
res = Gio.resource_load(os.path.join('resources', 'simple-resources.gresource'))
Gio.Resource._register(res)
data = Gio.resources_lookup_data('/com/example/myprog/res1.txt', Gio.ResourceLookupFlags.NONE)
assert(data.get_data() == b'This is a resource.\n')
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/test cases/frameworks/7 gnome/resources/resources.py
|
#!/usr/bin/env python3
from gi.repository import Meson, MesonDep1, MesonDep2
if __name__ == "__main__":
s = Meson.Sample.new()
dep1 = MesonDep1.Dep1.new()
dep2 = MesonDep2.Dep2.new("Hello, meson/py!")
s.print_message(dep1, dep2)
s2 = Meson.Sample2.new()
s2.print_message()
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/test cases/frameworks/7 gnome/gir/prog.py
|
#!/usr/bin/env python3
# SPDX-License-Identifier: Apache-2.0
# Copyright © 2021 Intel Corproation
import argparse
import shutil
def main() -> None:
parser = argparse.ArgumentParser()
parser.add_argument('src')
parser.add_argument('dest')
args = parser.parse_args()
shutil.copy(args.src, args.dest)
if __name__ == "__main__":
main()
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/test cases/frameworks/7 gnome/gir/copy.py
|
import sys
sys.path.append(sys.argv[1])
# import compiled python module depending on version of python we are running with
if sys.version_info[0] == 2:
import python2_module
if sys.version_info[0] == 3:
import python3_module
def run():
msg = 'howdy'
if sys.version_info[0] == 2:
w = python2_module.World()
if sys.version_info[0] == 3:
w = python3_module.World()
w.set(msg)
assert(msg == w.greet())
version_string = str(sys.version_info[0]) + "." + str(sys.version_info[1])
assert(version_string == w.version())
if __name__ == '__main__':
run()
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/test cases/frameworks/1 boost/test_python_module.py
|
#!/usr/bin/env python3
from gi.repository import MesonSub
if __name__ == "__main__":
s = MesonSub.Sample.new("Hello, sub/meson/py!")
s.print_message()
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/test cases/frameworks/11 gir subproject/gir/prog.py
|
#!/usr/bin/env python3
import os, sys, shutil
ifile = sys.argv[1]
ofile = sys.argv[2]
try:
os.unlink(ofile)
except FileNotFoundError:
pass
shutil.copy(ifile, ofile)
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/test cases/frameworks/6 gettext/generated/desktopgenerator.py
|
#!/usr/bin/env python3
import sys
DOC_HEADER = '''<?xml version='1.0'?>
<?xml-stylesheet type="text/xsl" href="http://docbook.sourceforge.net/release/xsl/current/xhtml/docbook.xsl"?>
<!DOCTYPE refentry PUBLIC "-//OASIS//DTD DocBook XML V4.2//EN" "http://www.oasis-open.org/docbook/xml/4.2/docbookx.dtd">
<refentry id="{0}">
<refmeta>
<refentrytitle role="top_of_page" id="{0}.top_of_page">{0}</refentrytitle>
<refmiscinfo>{0}</refmiscinfo>
</refmeta>
<refnamediv>
<refname>{0}</refname>
<refpurpose></refpurpose>
</refnamediv>
<refsect2 id="{1}" role="enum">
<title>enum {1}</title>
<indexterm zone="{1}">
<primary>{1}</primary>
</indexterm>
<para><link linkend="{1}">{1}</link></para>
<refsect3 role="enum_members">
<title>Values</title>
<informaltable role="enum_members_table" pgwide="1" frame="none">
<tgroup cols="4">
<colspec colname="enum_members_name" colwidth="300px" />
<colspec colname="enum_members_value" colwidth="100px"/>
<colspec colname="enum_members_description" />
<tbody>
'''
DOC_ENUM = ''' <row role="constant">
<entry role="enum_member_name"><para>{0}</para><para></para></entry>
<entry role="enum_member_value"><para>= <literal>{1}</literal></para><para></para></entry>
<entry role="enum_member_description"></entry>
</row>'''
DOC_FOOTER = '''
</tbody>
</tgroup>
</informaltable>
</refsect3>
</refsect2>
</refentry>
'''
if __name__ == '__main__':
if len(sys.argv) >= 4:
with open(sys.argv[1], 'w') as doc_out:
enum_name = sys.argv[2]
enum_type = sys.argv[3]
doc_out.write(DOC_HEADER.format(enum_name, enum_type))
for i, enum in enumerate(sys.argv[4:]):
doc_out.write(DOC_ENUM.format(enum, i))
doc_out.write(DOC_FOOTER)
else:
print('Use: ' + sys.argv[0] + ' out name type [enums]')
sys.exit(0)
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/test cases/frameworks/10 gtk-doc/include/generate-enums-docbook.py
|
#!/usr/bin/env python3
import sys
if len(sys.argv) > 1:
with open(sys.argv[1], "w") as output:
output.write("Hello World")
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/test cases/frameworks/4 qt/subfolder/generator.py
|
#!/usr/bin/env python3
import argparse
import subprocess
def main():
parser = argparse.ArgumentParser()
parser.add_argument('ldd')
parser.add_argument('bin')
args = parser.parse_args()
p, o, _ = subprocess.run([args.ldd, args.bin], stdout=subprocess.PIPE)
assert p == 0
o = o.decode()
assert 'libstuff.so =>' in o, 'libstuff so not in linker path.'
assert 'libstuff.so => not found' not in o, 'libstuff.so not found correctly'
if __name__ == '__main__':
main()
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/test cases/d/3 shared library/lld-test.py
|
# Copyright 2021 The Meson development team
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
# http://www.apache.org/licenses/LICENSE-2.0
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# This script is used by coverage (see tools/run_with_cov.py) to enable coverage
# reports in python subprocesses
import coverage
coverage.process_startup()
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/ci/usercustomize.py
|
#!/usr/bin/env python3
import json
import argparse
import stat
import textwrap
import shutil
import subprocess
from tempfile import TemporaryDirectory
from pathlib import Path
import typing as T
image_namespace = 'mesonbuild'
image_def_file = 'image.json'
install_script = 'install.sh'
class ImageDef:
def __init__(self, image_dir: Path) -> None:
path = image_dir / image_def_file
data = json.loads(path.read_text(encoding='utf-8'))
assert isinstance(data, dict)
assert all([x in data for x in ['base_image', 'env']])
assert isinstance(data['base_image'], str)
assert isinstance(data['env'], dict)
self.base_image: str = data['base_image']
self.args: T.List[str] = data.get('args', [])
self.env: T.Dict[str, str] = data['env']
class BuilderBase():
def __init__(self, data_dir: Path, temp_dir: Path) -> None:
self.data_dir = data_dir
self.temp_dir = temp_dir
self.common_sh = self.data_dir.parent / 'common.sh'
self.common_sh = self.common_sh.resolve(strict=True)
self.validate_data_dir()
self.image_def = ImageDef(self.data_dir)
self.docker = shutil.which('docker')
self.git = shutil.which('git')
if self.docker is None:
raise RuntimeError('Unable to find docker')
if self.git is None:
raise RuntimeError('Unable to find git')
def validate_data_dir(self) -> None:
files = [
self.data_dir / image_def_file,
self.data_dir / install_script,
]
if not self.data_dir.exists():
raise RuntimeError(f'{self.data_dir.as_posix()} does not exist')
for i in files:
if not i.exists():
raise RuntimeError(f'{i.as_posix()} does not exist')
if not i.is_file():
raise RuntimeError(f'{i.as_posix()} is not a regular file')
class Builder(BuilderBase):
def gen_bashrc(self) -> None:
out_file = self.temp_dir / 'env_vars.sh'
out_data = ''
# run_tests.py parameters
self.image_def.env['CI_ARGS'] = ' '.join(self.image_def.args)
for key, val in self.image_def.env.items():
out_data += f'export {key}="{val}"\n'
# Also add /ci to PATH
out_data += 'export PATH="/ci:$PATH"\n'
out_file.write_text(out_data, encoding='utf-8')
# make it executable
mode = out_file.stat().st_mode
out_file.chmod(mode | stat.S_IEXEC)
def gen_dockerfile(self) -> None:
out_file = self.temp_dir / 'Dockerfile'
out_data = textwrap.dedent(f'''\
FROM {self.image_def.base_image}
ADD install.sh /ci/install.sh
ADD common.sh /ci/common.sh
ADD env_vars.sh /ci/env_vars.sh
RUN /ci/install.sh
''')
out_file.write_text(out_data, encoding='utf-8')
def do_build(self) -> None:
# copy files
for i in self.data_dir.iterdir():
shutil.copy(str(i), str(self.temp_dir))
shutil.copy(str(self.common_sh), str(self.temp_dir))
self.gen_bashrc()
self.gen_dockerfile()
cmd_git = [self.git, 'rev-parse', '--short', 'HEAD']
res = subprocess.run(cmd_git, cwd=self.data_dir, stdout=subprocess.PIPE)
if res.returncode != 0:
raise RuntimeError('Failed to get the current commit hash')
commit_hash = res.stdout.decode().strip()
cmd = [
self.docker, 'build',
'-t', f'{image_namespace}/{self.data_dir.name}:latest',
'-t', f'{image_namespace}/{self.data_dir.name}:{commit_hash}',
'--pull',
self.temp_dir.as_posix(),
]
if subprocess.run(cmd).returncode != 0:
raise RuntimeError('Failed to build the docker image')
class ImageTester(BuilderBase):
def __init__(self, data_dir: Path, temp_dir: Path, ci_root: Path) -> None:
super().__init__(data_dir, temp_dir)
self.meson_root = ci_root.parent.parent.resolve()
def gen_dockerfile(self) -> None:
out_file = self.temp_dir / 'Dockerfile'
out_data = textwrap.dedent(f'''\
FROM {image_namespace}/{self.data_dir.name}
ADD meson /meson
''')
out_file.write_text(out_data, encoding='utf-8')
def copy_meson(self) -> None:
shutil.copytree(
self.meson_root,
self.temp_dir / 'meson',
ignore=shutil.ignore_patterns(
'.git',
'*_cache',
'__pycache__',
# 'work area',
self.temp_dir.name,
)
)
def do_test(self, tty: bool = False) -> None:
self.copy_meson()
self.gen_dockerfile()
try:
build_cmd = [
self.docker, 'build',
'-t', 'meson_test_image',
self.temp_dir.as_posix(),
]
if subprocess.run(build_cmd).returncode != 0:
raise RuntimeError('Failed to build the test docker image')
test_cmd = []
if tty:
test_cmd = [
self.docker, 'run', '--rm', '-t', '-i', 'meson_test_image',
'/bin/bash', '-c', ''
+ 'cd meson;'
+ 'source /ci/env_vars.sh;'
+ f'echo -e "\\n\\nInteractive test shell in the {image_namespace}/{self.data_dir.name} container with the current meson tree";'
+ 'echo -e "The file ci/ciimage/user.sh will be sourced if it exists to enable user specific configurations";'
+ 'echo -e "Run the following command to run all CI tests: ./run_tests.py $CI_ARGS\\n\\n";'
+ '[ -f ci/ciimage/user.sh ] && exec /bin/bash --init-file ci/ciimage/user.sh;'
+ 'exec /bin/bash;'
]
else:
test_cmd = [
self.docker, 'run', '--rm', '-t', 'meson_test_image',
'/bin/bash', '-c', 'source /ci/env_vars.sh; cd meson; ./run_tests.py $CI_ARGS'
]
if subprocess.run(test_cmd).returncode != 0 and not tty:
raise RuntimeError('Running tests failed')
finally:
cleanup_cmd = [self.docker, 'rmi', '-f', 'meson_test_image']
subprocess.run(cleanup_cmd).returncode
def main() -> None:
parser = argparse.ArgumentParser(description='Meson CI image builder')
parser.add_argument('what', type=str, help='Which image to build / test')
parser.add_argument('-t', '--type', choices=['build', 'test', 'testTTY'], help='What to do', required=True)
args = parser.parse_args()
ci_root = Path(__file__).parent
ci_data = ci_root / args.what
with TemporaryDirectory(prefix=f'{args.type}_{args.what}_', dir=ci_root) as td:
ci_build = Path(td)
print(f'Build dir: {ci_build}')
if args.type == 'build':
builder = Builder(ci_data, ci_build)
builder.do_build()
elif args.type == 'test':
tester = ImageTester(ci_data, ci_build, ci_root)
tester.do_test()
elif args.type == 'testTTY':
tester = ImageTester(ci_data, ci_build, ci_root)
tester.do_test(tty=True)
if __name__ == '__main__':
main()
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/ci/ciimage/build.py
|
#!/usr/bin/env python3
# Copyright 2019 The Meson development team
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
'''
Generates release notes for new releases of Meson build system
'''
import subprocess
import sys
import os
from glob import glob
RELNOTE_TEMPLATE = '''---
title: Release {}
short-description: Release notes for {}
...
# New features
'''
def add_to_sitemap(from_version, to_version):
'''
Adds release note entry to sitemap.txt.
'''
sitemapfile = '../sitemap.txt'
s_f = open(sitemapfile, encoding='utf-8')
lines = s_f.readlines()
s_f.close()
with open(sitemapfile, 'w', encoding='utf-8') as s_f:
for line in lines:
if 'Release-notes' in line and from_version in line:
new_line = line.replace(from_version, to_version)
s_f.write(new_line)
s_f.write(line)
def generate(from_version, to_version):
'''
Generate notes for Meson build next release.
'''
ofilename = f'Release-notes-for-{to_version}.md'
with open(ofilename, 'w', encoding='utf-8') as ofile:
ofile.write(RELNOTE_TEMPLATE.format(to_version, to_version))
for snippetfile in glob('snippets/*.md'):
snippet = open(snippetfile, encoding='utf-8').read()
ofile.write(snippet)
if not snippet.endswith('\n'):
ofile.write('\n')
ofile.write('\n')
subprocess.check_call(['git', 'rm', snippetfile])
subprocess.check_call(['git', 'add', ofilename])
add_to_sitemap(from_version, to_version)
if __name__ == '__main__':
if len(sys.argv) != 3:
print(sys.argv[0], 'from_version to_version')
sys.exit(1)
FROM_VERSION = sys.argv[1]
TO_VERSION = sys.argv[2]
os.chdir('markdown')
generate(FROM_VERSION, TO_VERSION)
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/meson/docs/genrelnotes.py
|
#!/usr/bin/env python
from __future__ import print_function
import sys
import bitstring
from capstone import *
from capstone.m68k import *
#
# Objdump with the same output as his binary cousin
#
TODO = """
TODO :
o need more testing on M68K_AM_*_DISP
o cleanup, etc ...
"""
objdump_cmd_example = 'm68k-atari-mint-objdump -b binary -D -mm68k --adjust-vma 0x30664 u/m68k.bin'
objdump_dumpheader_fmt = """
%s: file format binary
Disassembly of section .data:
%08x <.data>:"""
M68000_CODE = b"\x04\x40\x00\x40"
all_tests = (
(CS_ARCH_M68K, CS_MODE_BIG_ENDIAN | CS_MODE_M68K_060, M68000_CODE, "M68060-32 (Big-endian)"),
)
def dump_bytes(b, len):
str = ''
i = 0
while i < len:
str += format("%02x%02x " % (b[i], b[i+1]))
i += 2
return str[:-1]
def dump_op_reg(insn, op_reg):
if op_reg == M68K_REG_A7:
return "%sp"
if op_reg == M68K_REG_A6:
return "%fp"
return '%' + insn.reg_name(op_reg)
def s8(value):
return bitstring.Bits(uint=value, length=8).unpack('int')[0]
def s16(value):
return bitstring.Bits(uint=value, length=16).unpack('int')[0]
def extsign8(value):
if value & 0x80:
return 0xffffffffffffff00 + value
return value
def extsign1616(value):
if value & 0x8000:
return 0xffff0000 + value
return value
def extsign1632(value):
if value & 0x8000:
return 0xffffffffffff0000 + value
return value
def printRegbitsRange(buffer, data, prefix):
str = ''
first = 0
run_length = 0
i = 0
while i < 8:
if (data & (1 << i)):
first = i
run_length = 0
while (i < 7 and (data & (1 << (i + 1)))):
i += 1
run_length += 1
if len(buffer) or len(str):
str += "/"
str += format("%%%s%d" % (prefix, first))
if run_length > 0:
str += format("-%%%s%d" % (prefix, first + run_length))
i += 1
return str
def registerBits(op):
str = ''
data = op.register_bits
str += printRegbitsRange(str, data & 0xff, "d")
str += printRegbitsRange(str, (data >> 8) & 0xff, "a")
str += printRegbitsRange(str, (data >> 16) & 0xff, "fp")
return str
def dump_op_ea(insn, op):
s_spacing = " "
map_index_size_str = { 0: 'w', 1 : 'l' }
str = ''
if op.address_mode == M68K_AM_NONE:
if op.type == M68K_OP_REG_BITS:
return registerBits(op)
if op.type == M68K_OP_REG_PAIR:
return registerPair(op)
if op.type == M68K_OP_REG:
return dump_op_reg(insn, op.reg)
if op.address_mode == M68K_AM_REG_DIRECT_DATA:
return dump_op_reg(insn, op.reg)
if op.address_mode == M68K_AM_REG_DIRECT_ADDR:
return dump_op_reg(insn, op.reg) + "@"
if op.address_mode == M68K_AM_REGI_ADDR:
return dump_op_reg(insn, op.reg) + "@"
if op.address_mode == M68K_AM_REGI_ADDR_POST_INC:
return dump_op_reg(insn, op.reg) + "@+"
if op.address_mode == M68K_AM_REGI_ADDR_PRE_DEC:
return dump_op_reg(insn, op.reg) + "@-"
if op.address_mode == M68K_AM_REGI_ADDR_DISP:
# str = dump_op_reg(insn, op.mem.base_reg - M68K_REG_A0 + 1) #double check and fixme '+1' : 02af 899f 2622
str = dump_op_reg(insn, op.mem.base_reg)
if op.mem.disp:
str += format("@(%d)" % s16(op.mem.disp))
return str
if op.address_mode == M68K_AM_PCI_DISP:
return format("%%pc@(0x%x)" % ( extsign1616(op.mem.disp + 2)))
if op.address_mode == M68K_AM_ABSOLUTE_DATA_SHORT:
return format("0x%x" % (extsign1616(op.imm & 0xffff)))
if op.address_mode == M68K_AM_ABSOLUTE_DATA_LONG:
return format("0x%x" % (op.imm & 0xffffffff))
if op.address_mode == M68K_AM_IMMEDIATE:
if insn.op_size.type == M68K_SIZE_TYPE_FPU:
map_fpu_size_str = { M68K_FPU_SIZE_SINGLE : op.simm, M68K_FPU_SIZE_DOUBLE : op.dimm }
return format("#%f" % (insn.op_size.fpu_size[map_fpu_size_str]))
return format("#$%x" % (op.imm))
if op.address_mode in [ M68K_AM_PCI_INDEX_8_BIT_DISP, M68K_AM_AREGI_INDEX_8_BIT_DISP ]:
disp = op.mem.disp
if op.register_bits == 2:
disp = extsign8(op.mem.disp)
if op.register_bits == 4:
disp = extsign1632(op.mem.disp)
str = dump_op_reg(insn, op.mem.base_reg) + "@(" + "{0:016x}".format(disp) + "," + dump_op_reg(insn, op.mem.index_reg) + ":" + map_index_size_str[op.mem.index_size]
if op.register_bits:
str += format(":%u" % (op.register_bits))
return str + ")"
if op.address_mode in [ M68K_AM_PCI_INDEX_BASE_DISP, M68K_AM_AREGI_INDEX_BASE_DISP ]:
str += format("%s" % ( dump_op_reg(insn, op.mem.base_reg) ))
str += format("@(%016x)@(%016x" % (extsign1632(op.mem.in_disp), extsign1632(op.mem.out_disp)))
if op.mem.index_reg:
str += "," + dump_op_reg(insn, op.mem.index_reg) + ":" + map_index_size_str[op.mem.index_size]
if op.register_bits:
str += format(":%u" % (op.register_bits))
str += ")"
return str
if op.mem.in_disp > 0:
str += format("$%x" % ( op.mem.in_disp))
str += format("(")
if op.address_mode == M68K_AM_PCI_INDEX_BASE_DISP:
str_size = ''
if op.mem.index_size:
str_size = "l"
else:
str_size = "w"
str += format("pc,%s%s.%s" % ( dump_op_reg(insn, op.mem.index_reg)), s_spacing, str_size)
else:
if op.mem.base_reg != M68K_REG_INVALID:
str += format("a%d,%s" % ( op.mem.base_reg - M68K_REG_A0, s_spacing))
str_size = ''
if op.mem.index_size:
str_size = "l"
else:
str_size = "w"
str += format("%s.%s" % ( dump_op_reg(insn, op.mem.index_reg), str_size))
if op.mem.scale > 0:
str += format("%s*%s%d)" % ( s_spacing, s_spacing, op.mem.scale))
else:
str += ")"
return str
# It's ok to just use PCMI here as is as we set base_reg to PC in the disassembler.
# While this is not strictly correct it makes the code
# easier and that is what actually happens when the code is executed anyway.
if op.address_mode in [ M68K_AM_PC_MEMI_POST_INDEX, M68K_AM_PC_MEMI_PRE_INDEX, M68K_AM_MEMI_PRE_INDEX, M68K_AM_MEMI_POST_INDEX]:
if op.mem.base_reg:
str += format("%s" % ( dump_op_reg(insn, op.mem.base_reg) ))
if op.mem.in_disp:
value = op.mem.in_disp
if op.mem.in_disp & 0x8000:
value = 0xffffffffffff0000 + op.mem.in_disp
str += format("@(%016x)@(%016x)" % (value, op.mem.out_disp))
return str
str += format("([")
if op.mem.in_disp > 0:
str += format("$%x" % ( op.mem.in_disp))
if op.mem.base_reg != M68K_REG_INVALID:
if op.mem.in_disp > 0:
str += format(",%s%s" % ( s_spacing, dump_op_reg(insn, op.mem.base_reg)))
else:
str += format("%s" % ( dump_op_reg(insn, op.mem.base_reg)))
if op.address_mode in [ M68K_AM_MEMI_POST_INDEX, M68K_AM_PC_MEMI_POST_INDEX]:
str += format("]")
if op.mem.index_reg != M68K_REG_INVALID:
str_size = ''
if op.mem.index_size:
str_size = "l"
else:
str_size = "w"
str += format(",%s%s.%s" % ( s_spacing, dump_op_reg(insn, op.mem.index_reg), str_size))
if op.mem.scale > 0:
str += format("%s*%s%d" % ( s_spacing, s_spacing, op.mem.scale))
if op.address_mode in [ M68K_AM_MEMI_PRE_INDEX, M68K_AM_PC_MEMI_PRE_INDEX]:
str += format("]")
if op.mem.out_disp > 0:
str += format(",%s$%x" % ( s_spacing, op.mem.out_disp))
str += format(")")
return str
if op.mem.bitfield:
return format("%d:%d" % ( op.mem.offset, op.mem.width))
############# OK
if op.address_mode == M68K_AM_AREGI_INDEX_BASE_DISP:
if op.mem.index_size:
str_size = "l"
else:
str_size = "w"
bits = op.mem.disp
return dump_op_reg(insn, op.mem.base_reg) + "@(" + "{0:016b}".format(bits) + "," + dump_op_reg(insn, op.mem.index_reg) + ":" + str_size + ")"
return ''
# M68K Addressing Modes
map_address_mode_str = {
0 : "M68K_AM_NONE",
1 : "M68K_AM_REG_DIRECT_DATA",
2 : "M68K_AM_REG_DIRECT_ADDR",
3 : "M68K_AM_REGI_ADDR",
4 : "M68K_AM_REGI_ADDR_POST_INC",
5 : "M68K_AM_REGI_ADDR_PRE_DEC",
6 : "M68K_AM_REGI_ADDR_DISP",
7 : "M68K_AM_AREGI_INDEX_8_BIT_DISP",
8 : "M68K_AM_AREGI_INDEX_BASE_DISP",
9 : "M68K_AM_MEMI_POST_INDEX",
10 : "M68K_AM_MEMI_PRE_INDEX",
11 : "M68K_AM_PCI_DISP",
12 : "M68K_AM_PCI_INDEX_8_BIT_DISP",
13 : "M68K_AM_PCI_INDEX_BASE_DISP",
14 : "M68K_AM_PC_MEMI_POST_INDEX",
15 : "M68K_AM_PC_MEMI_PRE_INDEX",
16 : "M68K_AM_ABSOLUTE_DATA_SHORT",
17 : "M68K_AM_ABSOLUTE_DATA_LONG",
18 : "M68K_AM_IMMEDIATE",
}
# Operand type for instruction's operands
map_op_str = {
0 : "M68K_OP_INVALID",
1 : "M68K_OP_REG",
2 : "M68K_OP_IMM",
3 : "M68K_OP_MEM",
4 : "M68K_OP_FP",
5 : "M68K_OP_REG_BITS",
6 : "M68K_OP_REG_PAIR",
}
def debug(insn, op):
if len(sys.argv) > 3:
print("id %d type %s address_mode %s" % (insn.id, map_op_str[op.type], map_address_mode_str[op.address_mode]))
def dump_ops(insn):
str = ''
mnemonic = insn.insn_name()
i = 0
while i < len(insn.operands):
if i > 0:
str += ','
op = insn.operands[i]
debug(insn, op)
# "data" instruction generated by SKIPDATA option has no detail
if insn.id == M68K_INS_INVALID:
return format("0x%04x" % (op.imm))
if op.type == M68K_OP_REG:
str_op_reg = dump_op_ea(insn, op)
if str_op_reg == '' or op.address_mode == M68K_AM_REG_DIRECT_ADDR:
str_op_reg = dump_op_reg(insn, op.reg)
str += str_op_reg
if op.type == M68K_OP_IMM:
str_op_imm = format("#%u" % (op.imm))
if mnemonic in ["bkpt"]:
str_op_imm = format("%u" % (op.imm))
signed_insn = [ "move", "moveq", "cmp", "cmpi", "ori", "bclr", "pack", "unpk", "sub", "add" ]
if mnemonic in signed_insn:
if insn.op_size.size == 1 or mnemonic == "moveq":
str_op_imm = format("#%d" % s8(op.imm))
if insn.op_size.size == 2 or mnemonic == "pack":
str_op_imm = format("#%d" % s16(op.imm))
if insn.op_size.size == 4:
str_op_imm = format("#%d" % (op.imm))
dbxx_insn = [ "dbt", "dbf", "dbhi", "dbls", "dbcc", "dbcs", "dbne", "dbeq", "dbvc", "dbvs", "dbpl", "dbmi", "dbge", "dblt", "dbgt", "dble", "dbra" ]
if is_branch(insn) or mnemonic in dbxx_insn:
str_op_imm = format("0x%x" % (op.imm & 0xffffffff))
str += str_op_imm
if op.type == M68K_OP_MEM:
str_op_mem = dump_op_ea(insn, op)
if str_op_mem == '':
str_op_mem = format("0x%x" % (op.imm))
str += str_op_mem
if op.type in [ M68K_OP_REG_BITS, M68K_OP_REG_PAIR ]:
str += dump_op_ea(insn, op)
# if insn.address == 0x3127c:
# import pdb;pdb.set_trace()
# print("type %u am %u\n" % (op.type, op.address_mode))
i += 1
return str
def is_branch(insn):
mnemonic = insn.insn_name()
branch_insn = [ "bsr", "bra", "bhi", "bls", "bcc", "bcs", "bne", "beq", "bvc", "bvs", "bpl", "bmi", "bge", "blt", "bgt", "ble" ];
return mnemonic in branch_insn
def dump_mnemonic(insn):
# "data" instruction generated by SKIPDATA option has no detail
if insn.id == M68K_INS_INVALID:
return ".short"
mnemonic = insn.insn_name()
ext = { 0: '', 1:'b', 2:'w', 4:'l' }
if is_branch(insn):
ext.update({ 1:'s', 2:'w', 4:'l' })
no_size = [ "pea", "lea", "bset", "bclr", "bchg", "btst", "nbcd", "abcd", "sbcd", "exg", "scc", "sls", "scs", "shi" ]
sxx_insn = [ "st", "sf", "shi", "sls", "scc", "scs", "sne", "seq", "svc", "svs", "spl", "smi", "sge", "slt", "sgt", "sle", "stop" ]
no_size += sxx_insn
no_size += [ "tas" ]
if mnemonic in no_size:
ext.update({ 0:'', 1:'', 2:'', 4:'' })
return mnemonic + ext[insn.op_size.size]
def print_insn_detail_np(insn):
# objdump format hack
if insn.size == 2:
space = ' ' * 11
if insn.size == 4:
space = ' ' * 6
if insn.size >= 6:
space = ' '
space_ops = ''
if len(insn.operands) > 0:
space_ops = ' '
print(" %x:\t%s%s\t%s%s%s" % (insn.address, dump_bytes(insn._raw.bytes, min(insn.size, 6)), space, dump_mnemonic(insn), space_ops, dump_ops(insn)))
if insn.size > 6:
delta = min(insn.size, 6)
print(" %x:\t%s " % (insn.address+delta, dump_bytes(insn._raw.bytes[delta:], min(insn.size-delta, 6))))
def print_objdump_dumpheader(filename='', address=0):
print(objdump_dumpheader_fmt % (filename, address))
# ## Test class Cs
def test_class():
for (arch, mode, code, comment) in all_tests:
filename = "/dev/stdin"
address = 0
if len(sys.argv) > 1:
filename = sys.argv[1]
if len(sys.argv) > 2:
address = int(sys.argv[2],16)
if len(sys.argv) > 3:
debug_mode = True
with open(filename, "rb") as f:
code = f.read()
try:
md = Cs(arch, mode)
md.detail = True
print_objdump_dumpheader(filename, address)
for insn in md.disasm(code, address):
print_insn_detail_np(insn)
except CsError as e:
print("ERROR: %s" % e)
if __name__ == '__main__':
test_class()
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/capstone/contrib/objdump/objdump-m68k.py
|
#!/usr/bin/python
# Simple benchmark for Capstone by disassembling random code. By Nguyen Anh Quynh, 2014
# Syntax:
# ./suite/benchmark.py --> Benchmark all archs
# ./suite/benchmark.py x86 --> Benchmark all X86 (all 16bit, 32bit, 64bit)
# ./suite/benchmark.py x86-32 --> Benchmark X86-32 arch only
# ./suite/benchmark.py arm --> Benchmark all ARM (arm, thumb)
# ./suite/benchmark.py aarch64 --> Benchmark ARM-64
# ./suite/benchmark.py mips --> Benchmark all Mips (32bit, 64bit)
# ./suite/benchmark.py ppc --> Benchmark PPC
from capstone import *
from time import time
from random import randint
import sys
# file providing code to disassemble
FILE = '/usr/bin/python'
all_tests = (
(CS_ARCH_X86, CS_MODE_16, "X86-16 (Intel syntax)", 0),
(CS_ARCH_X86, CS_MODE_32, "X86-32 (ATT syntax)", CS_OPT_SYNTAX_ATT),
(CS_ARCH_X86, CS_MODE_32, "X86-32 (Intel syntax)", 0),
(CS_ARCH_X86, CS_MODE_64, "X86-64 (Intel syntax)", 0),
(CS_ARCH_ARM, CS_MODE_ARM, "ARM", 0),
(CS_ARCH_ARM, CS_MODE_THUMB, "THUMB (ARM)", 0),
(CS_ARCH_MIPS, CS_MODE_MIPS32 + CS_MODE_BIG_ENDIAN, "MIPS-32 (Big-endian)", 0),
(CS_ARCH_MIPS, CS_MODE_MIPS64 + CS_MODE_LITTLE_ENDIAN, "MIPS-64-EL (Little-endian)", 0),
(CS_ARCH_ARM64, CS_MODE_ARM, "ARM-64 (AArch64)", 0),
(CS_ARCH_PPC, CS_MODE_BIG_ENDIAN, "PPC", 0),
(CS_ARCH_PPC, CS_MODE_BIG_ENDIAN, "PPC, print register with number only", CS_OPT_SYNTAX_NOREGNAME),
(CS_ARCH_SPARC, CS_MODE_BIG_ENDIAN, "Sparc", 0),
(CS_ARCH_SYSZ, 0, "SystemZ", 0),
(CS_ARCH_XCORE, 0, "XCore", 0),
(CS_ARCH_M68K, 0, "M68K", 0),
(CS_ARCH_RISCV, 0, "RISCV", 0),
)
# for debugging
def to_hex(s):
return " ".join("0x" + "{0:x}".format(ord(c)).zfill(2) for c in s) # <-- Python 3 is OK
def get_code(f, size):
code = f.read(size)
if len(code) != size: # reached end-of-file?
# then reset file position to begin-of-file
f.seek(0)
code = f.read(size)
return code
def cs(md, code):
insns = md.disasm(code, 0)
# uncomment below line to speed up this function 200 times!
# return
for i in insns:
if i.address == 0x100000:
print i
def cs_lite(md, code):
insns = md.disasm_lite(code, 0)
for (addr, size, mnem, ops) in insns:
if addr == 0x100000:
print i
cfile = open(FILE)
for (arch, mode, comment, syntax) in all_tests:
try:
request = sys.argv[1]
if not request in comment.lower():
continue
except:
pass
print("Platform: %s" %comment)
try:
md = Cs(arch, mode)
#md.detail = True
if syntax != 0:
md.syntax = syntax
# warm up few times
cfile.seek(0)
for i in xrange(3):
code = get_code(cfile, 128)
#print to_hex(code)
#print
cs(md, code)
# start real benchmark
c_t = 0
for i in xrange(50000):
code = get_code(cfile, 128)
#print to_hex(code)
#print
t1 = time()
cs(md, code)
c_t += time() - t1
print "Benchmark - full obj:", c_t, "seconds"
print
cfile.seek(0)
c_t = 0
for i in xrange(50000):
code = get_code(cfile, 128)
#print to_hex(code)
#print
t1 = time()
cs_lite(md, code)
c_t += time() - t1
print "Benchmark - lite:", c_t, "seconds"
print
except CsError as e:
print("ERROR: %s" %e)
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/capstone/suite/benchmark.py
|
#!/usr/bin/python
# Test tool to disassemble MC files. By Nguyen Anh Quynh, 2017
import array, os.path, sys
from capstone import *
# convert all hex numbers to decimal numbers in a text
def normalize_hex(a):
while(True):
i = a.find('0x')
if i == -1: # no more hex number
break
hexnum = '0x'
for c in a[i + 2:]:
if c in '0123456789abcdefABCDEF':
hexnum += c
else:
break
num = int(hexnum, 16)
a = a.replace(hexnum, str(num))
return a
def test_file(fname):
print("Test %s" %fname);
f = open(fname)
lines = f.readlines()
f.close()
if not lines[0].startswith('# '):
print("ERROR: decoding information is missing")
return
# skip '# ' at the front, then split line to get out hexcode
# Note: option can be '', or 'None'
#print lines[0]
#print lines[0][2:].split(', ')
(arch, mode, option) = lines[0][2:].split(', ')
mode = mode.replace(' ', '')
option = option.strip()
archs = {
"CS_ARCH_ARM": CS_ARCH_ARM,
"CS_ARCH_ARM64": CS_ARCH_ARM64,
"CS_ARCH_MIPS": CS_ARCH_MIPS,
"CS_ARCH_PPC": CS_ARCH_PPC,
"CS_ARCH_SPARC": CS_ARCH_SPARC,
"CS_ARCH_SYSZ": CS_ARCH_SYSZ,
"CS_ARCH_X86": CS_ARCH_X86,
"CS_ARCH_XCORE": CS_ARCH_XCORE,
"CS_ARCH_M68K": CS_ARCH_M68K,
"CS_ARCH_RISCV": CS_ARCH_RISCV,
}
modes = {
"CS_MODE_16": CS_MODE_16,
"CS_MODE_32": CS_MODE_32,
"CS_MODE_64": CS_MODE_64,
"CS_MODE_MIPS32": CS_MODE_MIPS32,
"CS_MODE_MIPS64": CS_MODE_MIPS64,
"0": CS_MODE_ARM,
"CS_MODE_ARM": CS_MODE_ARM,
"CS_MODE_THUMB": CS_MODE_THUMB,
"CS_MODE_ARM+CS_MODE_V8": CS_MODE_ARM+CS_MODE_V8,
"CS_MODE_THUMB+CS_MODE_V8": CS_MODE_THUMB+CS_MODE_V8,
"CS_MODE_THUMB+CS_MODE_MCLASS": CS_MODE_THUMB+CS_MODE_MCLASS,
"CS_MODE_LITTLE_ENDIAN": CS_MODE_LITTLE_ENDIAN,
"CS_MODE_BIG_ENDIAN": CS_MODE_BIG_ENDIAN,
"CS_MODE_64+CS_MODE_LITTLE_ENDIAN": CS_MODE_64+CS_MODE_LITTLE_ENDIAN,
"CS_MODE_64+CS_MODE_BIG_ENDIAN": CS_MODE_64+CS_MODE_BIG_ENDIAN,
"CS_MODE_MIPS32+CS_MODE_MICRO": CS_MODE_MIPS32+CS_MODE_MICRO,
"CS_MODE_MIPS32+CS_MODE_MICRO+CS_MODE_BIG_ENDIAN": CS_MODE_MIPS32+CS_MODE_MICRO+CS_MODE_BIG_ENDIAN,
"CS_MODE_MIPS32+CS_MODE_BIG_ENDIAN+CS_MODE_MICRO": CS_MODE_MIPS32+CS_MODE_MICRO+CS_MODE_BIG_ENDIAN,
"CS_MODE_BIG_ENDIAN+CS_MODE_V9": CS_MODE_BIG_ENDIAN + CS_MODE_V9,
"CS_MODE_MIPS32+CS_MODE_BIG_ENDIAN": CS_MODE_MIPS32+CS_MODE_BIG_ENDIAN,
"CS_MODE_MIPS32+CS_MODE_LITTLE_ENDIAN": CS_MODE_MIPS32+CS_MODE_LITTLE_ENDIAN,
"CS_MODE_MIPS64+CS_MODE_LITTLE_ENDIAN": CS_MODE_MIPS64+CS_MODE_LITTLE_ENDIAN,
"CS_MODE_MIPS64+CS_MODE_BIG_ENDIAN": CS_MODE_MIPS64+CS_MODE_BIG_ENDIAN,
"CS_MODE_RISCV32": CS_MODE_RISCV32,
"CS_MODE_RISCV64": CS_MODE_RISCV64,
}
options = {
"CS_OPT_SYNTAX_ATT": CS_OPT_SYNTAX_ATT,
"CS_OPT_SYNTAX_NOREGNAME": CS_OPT_SYNTAX_NOREGNAME,
}
mc_modes = {
("CS_ARCH_X86", "CS_MODE_32"): ['-triple=i386'],
("CS_ARCH_X86", "CS_MODE_64"): ['-triple=x86_64'],
("CS_ARCH_ARM", "CS_MODE_ARM"): ['-triple=armv7'],
("CS_ARCH_ARM", "CS_MODE_THUMB"): ['-triple=thumbv7'],
("CS_ARCH_ARM", "CS_MODE_ARM+CS_MODE_V8"): ['-triple=armv8'],
("CS_ARCH_ARM", "CS_MODE_THUMB+CS_MODE_V8"): ['-triple=thumbv8'],
("CS_ARCH_ARM", "CS_MODE_THUMB+CS_MODE_MCLASS"): ['-triple=thumbv7m'],
("CS_ARCH_ARM64", "0"): ['-triple=aarch64'],
("CS_ARCH_MIPS", "CS_MODE_MIPS32+CS_MODE_BIG_ENDIAN"): ['-triple=mips'],
("CS_ARCH_MIPS", "CS_MODE_MIPS32+CS_MODE_MICRO"): ['-triple=mipsel', '-mattr=+micromips'],
("CS_ARCH_MIPS", "CS_MODE_MIPS64"): ['-triple=mips64el'],
("CS_ARCH_MIPS", "CS_MODE_MIPS32"): ['-triple=mipsel'],
("CS_ARCH_MIPS", "CS_MODE_MIPS64+CS_MODE_BIG_ENDIAN"): ['-triple=mips64'],
("CS_ARCH_MIPS", "CS_MODE_MIPS32+CS_MODE_MICRO+CS_MODE_BIG_ENDIAN"): ['-triple=mips', '-mattr=+micromips'],
("CS_ARCH_MIPS", "CS_MODE_MIPS32+CS_MODE_BIG_ENDIAN+CS_MODE_MICRO"): ['-triple=mips', '-mattr=+micromips'],
("CS_ARCH_PPC", "CS_MODE_BIG_ENDIAN"): ['-triple=powerpc64'],
('CS_ARCH_SPARC', 'CS_MODE_BIG_ENDIAN'): ['-triple=sparc'],
('CS_ARCH_SPARC', 'CS_MODE_BIG_ENDIAN+CS_MODE_V9'): ['-triple=sparcv9'],
('CS_ARCH_SYSZ', '0'): ['-triple=s390x', '-mcpu=z196'],
('CS_ARCH_RISCV', 'CS_MODE_RISCV32'): ['-triple=riscv32'],
('CS_ARCH_RISCV', 'CS_MODE_RISCV64'): ['-triple=riscv64'],
}
#if not option in ('', 'None'):
# print archs[arch], modes[mode], options[option]
#print(arch, mode, option)
md = Cs(archs[arch], modes[mode])
if arch == 'CS_ARCH_ARM' or arch == 'CS_ARCH_PPC' :
md.syntax = CS_OPT_SYNTAX_NOREGNAME
if fname.endswith('3DNow.s.cs'):
md.syntax = CS_OPT_SYNTAX_ATT
for line in lines[1:]:
# ignore all the input lines having # in front.
if line.startswith('#'):
continue
#print("Check %s" %line)
code = line.split(' = ')[0]
asm = ''.join(line.split(' = ')[1:])
hex_code = code.replace('0x', '')
hex_code = hex_code.replace(',', '')
hex_data = hex_code.decode('hex')
#hex_bytes = array.array('B', hex_data)
x = list(md.disasm(hex_data, 0))
if len(x) > 0:
if x[0].op_str != '':
cs_output = "%s %s" %(x[0].mnemonic, x[0].op_str)
else:
cs_output = x[0].mnemonic
else:
cs_output = 'FAILED to disassemble'
cs_output2 = normalize_hex(cs_output)
cs_output2 = cs_output2.replace(' ', '')
if arch == 'CS_ARCH_MIPS':
# normalize register alias names
cs_output2 = cs_output2.replace('$at', '$1')
cs_output2 = cs_output2.replace('$v0', '$2')
cs_output2 = cs_output2.replace('$v1', '$3')
cs_output2 = cs_output2.replace('$a0', '$4')
cs_output2 = cs_output2.replace('$a1', '$5')
cs_output2 = cs_output2.replace('$a2', '$6')
cs_output2 = cs_output2.replace('$a3', '$7')
cs_output2 = cs_output2.replace('$t0', '$8')
cs_output2 = cs_output2.replace('$t1', '$9')
cs_output2 = cs_output2.replace('$t2', '$10')
cs_output2 = cs_output2.replace('$t3', '$11')
cs_output2 = cs_output2.replace('$t4', '$12')
cs_output2 = cs_output2.replace('$t5', '$13')
cs_output2 = cs_output2.replace('$t6', '$14')
cs_output2 = cs_output2.replace('$t7', '$15')
cs_output2 = cs_output2.replace('$t8', '$24')
cs_output2 = cs_output2.replace('$t9', '$25')
cs_output2 = cs_output2.replace('$s0', '$16')
cs_output2 = cs_output2.replace('$s1', '$17')
cs_output2 = cs_output2.replace('$s2', '$18')
cs_output2 = cs_output2.replace('$s3', '$19')
cs_output2 = cs_output2.replace('$s4', '$20')
cs_output2 = cs_output2.replace('$s5', '$21')
cs_output2 = cs_output2.replace('$s6', '$22')
cs_output2 = cs_output2.replace('$s7', '$23')
cs_output2 = cs_output2.replace('$k0', '$26')
cs_output2 = cs_output2.replace('$k1', '$27')
print("\t%s = %s" %(hex_code, cs_output))
if __name__ == '__main__':
if len(sys.argv) == 1:
fnames = sys.stdin.readlines()
for fname in fnames:
test_file(fname.strip())
else:
#print("Usage: ./test_mc.py <input-file.s.cs>")
test_file(sys.argv[1])
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/capstone/suite/disasm_mc.py
|
#!/usr/bin/env python
# Capstone by Nguyen Anh Quynnh <aquynh@gmail.com>
# PPC Branch testing suite by kratolp
from __future__ import print_function
import sys
from capstone import *
CODE32 = b"\x48\x01\x05\x15" # bl .+0x10514
CODE32 += b"\x4B\xff\xff\xfd" # bl .-0x4
CODE32 += b"\x48\x00\x00\x0c" # b .+0xc
CODE32 += b"\x41\x80\xff\xd8" # blt .-0x28
CODE32 += b"\x40\x80\xff\xec" # bge .-0x14
CODE32 += b"\x41\x84\x01\x6c" # blt cr1, .+0x16c
CODE32 += b"\x41\x82\x00\x10" # beq .+0x10
CODE32 += b"\x40\x82\x00\x08" # bne .+0x8
CODE32 += b"\x40\x95\x00\x94" # ble cr5,.+0x94
CODE32 += b"\x40\x9f\x10\x30" # bns cr5,.+0x94
CODE32 += b"\x42\x00\xff\xd8" # bdnz .-0x28
CODE32 += b"\x4d\x82\x00\x20" # beqlr
CODE32 += b"\x4e\x80\x00\x20" # blr
CODE32 += b"\x4a\x00\x00\x02" # ba .0xfe000000
CODE32 += b"\x41\x80\xff\xda" # blta .0xffffffd8
CODE32 += b"\x41\x4f\xff\x17" # bdztla 4*cr3+so, .0xffffff14
CODE32 += b"\x43\x20\x0c\x07" # bdnzla+ .0xc04
CODE32 += b"\x4c\x00\x04\x20" # bdnzfctr lt
_python3 = sys.version_info.major == 3
all_tests = (
(CS_ARCH_PPC, CS_MODE_BIG_ENDIAN, CODE32, "PPC branch instruction decoding", 0),
)
def to_hex(s):
if _python3:
return " ".join("0x{0:02x}".format(c) for c in s) # <-- Python 3 is OK
else:
return " ".join("0x{0:02x}".format(ord(c)) for c in s)
# ## Test cs_disasm_quick()
def test_cs_disasm_quick():
for (arch, mode, code, comment, syntax) in all_tests:
print("Platform: %s" % comment)
print("Code: %s" %(to_hex(code))),
print("Disasm:")
for (addr, size, mnemonic, op_str) in cs_disasm_lite(arch, mode, code, 0x1000):
print("0x%x:\t%s\t%s" % (addr, mnemonic, op_str))
print()
if __name__ == '__main__':
test_cs_disasm_quick()
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/capstone/suite/ppcbranch.py
|
#!/usr/bin/python
from capstone import *
from capstone.arm import *
from capstone.arm64 import *
from capstone.mips import *
from capstone.ppc import *
from capstone.sparc import *
from capstone.systemz import *
from capstone.x86 import *
from capstone.xcore import *
from capstone.riscv import *
import sys
class GroupTest:
def __init__(self, name, arch, mode, data):
self.name = name
self.arch = arch
self.mode = mode
self.data = data
def run(self):
print('Testing %s' %self.name)
cap = Cs(self.arch, self.mode)
for group_id in xrange(0,255):
name = self.data.get(group_id)
res = cap.group_name(group_id)
if res != name:
print("ERROR: id = %u expected '%s', but got '%s'" %(group_id, name, res))
print("")
arm_dict = {
ARM_GRP_JUMP: "jump",
ARM_GRP_CALL: "call",
ARM_GRP_INT: "int",
ARM_GRP_PRIVILEGE: "privilege",
ARM_GRP_CRYPTO: "crypto",
ARM_GRP_DATABARRIER: "databarrier",
ARM_GRP_DIVIDE: "divide",
ARM_GRP_FPARMV8: "fparmv8",
ARM_GRP_MULTPRO: "multpro",
ARM_GRP_NEON: "neon",
ARM_GRP_T2EXTRACTPACK: "T2EXTRACTPACK",
ARM_GRP_THUMB2DSP: "THUMB2DSP",
ARM_GRP_TRUSTZONE: "TRUSTZONE",
ARM_GRP_V4T: "v4t",
ARM_GRP_V5T: "v5t",
ARM_GRP_V5TE: "v5te",
ARM_GRP_V6: "v6",
ARM_GRP_V6T2: "v6t2",
ARM_GRP_V7: "v7",
ARM_GRP_V8: "v8",
ARM_GRP_VFP2: "vfp2",
ARM_GRP_VFP3: "vfp3",
ARM_GRP_VFP4: "vfp4",
ARM_GRP_ARM: "arm",
ARM_GRP_MCLASS: "mclass",
ARM_GRP_NOTMCLASS: "notmclass",
ARM_GRP_THUMB: "thumb",
ARM_GRP_THUMB1ONLY: "thumb1only",
ARM_GRP_THUMB2: "thumb2",
ARM_GRP_PREV8: "prev8",
ARM_GRP_FPVMLX: "fpvmlx",
ARM_GRP_MULOPS: "mulops",
ARM_GRP_CRC: "crc",
ARM_GRP_DPVFP: "dpvfp",
ARM_GRP_V6M: "v6m",
ARM_GRP_VIRTUALIZATION: "virtualization",
}
arm64_dict = {
ARM64_GRP_JUMP: "jump",
ARM64_GRP_CALL: "call",
ARM64_GRP_RET: "return",
ARM64_GRP_INT: "int",
ARM64_GRP_PRIVILEGE: "privilege",
ARM64_GRP_CRYPTO: "crypto",
ARM64_GRP_FPARMV8: "fparmv8",
ARM64_GRP_NEON: "neon",
ARM64_GRP_CRC: "crc"
}
mips_dict = {
MIPS_GRP_JUMP: "jump",
MIPS_GRP_CALL: "call",
MIPS_GRP_RET: "ret",
MIPS_GRP_INT: "int",
MIPS_GRP_IRET: "iret",
MIPS_GRP_PRIVILEGE: "privilege",
MIPS_GRP_BITCOUNT: "bitcount",
MIPS_GRP_DSP: "dsp",
MIPS_GRP_DSPR2: "dspr2",
MIPS_GRP_FPIDX: "fpidx",
MIPS_GRP_MSA: "msa",
MIPS_GRP_MIPS32R2: "mips32r2",
MIPS_GRP_MIPS64: "mips64",
MIPS_GRP_MIPS64R2: "mips64r2",
MIPS_GRP_SEINREG: "seinreg",
MIPS_GRP_STDENC: "stdenc",
MIPS_GRP_SWAP: "swap",
MIPS_GRP_MICROMIPS: "micromips",
MIPS_GRP_MIPS16MODE: "mips16mode",
MIPS_GRP_FP64BIT: "fp64bit",
MIPS_GRP_NONANSFPMATH: "nonansfpmath",
MIPS_GRP_NOTFP64BIT: "notfp64bit",
MIPS_GRP_NOTINMICROMIPS: "notinmicromips",
MIPS_GRP_NOTNACL: "notnacl",
MIPS_GRP_NOTMIPS32R6: "notmips32r6",
MIPS_GRP_NOTMIPS64R6: "notmips64r6",
MIPS_GRP_CNMIPS: "cnmips",
MIPS_GRP_MIPS32: "mips32",
MIPS_GRP_MIPS32R6: "mips32r6",
MIPS_GRP_MIPS64R6: "mips64r6",
MIPS_GRP_MIPS2: "mips2",
MIPS_GRP_MIPS3: "mips3",
MIPS_GRP_MIPS3_32: "mips3_32",
MIPS_GRP_MIPS3_32R2: "mips3_32r2",
MIPS_GRP_MIPS4_32: "mips4_32",
MIPS_GRP_MIPS4_32R2: "mips4_32r2",
MIPS_GRP_MIPS5_32R2: "mips5_32r2",
MIPS_GRP_GP32BIT: "gp32bit",
MIPS_GRP_GP64BIT: "gp64bit",
}
ppc_dict = {
PPC_GRP_JUMP: "jump",
PPC_GRP_ALTIVEC: "altivec",
PPC_GRP_MODE32: "mode32",
PPC_GRP_MODE64: "mode64",
PPC_GRP_BOOKE: "booke",
PPC_GRP_NOTBOOKE: "notbooke",
PPC_GRP_SPE: "spe",
PPC_GRP_VSX: "vsx",
PPC_GRP_E500: "e500",
PPC_GRP_PPC4XX: "ppc4xx",
PPC_GRP_PPC6XX: "ppc6xx",
PPC_GRP_ICBT: "icbt",
PPC_GRP_P8ALTIVEC: "p8altivec",
PPC_GRP_P8VECTOR: "p8vector",
PPC_GRP_QPX: "qpx",
}
sparc_dict = {
SPARC_GRP_JUMP: "jump",
SPARC_GRP_HARDQUAD: "hardquad",
SPARC_GRP_V9: "v9",
SPARC_GRP_VIS: "vis",
SPARC_GRP_VIS2: "vis2",
SPARC_GRP_VIS3: "vis3",
SPARC_GRP_32BIT: "32bit",
SPARC_GRP_64BIT: "64bit",
}
sysz_dict = {
SYSZ_GRP_JUMP: "jump",
SYSZ_GRP_DISTINCTOPS: "distinctops",
SYSZ_GRP_FPEXTENSION: "fpextension",
SYSZ_GRP_HIGHWORD: "highword",
SYSZ_GRP_INTERLOCKEDACCESS1: "interlockedaccess1",
SYSZ_GRP_LOADSTOREONCOND: "loadstoreoncond",
}
x86_dict = {
X86_GRP_JUMP: "jump",
X86_GRP_CALL: "call",
X86_GRP_RET: "ret",
X86_GRP_INT: "int",
X86_GRP_IRET: "iret",
X86_GRP_PRIVILEGE: "privilege",
X86_GRP_VM: "vm",
X86_GRP_3DNOW: "3dnow",
X86_GRP_AES: "aes",
X86_GRP_ADX: "adx",
X86_GRP_AVX: "avx",
X86_GRP_AVX2: "avx2",
X86_GRP_AVX512: "avx512",
X86_GRP_BMI: "bmi",
X86_GRP_BMI2: "bmi2",
X86_GRP_CMOV: "cmov",
X86_GRP_F16C: "fc16",
X86_GRP_FMA: "fma",
X86_GRP_FMA4: "fma4",
X86_GRP_FSGSBASE: "fsgsbase",
X86_GRP_HLE: "hle",
X86_GRP_MMX: "mmx",
X86_GRP_MODE32: "mode32",
X86_GRP_MODE64: "mode64",
X86_GRP_RTM: "rtm",
X86_GRP_SHA: "sha",
X86_GRP_SSE1: "sse1",
X86_GRP_SSE2: "sse2",
X86_GRP_SSE3: "sse3",
X86_GRP_SSE41: "sse41",
X86_GRP_SSE42: "sse42",
X86_GRP_SSE4A: "sse4a",
X86_GRP_SSSE3: "ssse3",
X86_GRP_PCLMUL: "pclmul",
X86_GRP_XOP: "xop",
X86_GRP_CDI: "cdi",
X86_GRP_ERI: "eri",
X86_GRP_TBM: "tbm",
X86_GRP_16BITMODE: "16bitmode",
X86_GRP_NOT64BITMODE: "not64bitmode",
X86_GRP_SGX: "sgx",
X86_GRP_DQI: "dqi",
X86_GRP_BWI: "bwi",
X86_GRP_PFI: "pfi",
X86_GRP_VLX: "vlx",
X86_GRP_SMAP: "smap",
X86_GRP_NOVLX: "novlx",
}
xcore_dict = {
XCORE_GRP_JUMP: "jump",
}
riscv32_dict = {
RISCV_GRP_JUMP : "jump",
RISCV_GRP_ISRV32 : "isrv32",
RISCV_GRP_HASSTDEXTA : "hasstdexta",
RISCV_GRP_HASSTDEXTC : "hasstdextc",
RISCV_GRP_HASSTDEXTD : "hasstdextd",
RISCV_GRP_HASSTDEXTF : "hasstdextf",
RISCV_GRP_HASSTDEXTM : "hasstdextm",
}
riscv64_dict = {
RISCV_GRP_JUMP : "jump",
RISCV_GRP_ISRV64 : "isrv64",
RISCV_GRP_HASSTDEXTA : "hasstdexta",
RISCV_GRP_HASSTDEXTC : "hasstdextc",
RISCV_GRP_HASSTDEXTD : "hasstdextd",
RISCV_GRP_HASSTDEXTF : "hasstdextf",
RISCV_GRP_HASSTDEXTM : "hasstdextm",
}
tests = [
GroupTest('arm', CS_ARCH_ARM, CS_MODE_THUMB, arm_dict),
GroupTest('arm64', CS_ARCH_ARM64, CS_MODE_ARM, arm64_dict),
GroupTest('mips', CS_ARCH_MIPS, CS_MODE_MIPS32 | CS_MODE_BIG_ENDIAN, mips_dict),
GroupTest('ppc', CS_ARCH_PPC, CS_MODE_BIG_ENDIAN, ppc_dict),
GroupTest('sparc', CS_ARCH_SPARC, CS_MODE_BIG_ENDIAN, sparc_dict),
GroupTest('sysz', CS_ARCH_SYSZ, CS_MODE_BIG_ENDIAN, sysz_dict),
GroupTest('x86', CS_ARCH_X86, CS_MODE_32, x86_dict),
GroupTest('xcore', CS_ARCH_XCORE, CS_MODE_BIG_ENDIAN, xcore_dict),
GroupTest('m68k', CS_ARCH_M68K, CS_MODE_BIG_ENDIAN, xcore_dict),
GroupTest('riscv32', CS_ARCH_RISCV, CS_MODE_RISCV32, riscv32_dict),
GroupTest('riscv64', CS_ARCH_RISCV, CS_MODE_RISCV64, riscv64_dict),
]
if __name__ == '__main__':
args = sys.argv[1:]
all = len(args) == 0 or 'all' in args
for t in tests:
if all or t.name in args:
t.run()
else:
print('Skipping %s' %t.name)
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/capstone/suite/test_group_name.py
|
#!/usr/bin/python
# By Nguyen Anh Quynh, 2015
# This tool extract sizes of immediadte operands from X86 instruction names.
# Syntax: ./autogen_x86imm.py
# Gather immediate sizes to put into X86ImmSize.inc
OUTPUT = "../arch/X86/X86ImmSize.inc"
f = open("../arch/X86/X86GenInstrInfo.inc")
f2 = open(OUTPUT, "w")
for line in f.readlines():
tmp = line.strip().split("=")
if len(tmp) == 2: # X86_xxx = nnn,
name = tmp[0].strip()
if name == "X86_INSTRUCTION_LIST_END": # no more instructions
break
if name.endswith("_DB"): # pseudo instruction
continue
if "_LOCK_" in name or "BEXTR" in name: # exception
continue
if name.startswith("X86_"): # instruction
if name.endswith("16mi8"):
f2.write("{2, %s},\n" %name)
elif name.endswith("16ri8"):
f2.write("{2, %s},\n" %name)
elif name.endswith("32ri8"):
f2.write("{4, %s},\n" %name)
elif name.endswith("32mi8"):
f2.write("{4, %s},\n" %name)
elif name.endswith("64i32"):
f2.write("{8, %s},\n" %name)
elif name.endswith("64mi32"):
f2.write("{8, %s},\n" %name)
elif name.endswith("64ri32"):
f2.write("{8, %s},\n" %name)
elif name.endswith("64ri8"):
f2.write("{8, %s},\n" %name)
elif name.endswith("64mi8"):
f2.write("{8, %s},\n" %name)
elif name.endswith("16rmi8"):
f2.write("{2, %s},\n" %name)
elif name.endswith("32rmi8"):
f2.write("{4, %s},\n" %name)
elif name.endswith("16rri8"):
f2.write("{2, %s},\n" %name)
elif name.endswith("32rri8"):
f2.write("{4, %s},\n" %name)
elif name.endswith("64rmi8"):
f2.write("{8, %s},\n" %name)
elif name.endswith("64rmi32"):
f2.write("{8, %s},\n" %name)
elif name.endswith("64rri32"):
f2.write("{8, %s},\n" %name)
elif name.endswith("64rri8"):
f2.write("{8, %s},\n" %name)
elif name.endswith("32ri64"): # special case
f2.write("{8, %s},\n" %name)
elif name.endswith("16i8"): # special case
f2.write("{2, %s},\n" %name)
elif name.endswith("32i8"): # special case
f2.write("{4, %s},\n" %name)
elif name.endswith("64i16"): # special case
f2.write("{8, %s},\n" %name)
elif name.endswith("64i8"): # special case
f2.write("{8, %s},\n" %name)
elif name.endswith("i8") or "i8_" in name:
f2.write("{1, %s},\n" %name)
elif "8ri" in name or "8mi" in name:
f2.write("{1, %s},\n" %name)
elif name.endswith("i16") or "i16_" in name:
f2.write("{2, %s},\n" %name)
elif "16ri" in name or "16mi" in name:
f2.write("{2, %s},\n" %name)
elif name.endswith("i32") or "i32_" in name:
f2.write("{4, %s},\n" %name)
elif "32ri" in name or "32mi" in name:
f2.write("{4, %s},\n" %name)
elif name.endswith("i64") or "i64_" in name:
f2.write("{8, %s},\n" %name)
elif "64ri" in name or "64mi" in name:
f2.write("{8, %s},\n" %name)
f.close()
f2.close()
print("Generated %s" %OUTPUT)
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/capstone/suite/autogen_x86imm.py
|
#!/usr/bin/python
# Test tool to compare Capstone output with llvm-mc. By Nguyen Anh Quynh, 2014
import sys
import os
from capstone import *
def test_file(fname):
print("Test %s" %fname);
f = open(fname)
lines = f.readlines()
f.close()
if not lines[0].startswith('# '):
print("ERROR: decoding information is missing")
return
# skip '# ' at the front, then split line to get out hexcode
# Note: option can be '', or 'None'
#print lines[0]
#print lines[0][2:].split(', ')
(arch, mode, option) = lines[0][2:].split(', ')
mode = mode.replace(' ', '')
option = option.strip()
archs = {
"CS_ARCH_ARM": CS_ARCH_ARM,
"CS_ARCH_ARM64": CS_ARCH_ARM64,
"CS_ARCH_MIPS": CS_ARCH_MIPS,
"CS_ARCH_PPC": CS_ARCH_PPC,
"CS_ARCH_SPARC": CS_ARCH_SPARC,
"CS_ARCH_SYSZ": CS_ARCH_SYSZ,
"CS_ARCH_X86": CS_ARCH_X86,
"CS_ARCH_XCORE": CS_ARCH_XCORE,
"CS_ARCH_RISCV": CS_ARCH_RISCV,
}
modes = {
"CS_MODE_16": CS_MODE_16,
"CS_MODE_32": CS_MODE_32,
"CS_MODE_64": CS_MODE_64,
"CS_MODE_MIPS32": CS_MODE_MIPS32,
"CS_MODE_MIPS64": CS_MODE_MIPS64,
"0": CS_MODE_ARM,
"CS_MODE_ARM": CS_MODE_ARM,
"CS_MODE_THUMB": CS_MODE_THUMB,
"CS_MODE_ARM+CS_MODE_V8": CS_MODE_ARM+CS_MODE_V8,
"CS_MODE_THUMB+CS_MODE_V8": CS_MODE_THUMB+CS_MODE_V8,
"CS_MODE_THUMB+CS_MODE_MCLASS": CS_MODE_THUMB+CS_MODE_MCLASS,
"CS_MODE_LITTLE_ENDIAN": CS_MODE_LITTLE_ENDIAN,
"CS_MODE_BIG_ENDIAN": CS_MODE_BIG_ENDIAN,
"CS_MODE_64+CS_MODE_LITTLE_ENDIAN": CS_MODE_64+CS_MODE_LITTLE_ENDIAN,
"CS_MODE_64+CS_MODE_BIG_ENDIAN": CS_MODE_64+CS_MODE_BIG_ENDIAN,
"CS_MODE_MIPS32+CS_MODE_MICRO": CS_MODE_MIPS32+CS_MODE_MICRO,
"CS_MODE_MIPS32+CS_MODE_MICRO+CS_MODE_BIG_ENDIAN": CS_MODE_MIPS32+CS_MODE_MICRO+CS_MODE_BIG_ENDIAN,
"CS_MODE_MIPS32+CS_MODE_BIG_ENDIAN+CS_MODE_MICRO": CS_MODE_MIPS32+CS_MODE_MICRO+CS_MODE_BIG_ENDIAN,
"CS_MODE_BIG_ENDIAN+CS_MODE_V9": CS_MODE_BIG_ENDIAN + CS_MODE_V9,
"CS_MODE_MIPS32+CS_MODE_BIG_ENDIAN": CS_MODE_MIPS32+CS_MODE_BIG_ENDIAN,
"CS_MODE_MIPS32+CS_MODE_LITTLE_ENDIAN": CS_MODE_MIPS32+CS_MODE_LITTLE_ENDIAN,
"CS_MODE_MIPS64+CS_MODE_LITTLE_ENDIAN": CS_MODE_MIPS64+CS_MODE_LITTLE_ENDIAN,
"CS_MODE_MIPS64+CS_MODE_BIG_ENDIAN": CS_MODE_MIPS64+CS_MODE_BIG_ENDIAN,
"CS_MODE_RISCV32": CS_MODE_RISCV32,
"CS_MODE_RISCV64": CS_MODE_RISCV64,
}
mc_modes = {
("CS_ARCH_X86", "CS_MODE_32"): 0,
("CS_ARCH_X86", "CS_MODE_64"): 1,
("CS_ARCH_ARM", "CS_MODE_ARM"): 2,
("CS_ARCH_ARM", "CS_MODE_THUMB"): 3,
("CS_ARCH_ARM", "CS_MODE_ARM+CS_MODE_V8"): 4,
("CS_ARCH_ARM", "CS_MODE_THUMB+CS_MODE_V8"): 5,
("CS_ARCH_ARM", "CS_MODE_THUMB+CS_MODE_MCLASS"): 6,
("CS_ARCH_ARM64", "0"): 7,
("CS_ARCH_MIPS", "CS_MODE_MIPS32+CS_MODE_BIG_ENDIAN"): 8,
("CS_ARCH_MIPS", "CS_MODE_MIPS32+CS_MODE_MICRO"): 9,
("CS_ARCH_MIPS", "CS_MODE_MIPS64"): 10,
("CS_ARCH_MIPS", "CS_MODE_MIPS32"): 11,
("CS_ARCH_MIPS", "CS_MODE_MIPS64+CS_MODE_BIG_ENDIAN"): 12,
("CS_ARCH_MIPS", "CS_MODE_MIPS32+CS_MODE_MICRO+CS_MODE_BIG_ENDIAN"): 13,
("CS_ARCH_MIPS", "CS_MODE_MIPS32+CS_MODE_BIG_ENDIAN+CS_MODE_MICRO"): 13,
("CS_ARCH_PPC", "CS_MODE_BIG_ENDIAN"): 14,
("CS_ARCH_SPARC", "CS_MODE_BIG_ENDIAN"): 15,
("CS_ARCH_SPARC", "CS_MODE_BIG_ENDIAN+CS_MODE_V9"): 16,
("CS_ARCH_SYSZ", "0"): 17,
("CS_ARCH_XCORE", "0"): 18,
("CS_ARCH_MIPS", "CS_MODE_MIPS32R6+CS_MODE_BIG_ENDIAN"): 19,
("CS_ARCH_MIPS", "CS_MODE_MIPS32R6+CS_MODE_MICRO+CS_MODE_BIG_ENDIAN"): 20,
("CS_ARCH_MIPS", "CS_MODE_MIPS32R6"): 21,
("CS_ARCH_MIPS", "CS_MODE_MIPS32R6+CS_MODE_MICRO"): 22,
("CS_ARCH_M68K", "0"): 23,
("CS_ARCH_M680X", "CS_MODE_M680X_6809"): 24,
("CS_ARCH_EVM", "0"): 25,
("CS_ARCH_BPF", "CS_MODE_LITTLE_ENDIAN+CS_MODE_BPF_CLASSIC"): 29,
("CS_ARCH_BPF", "CS_MODE_LITTLE_ENDIAN+CS_MODE_BPF_EXTENDED"): 30,
("CS_ARCH_BPF", "CS_MODE_BIG_ENDIAN+CS_MODE_BPF_CLASSIC"): 31,
("CS_ARCH_BPF", "CS_MODE_BIG_ENDIAN+CS_MODE_BPF_EXTENDED"): 32,
("CS_ARCH_RISCV", "CS_MODE_RISCV32"): 44,
("CS_ARCH_RISCV", "CS_MODE_RISCV64"): 45,
}
#if not option in ('', 'None'):
# print archs[arch], modes[mode], options[option]
for line in lines[1:]:
# ignore all the input lines having # in front.
if line.startswith('#'):
continue
if line.startswith('// '):
line=line[3:]
#print("Check %s" %line)
code = line.split(' = ')[0]
if len(code) < 2:
continue
if code.find('//') >= 0:
continue
hex_code = code.replace('0x', '')
hex_code = hex_code.replace(',', '')
try:
hex_data = hex_code.strip().decode('hex')
except:
print "skipping", hex_code
fout = open("fuzz/corpus/%s_%s" % (os.path.basename(fname), hex_code), 'w')
if (arch, mode) not in mc_modes:
print "fail", arch, mode
fout.write(unichr(mc_modes[(arch, mode)]))
fout.write(hex_data)
fout.close()
if __name__ == '__main__':
if len(sys.argv) == 1:
fnames = sys.stdin.readlines()
for fname in fnames:
test_file(fname.strip())
else:
#print("Usage: ./test_mc.py <input-file.s.cs>")
test_file(sys.argv[1])
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/capstone/suite/test_corpus.py
|
#!/usr/bin/env python
# Capstone Python bindings, by Nguyen Anh Quynnh <aquynh@gmail.com>
from __future__ import print_function
import sys
from capstone import *
CODE32 = b"\xc0\xe0\x02"
CODE32 += b"\xc0\xf6\x02" # sal dh, 0
CODE32 += b"\xc1\xf6\x00" # sal esi, 0
CODE32 += b"\x82\xc0\x00"
CODE32 += b"\x0f\x1a\x00" # nop dword ptr [eax]
CODE32 += b"\xf7\xc0\x11\x22\x33\x44" # test eax, 0x44332211
CODE32 += b"\xf7\xc8\x11\x22\x33\x44" # test eax, 0x44332211
CODE32 += b"\xf7\x88\x00\x00\x00\x00\x00\x00\x00\x00" # test dword ptr [eax], 0
CODE32 += b"\xf6\x88\x00\x00\x00\x00\x00" # test byte ptr [eax], 0
CODE32 += b"\xd9\xd8" # fstpnce st(0), st(0)
CODE32 += b"\xdf\xdf" # fstp st(7), st(0)
CODE32 += b"\x0f\x20\x00" # mov eax, cr0
CODE32 += b"\x0f\x20\x40" # mov eax, cr0
CODE32 += b"\x0f\x20\x80" # mov eax, cr0
CODE32 += b"\x0f\x22\x00" # mov cr0, eax
CODE32 += b"\x0f\x22\x40" # mov cr0, eax
CODE32 += b"\x0f\x22\x80" # mov cr0, eax
CODE32 += b"\x0f\x21\x00" # mov eax, dr0
CODE32 += b"\x0f\x21\x40" # mov eax, dr0
CODE32 += b"\x0f\x21\x80" # mov eax, dr0
CODE32 += b"\x0f\x23\x00" # mov dr0, eax
CODE32 += b"\x0f\x23\x40" # mov dr0, eax
CODE32 += b"\x0f\x23\x80" # mov dr0, eax
CODE32 += b"\x66\x2e\x0f\x58\xc0" # addpd xmm0, xmm0
CODE32 += b"\x2e\x66\x0f\x58\xc0" # addpd xmm0, xmm0
CODE32 += b"\x66\xf2\x0f\x38\xf1\xc3" # crc32w %bx, %eax
CODE32 += b"\xf2\x0f\x38\xf1\x8c\xcb\xef\xbe\xad\xde" # crc32l -0x21524111(%ebx, %ecx, 8), %ecx
CODE32_MEMREF = b"\x8b\x84\x91\x23\x01\x00\x00"
CODE32_MEMREF += b"\x8b\x04\x95\x23\x01\x00\x00"
CODE32_MEMREF += b"\x8b\x04\x95\xdd\xfe\xff\xff"
CODE32_MEMREF += b"\xa1\x23\x01\x00\x00"
CODE32_MEMREF += b"\xa1\x00\x00\x00\x00"
CODE32_MEMREF += b"\xa1\xdd\xfe\xff\xff"
CODE32_MEMREF += b"\x8b\x04\x91"
CODE64_MEMREF = b"\xa3\x0b\x00\x00\x0f\xbe\xc0\x48\x83"
CODE64_MEMREF += b"\xa0\x71\xfa\xff\x48\x85\xc0\x48\x89"
CODE32_ARITH = b"\x83\xe0\xf7"
CODE32_ARITH += b"\x83\xe0\x10"
CODE32_ARITH += b"\x83\xe0\x00"
CODE32_ARITH += b"\x80\x23\x10"
CODE64_ARITH = b"\x41\x83\xe0\xfa"
CODE64_ARITH += b"\x48\x83\xe4\xf0"
CODE32_IMM = b"\xc2\xb8\xc0"
CODE32_IMM += b"\xc2\x0f\x92"
CODE32_IMM += b"\x02\x2d\x00\x00\x00\x83"
_python3 = sys.version_info.major == 3
all_tests = (
(CS_ARCH_X86, CS_MODE_32, CODE32, "X86 32 (Intel syntax)", 0),
(CS_ARCH_X86, CS_MODE_32, CODE32, "X86 32 (ATT syntax)", CS_OPT_SYNTAX_ATT),
(CS_ARCH_X86, CS_MODE_32, CODE32_MEMREF, "X86 32 MemRef (Intel syntax)", 0),
(CS_ARCH_X86, CS_MODE_32, CODE32_MEMREF, "X86 32 MemRef (ATT syntax)", CS_OPT_SYNTAX_ATT),
(CS_ARCH_X86, CS_MODE_64, CODE64_MEMREF, "X86 64 (Intel syntax)", 0),
(CS_ARCH_X86, CS_MODE_32, CODE32_ARITH, "X86 32 (Intel syntax)", 0),
(CS_ARCH_X86, CS_MODE_64, CODE64_ARITH, "X86 64 (Intel syntax)", 0),
(CS_ARCH_X86, CS_MODE_32, CODE32_IMM, "X86 32 (Intel syntax)", 0),
(CS_ARCH_X86, CS_MODE_32, CODE32_IMM, "X86 32 (Intel syntax)", CS_OPT_SYNTAX_ATT),
)
def to_hex(s):
if _python3:
return " ".join("0x{0:02x}".format(c) for c in s) # <-- Python 3 is OK
else:
return " ".join("0x{0:02x}".format(ord(c)) for c in s)
# ## Test cs_disasm_quick()
def test_cs_disasm_quick():
for (arch, mode, code, comment, syntax) in all_tests:
print("Platform: %s" % comment)
print("Code: %s" %(to_hex(code))),
print("Disasm:")
md = Cs(arch, mode)
if syntax != 0:
md.syntax = syntax
for insn in md.disasm(code, 0x1000):
print("0x%x:\t%s\t%s" % (insn.address, insn.mnemonic, insn.op_str))
print("--------")
if __name__ == '__main__':
test_cs_disasm_quick()
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/capstone/suite/x86odd.py
|
#!/bin/sh
# this prints out Capstone setup & core+Python-binding versions
python -c "import capstone; print capstone.debug()"
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/capstone/suite/python_capstone_setup.py
|
#!/usr/bin/env python
# By Daniel Pistelli & Nguyen Tan Cong
# This script is to patch DLL/EXE MajorVersion to 5,
# so they can be loaded by Windows XP.
# This is the problem introduced by compiling on Windows 7, using VS2013.
import sys, struct
if len(sys.argv) < 2:
print("Usage: %s <pe_file_path>" % sys.argv[0])
sys.exit(0)
pe_file_path = sys.argv[1]
with open(pe_file_path, "rb") as f:
b = f.read()
if not b.startswith("MZ"):
print("Not a PE file")
sys.exit(0)
e_lfanew = struct.unpack_from("<I", b, 0x3C)[0]
vb = struct.pack("<HHHHH", 5, 0, 0, 0, 5) # encode versions
# patches MajorOperatingSystemVersion and MajorSubsystemVersion
b = b[0:e_lfanew + 0x40] + vb + b[e_lfanew + 0x4A:]
# write back to file
with open(pe_file_path, "wb") as f:
f.write(b)
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/capstone/suite/patch_major_os_version.py
|
#!/usr/bin/python
# Test tool to compare Capstone output with llvm-mc. By Nguyen Anh Quynh, 2014
import array, os.path, sys
from subprocess import Popen, PIPE, STDOUT
from capstone import *
# convert all hex numbers to decimal numbers in a text
def normalize_hex(a):
while(True):
i = a.find('0x')
if i == -1: # no more hex number
break
hexnum = '0x'
for c in a[i + 2:]:
if c in '0123456789abcdefABCDEF':
hexnum += c
else:
break
num = int(hexnum, 16)
a = a.replace(hexnum, str(num))
return a
def run_mc(arch, hexcode, option, syntax=None):
def normalize(text):
# remove tabs
text = text.lower()
items = text.split()
text = ' '.join(items)
if arch == CS_ARCH_X86:
# remove comment after #
i = text.find('# ')
if i != -1:
return text[:i].strip()
if arch == CS_ARCH_ARM64:
# remove comment after #
i = text.find('// ')
if i != -1:
return text[:i].strip()
# remove some redundant spaces
text = text.replace('{ ', '{')
text = text.replace(' }', '}')
return text.strip()
#print("Trying to decode: %s" %hexcode)
if syntax:
if arch == CS_ARCH_MIPS:
p = Popen(['llvm-mc', '-disassemble', '-print-imm-hex', '-mattr=+msa', syntax] + option, stdout=PIPE, stdin=PIPE, stderr=STDOUT)
else:
p = Popen(['llvm-mc', '-disassemble', '-print-imm-hex', syntax] + option, stdout=PIPE, stdin=PIPE, stderr=STDOUT)
else:
if arch == CS_ARCH_MIPS:
p = Popen(['llvm-mc', '-disassemble', '-print-imm-hex', '-mattr=+msa'] + option, stdout=PIPE, stdin=PIPE, stderr=STDOUT)
else:
p = Popen(['llvm-mc', '-disassemble', '-print-imm-hex'] + option, stdout=PIPE, stdin=PIPE, stderr=STDOUT)
output = p.communicate(input=hexcode)[0]
lines = output.split('\n')
#print lines
if 'invalid' in lines[0]:
#print 'invalid ----'
return 'FAILED to disassemble (MC)'
else:
#print 'OK:', lines[1]
return normalize(lines[1].strip())
def test_file(fname):
print("Test %s" %fname);
f = open(fname)
lines = f.readlines()
f.close()
if not lines[0].startswith('# '):
print("ERROR: decoding information is missing")
return
# skip '# ' at the front, then split line to get out hexcode
# Note: option can be '', or 'None'
#print lines[0]
#print lines[0][2:].split(', ')
(arch, mode, option) = lines[0][2:].split(', ')
mode = mode.replace(' ', '')
option = option.strip()
archs = {
"CS_ARCH_ARM": CS_ARCH_ARM,
"CS_ARCH_ARM64": CS_ARCH_ARM64,
"CS_ARCH_MIPS": CS_ARCH_MIPS,
"CS_ARCH_PPC": CS_ARCH_PPC,
"CS_ARCH_SPARC": CS_ARCH_SPARC,
"CS_ARCH_SYSZ": CS_ARCH_SYSZ,
"CS_ARCH_X86": CS_ARCH_X86,
"CS_ARCH_XCORE": CS_ARCH_XCORE,
"CS_ARCH_RISCV": CS_ARCH_RISCV
# "CS_ARCH_M68K": CS_ARCH_M68K,
}
modes = {
"CS_MODE_16": CS_MODE_16,
"CS_MODE_32": CS_MODE_32,
"CS_MODE_64": CS_MODE_64,
"CS_MODE_MIPS32": CS_MODE_MIPS32,
"CS_MODE_MIPS64": CS_MODE_MIPS64,
"0": CS_MODE_ARM,
"CS_MODE_ARM": CS_MODE_ARM,
"CS_MODE_THUMB": CS_MODE_THUMB,
"CS_MODE_ARM+CS_MODE_V8": CS_MODE_ARM+CS_MODE_V8,
"CS_MODE_THUMB+CS_MODE_V8": CS_MODE_THUMB+CS_MODE_V8,
"CS_MODE_THUMB+CS_MODE_MCLASS": CS_MODE_THUMB+CS_MODE_MCLASS,
"CS_MODE_LITTLE_ENDIAN": CS_MODE_LITTLE_ENDIAN,
"CS_MODE_BIG_ENDIAN": CS_MODE_BIG_ENDIAN,
"CS_MODE_64+CS_MODE_LITTLE_ENDIAN": CS_MODE_64+CS_MODE_LITTLE_ENDIAN,
"CS_MODE_64+CS_MODE_BIG_ENDIAN": CS_MODE_64+CS_MODE_BIG_ENDIAN,
"CS_MODE_MIPS32+CS_MODE_MICRO": CS_MODE_MIPS32+CS_MODE_MICRO,
"CS_MODE_MIPS32+CS_MODE_MICRO+CS_MODE_BIG_ENDIAN": CS_MODE_MIPS32+CS_MODE_MICRO+CS_MODE_BIG_ENDIAN,
"CS_MODE_MIPS32+CS_MODE_BIG_ENDIAN+CS_MODE_MICRO": CS_MODE_MIPS32+CS_MODE_MICRO+CS_MODE_BIG_ENDIAN,
"CS_MODE_BIG_ENDIAN+CS_MODE_V9": CS_MODE_BIG_ENDIAN + CS_MODE_V9,
"CS_MODE_MIPS32+CS_MODE_BIG_ENDIAN": CS_MODE_MIPS32+CS_MODE_BIG_ENDIAN,
"CS_MODE_MIPS32+CS_MODE_LITTLE_ENDIAN": CS_MODE_MIPS32+CS_MODE_LITTLE_ENDIAN,
"CS_MODE_MIPS64+CS_MODE_LITTLE_ENDIAN": CS_MODE_MIPS64+CS_MODE_LITTLE_ENDIAN,
"CS_MODE_MIPS64+CS_MODE_BIG_ENDIAN": CS_MODE_MIPS64+CS_MODE_BIG_ENDIAN,
"CS_MODE_RISCV32": CS_MODE_RISCV32,
"CS_MODE_RISCV64": CS_MODE_RISCV64,
}
options = {
"CS_OPT_SYNTAX_ATT": CS_OPT_SYNTAX_ATT,
"CS_OPT_SYNTAX_NOREGNAME": CS_OPT_SYNTAX_NOREGNAME,
}
mc_modes = {
("CS_ARCH_X86", "CS_MODE_32"): ['-triple=i386'],
("CS_ARCH_X86", "CS_MODE_64"): ['-triple=x86_64'],
("CS_ARCH_ARM", "CS_MODE_ARM"): ['-triple=armv7'],
("CS_ARCH_ARM", "CS_MODE_THUMB"): ['-triple=thumbv7'],
("CS_ARCH_ARM", "CS_MODE_ARM+CS_MODE_V8"): ['-triple=armv8'],
("CS_ARCH_ARM", "CS_MODE_THUMB+CS_MODE_V8"): ['-triple=thumbv8'],
("CS_ARCH_ARM", "CS_MODE_THUMB+CS_MODE_MCLASS"): ['-triple=thumbv7m'],
("CS_ARCH_ARM64", "0"): ['-triple=aarch64'],
("CS_ARCH_MIPS", "CS_MODE_MIPS32+CS_MODE_BIG_ENDIAN"): ['-triple=mips'],
("CS_ARCH_MIPS", "CS_MODE_MIPS32+CS_MODE_MICRO"): ['-triple=mipsel', '-mattr=+micromips'],
("CS_ARCH_MIPS", "CS_MODE_MIPS64"): ['-triple=mips64el'],
("CS_ARCH_MIPS", "CS_MODE_MIPS32"): ['-triple=mipsel'],
("CS_ARCH_MIPS", "CS_MODE_MIPS64+CS_MODE_BIG_ENDIAN"): ['-triple=mips64'],
("CS_ARCH_MIPS", "CS_MODE_MIPS32+CS_MODE_MICRO+CS_MODE_BIG_ENDIAN"): ['-triple=mips', '-mattr=+micromips'],
("CS_ARCH_MIPS", "CS_MODE_MIPS32+CS_MODE_BIG_ENDIAN+CS_MODE_MICRO"): ['-triple=mips', '-mattr=+micromips'],
("CS_ARCH_PPC", "CS_MODE_BIG_ENDIAN"): ['-triple=powerpc64'],
('CS_ARCH_SPARC', 'CS_MODE_BIG_ENDIAN'): ['-triple=sparc'],
('CS_ARCH_SPARC', 'CS_MODE_BIG_ENDIAN+CS_MODE_V9'): ['-triple=sparcv9'],
('CS_ARCH_SYSZ', '0'): ['-triple=s390x', '-mcpu=z196'],
('CS_ARCH_RISCV', 'CS_MODE_RISCV32'): ['-triple=riscv32'],
('CS_ARCH_RISCV', 'CS_MODE_RISCV64'): ['-triple=riscv64'],
}
#if not option in ('', 'None'):
# print archs[arch], modes[mode], options[option]
#print(arch, mode, option)
md = Cs(archs[arch], modes[mode])
mc_option = None
if arch == 'CS_ARCH_X86':
# tell llvm-mc to use Intel syntax
mc_option = '-output-asm-variant=1'
if arch == 'CS_ARCH_ARM' or arch == 'CS_ARCH_PPC' :
md.syntax = CS_OPT_SYNTAX_NOREGNAME
if fname.endswith('3DNow.s.cs'):
md.syntax = CS_OPT_SYNTAX_ATT
for line in lines[1:]:
# ignore all the input lines having # in front.
if line.startswith('#'):
continue
#print("Check %s" %line)
code = line.split(' = ')[0]
asm = ''.join(line.split(' = ')[1:])
hex_code = code.replace('0x', '')
hex_code = hex_code.replace(',', '')
hex_data = hex_code.decode('hex')
#hex_bytes = array.array('B', hex_data)
x = list(md.disasm(hex_data, 0))
if len(x) > 0:
if x[0].op_str != '':
cs_output = "%s %s" %(x[0].mnemonic, x[0].op_str)
else:
cs_output = x[0].mnemonic
else:
cs_output = 'FAILED to disassemble'
cs_output2 = normalize_hex(cs_output)
cs_output2 = cs_output2.replace(' ', '')
if arch == 'CS_ARCH_MIPS':
# normalize register alias names
cs_output2 = cs_output2.replace('$at', '$1')
cs_output2 = cs_output2.replace('$v0', '$2')
cs_output2 = cs_output2.replace('$v1', '$3')
cs_output2 = cs_output2.replace('$a0', '$4')
cs_output2 = cs_output2.replace('$a1', '$5')
cs_output2 = cs_output2.replace('$a2', '$6')
cs_output2 = cs_output2.replace('$a3', '$7')
cs_output2 = cs_output2.replace('$t0', '$8')
cs_output2 = cs_output2.replace('$t1', '$9')
cs_output2 = cs_output2.replace('$t2', '$10')
cs_output2 = cs_output2.replace('$t3', '$11')
cs_output2 = cs_output2.replace('$t4', '$12')
cs_output2 = cs_output2.replace('$t5', '$13')
cs_output2 = cs_output2.replace('$t6', '$14')
cs_output2 = cs_output2.replace('$t7', '$15')
cs_output2 = cs_output2.replace('$t8', '$24')
cs_output2 = cs_output2.replace('$t9', '$25')
cs_output2 = cs_output2.replace('$s0', '$16')
cs_output2 = cs_output2.replace('$s1', '$17')
cs_output2 = cs_output2.replace('$s2', '$18')
cs_output2 = cs_output2.replace('$s3', '$19')
cs_output2 = cs_output2.replace('$s4', '$20')
cs_output2 = cs_output2.replace('$s5', '$21')
cs_output2 = cs_output2.replace('$s6', '$22')
cs_output2 = cs_output2.replace('$s7', '$23')
cs_output2 = cs_output2.replace('$k0', '$26')
cs_output2 = cs_output2.replace('$k1', '$27')
#print("Running MC ...")
if fname.endswith('thumb-fp-armv8.s.cs'):
mc_output = run_mc(archs[arch], code, ['-triple=thumbv8'], mc_option)
elif fname.endswith('mips64-alu-instructions.s.cs'):
mc_output = run_mc(archs[arch], code, ['-triple=mips64el', '-mcpu=mips64r2'], mc_option)
else:
mc_output = run_mc(archs[arch], code, mc_modes[(arch, mode)], mc_option)
mc_output2 = normalize_hex(mc_output)
if arch == 'CS_ARCH_MIPS':
mc_output2 = mc_output2.replace(' 0(', '(')
if arch == 'CS_ARCH_PPC':
mc_output2 = mc_output2.replace('.+', '')
mc_output2 = mc_output2.replace('.', '')
mc_output2 = mc_output2.replace(' 0(', '(')
mc_output2 = mc_output2.replace(' ', '')
mc_output2 = mc_output2.replace('opaque', '')
if (cs_output2 != mc_output2):
asm = asm.replace(' ', '').strip().lower()
if asm != cs_output2:
print("Mismatch: %s" %line.strip())
print("\tMC = %s" %mc_output)
print("\tCS = %s" %cs_output)
if __name__ == '__main__':
if len(sys.argv) == 1:
fnames = sys.stdin.readlines()
for fname in fnames:
test_file(fname.strip())
else:
#print("Usage: ./test_mc.py <input-file.s.cs>")
test_file(sys.argv[1])
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/capstone/suite/test_mc.py
|
#!/usr/bin/env python
# Capstone Python bindings, by Nguyen Anh Quynnh <aquynh@gmail.com>
from __future__ import print_function
import sys
from capstone import *
all_tests = (
# arch, mode, syntax, address, hexcode, expected output
# issue 456 https://github.com/aquynh/capstone/issues/456
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xfc16, b"\xE8\x35\x64", "call 0x604e"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123fc1b, b"\x66\xE8\x35\x64", "call 0x6054"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x9123fc1b, b"\x66\xE8\x35\x64", "call 0x6054"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xfc26, b"\xE9\x35\x64", "jmp 0x605e"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xfff6, b"\x66\xE9\x35\x64\x93\x53", "jmp 0x53946431"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123fff1, b"\xE9\x35\x64\x93\x53", "jmp 0xe4b7642b"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123fff1, b"\xE9\x35\x64\x93\x53", "jmp 0x64e4b7642b"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\xe8\x35\x64\x93\x53", "call 0x5394641c"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\xe8\x35\x64", "call 0x641a"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\xe9\x35\x64", "jmp 0x641a"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\xe9\x35\x64\x93\x53", "jmp 0x5394641c"),
# AT&T syntax
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_ATT, 0xfc16, b"\xE8\x35\x64", "callw 0x604e"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_ATT, 0x9123fc1b, b"\x66\xE8\x35\x64", "callw 0x6054"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_ATT, 0x9123fc1b, b"\x66\xE8\x35\x64", "callw 0x6054"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_ATT, 0xfc26, b"\xE9\x35\x64", "jmp 0x605e"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_ATT, 0xfff6, b"\x66\xE9\x35\x64\x93\x53", "jmp 0x53946431"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_ATT, 0x9123fff1, b"\xE9\x35\x64\x93\x53", "jmp 0xe4b7642b"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_ATT, 0x649123fff1, b"\xE9\x35\x64\x93\x53", "jmp 0x64e4b7642b"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_ATT, 0xffe1, b"\x66\xe8\x35\x64\x93\x53", "calll 0x5394641c"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_ATT, 0x649123ffe1, b"\x66\xe8\x35\x64", "callw 0x641a"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_ATT, 0x649123ffe1, b"\x66\xe9\x35\x64", "jmp 0x641a"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_ATT, 0xffe1, b"\x66\xe9\x35\x64\x93\x53", "jmp 0x5394641c"),
# issue 452 https://github.com/aquynh/capstone/issues/452
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x6C", "insb byte ptr es:[di], dx"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x6D", "insw word ptr es:[di], dx"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x6E", "outsb dx, byte ptr [si]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x6F", "outsw dx, word ptr [si]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\xA4", "movsb byte ptr es:[di], byte ptr [si]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\xA5", "movsw word ptr es:[di], word ptr [si]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\xA6", "cmpsb byte ptr [si], byte ptr es:[di]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\xA7", "cmpsw word ptr [si], word ptr es:[di]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\xAA", "stosb byte ptr es:[di], al"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\xAB", "stosw word ptr es:[di], ax"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\xAC", "lodsb al, byte ptr [si]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\xAD", "lodsw ax, word ptr [si]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\xAE", "scasb al, byte ptr es:[di]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\xAF", "scasw ax, word ptr es:[di]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\x6C", "insb byte ptr es:[di], dx"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\x6D", "insd dword ptr es:[di], dx"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\x6E", "outsb dx, byte ptr [si]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\x6F", "outsd dx, dword ptr [si]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\xA4", "movsb byte ptr es:[di], byte ptr [si]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\xA5", "movsd dword ptr es:[di], dword ptr [si]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\xA6", "cmpsb byte ptr [si], byte ptr es:[di]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\xA7", "cmpsd dword ptr [si], dword ptr es:[di]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\xAA", "stosb byte ptr es:[di], al"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\xAB", "stosd dword ptr es:[di], eax"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\xAC", "lodsb al, byte ptr [si]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\xAD", "lodsd eax, dword ptr [si]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\xAE", "scasb al, byte ptr es:[di]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\xAF", "scasd eax, dword ptr es:[di]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x67\x6C", "insb byte ptr es:[edi], dx"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x67\x6D", "insw word ptr es:[edi], dx"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x67\x6E", "outsb dx, byte ptr [esi]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x67\x6F", "outsw dx, word ptr [esi]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x67\xA4", "movsb byte ptr es:[edi], byte ptr [esi]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x67\xA5", "movsw word ptr es:[edi], word ptr [esi]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x67\xA6", "cmpsb byte ptr [esi], byte ptr es:[edi]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x67\xA7", "cmpsw word ptr [esi], word ptr es:[edi]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x67\xAA", "stosb byte ptr es:[edi], al"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x67\xAB", "stosw word ptr es:[edi], ax"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x67\xAC", "lodsb al, byte ptr [esi]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x67\xAD", "lodsw ax, word ptr [esi]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x67\xAE", "scasb al, byte ptr es:[edi]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x67\xAF", "scasw ax, word ptr es:[edi]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\xF2\x6C", "repne insb byte ptr es:[di], dx"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\xF2\x6D", "repne insw word ptr es:[di], dx"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\xF2\x6E", "repne outsb dx, byte ptr [si]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\xF2\x6F", "repne outsw dx, word ptr [si]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\xF2\xA4", "repne movsb byte ptr es:[di], byte ptr [si]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\xF2\xA5", "repne movsw word ptr es:[di], word ptr [si]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\xF2\xA6", "repne cmpsb byte ptr [si], byte ptr es:[di]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\xF2\xA7", "repne cmpsw word ptr [si], word ptr es:[di]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\xF2\xAA", "repne stosb byte ptr es:[di], al"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\xF2\xAB", "repne stosw word ptr es:[di], ax"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\xF2\xAC", "repne lodsb al, byte ptr [si]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\xF2\xAD", "repne lodsw ax, word ptr [si]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\xF2\xAE", "repne scasb al, byte ptr es:[di]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\xF2\xAF", "repne scasw ax, word ptr es:[di]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\xF3\x6C", "rep insb byte ptr es:[di], dx"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\xF3\x6D", "rep insw word ptr es:[di], dx"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\xF3\x6E", "rep outsb dx, byte ptr [si]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\xF3\x6F", "rep outsw dx, word ptr [si]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\xF3\xA4", "rep movsb byte ptr es:[di], byte ptr [si]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\xF3\xA5", "rep movsw word ptr es:[di], word ptr [si]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\xF3\xA6", "repe cmpsb byte ptr [si], byte ptr es:[di]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\xF3\xA7", "repe cmpsw word ptr [si], word ptr es:[di]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\xF3\xAA", "rep stosb byte ptr es:[di], al"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\xF3\xAB", "rep stosw word ptr es:[di], ax"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\xF3\xAC", "rep lodsb al, byte ptr [si]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\xF3\xAD", "rep lodsw ax, word ptr [si]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\xF3\xAE", "repe scasb al, byte ptr es:[di]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\xF3\xAF", "repe scasw ax, word ptr es:[di]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\x67\x6C", "insb byte ptr es:[edi], dx"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\x67\x6D", "insd dword ptr es:[edi], dx"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\x67\x6E", "outsb dx, byte ptr [esi]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\x67\x6F", "outsd dx, dword ptr [esi]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\x67\xA4", "movsb byte ptr es:[edi], byte ptr [esi]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\x67\xA5", "movsd dword ptr es:[edi], dword ptr [esi]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\x67\xA6", "cmpsb byte ptr [esi], byte ptr es:[edi]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\x67\xA7", "cmpsd dword ptr [esi], dword ptr es:[edi]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\x67\xAA", "stosb byte ptr es:[edi], al"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\x67\xAB", "stosd dword ptr es:[edi], eax"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\x67\xAC", "lodsb al, byte ptr [esi]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\x67\xAD", "lodsd eax, dword ptr [esi]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\x67\xAE", "scasb al, byte ptr es:[edi]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\x67\xAF", "scasd eax, dword ptr es:[edi]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\xF2\x6C", "repne insb byte ptr es:[di], dx"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\xF2\x6D", "repne insd dword ptr es:[di], dx"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\xF2\x6E", "repne outsb dx, byte ptr [si]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\xF2\x6F", "repne outsd dx, dword ptr [si]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\xF2\xA4", "repne movsb byte ptr es:[di], byte ptr [si]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\xF2\xA5", "repne movsd dword ptr es:[di], dword ptr [si]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\xF2\xA6", "repne cmpsb byte ptr [si], byte ptr es:[di]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\xF2\xA7", "repne cmpsd dword ptr [si], dword ptr es:[di]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\xF2\xAA", "repne stosb byte ptr es:[di], al"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\xF2\xAB", "repne stosd dword ptr es:[di], eax"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\xF2\xAC", "repne lodsb al, byte ptr [si]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\xF2\xAD", "repne lodsd eax, dword ptr [si]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\xF2\xAE", "repne scasb al, byte ptr es:[di]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\xF2\xAF", "repne scasd eax, dword ptr es:[di]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\xF3\x6C", "rep insb byte ptr es:[di], dx"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\xF3\x6D", "rep insd dword ptr es:[di], dx"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\xF3\x6E", "rep outsb dx, byte ptr [si]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\xF3\x6F", "rep outsd dx, dword ptr [si]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\xF3\xA4", "rep movsb byte ptr es:[di], byte ptr [si]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\xF3\xA5", "rep movsd dword ptr es:[di], dword ptr [si]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\xF3\xA6", "repe cmpsb byte ptr [si], byte ptr es:[di]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\xF3\xA7", "repe cmpsd dword ptr [si], dword ptr es:[di]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\xF3\xAA", "rep stosb byte ptr es:[di], al"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\xF3\xAB", "rep stosd dword ptr es:[di], eax"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\xF3\xAC", "rep lodsb al, byte ptr [si]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\xF3\xAD", "rep lodsd eax, dword ptr [si]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\xF3\xAE", "repe scasb al, byte ptr es:[di]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\xF3\xAF", "repe scasd eax, dword ptr es:[di]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x67\xF2\x6C", "repne insb byte ptr es:[edi], dx"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x67\xF2\x6D", "repne insw word ptr es:[edi], dx"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x67\xF2\x6E", "repne outsb dx, byte ptr [esi]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x67\xF2\x6F", "repne outsw dx, word ptr [esi]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x67\xF2\xA4", "repne movsb byte ptr es:[edi], byte ptr [esi]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x67\xF2\xA5", "repne movsw word ptr es:[edi], word ptr [esi]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x67\xF2\xA6", "repne cmpsb byte ptr [esi], byte ptr es:[edi]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x67\xF2\xA7", "repne cmpsw word ptr [esi], word ptr es:[edi]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x67\xF2\xAA", "repne stosb byte ptr es:[edi], al"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x67\xF2\xAB", "repne stosw word ptr es:[edi], ax"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x67\xF2\xAC", "repne lodsb al, byte ptr [esi]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x67\xF2\xAD", "repne lodsw ax, word ptr [esi]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x67\xF2\xAE", "repne scasb al, byte ptr es:[edi]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x67\xF2\xAF", "repne scasw ax, word ptr es:[edi]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x67\xF3\x6C", "rep insb byte ptr es:[edi], dx"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x67\xF3\x6D", "rep insw word ptr es:[edi], dx"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x67\xF3\x6E", "rep outsb dx, byte ptr [esi]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x67\xF3\x6F", "rep outsw dx, word ptr [esi]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x67\xF3\xA4", "rep movsb byte ptr es:[edi], byte ptr [esi]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x67\xF3\xA5", "rep movsw word ptr es:[edi], word ptr [esi]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x67\xF3\xA6", "repe cmpsb byte ptr [esi], byte ptr es:[edi]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x67\xF3\xA7", "repe cmpsw word ptr [esi], word ptr es:[edi]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x67\xF3\xAA", "rep stosb byte ptr es:[edi], al"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x67\xF3\xAB", "rep stosw word ptr es:[edi], ax"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x67\xF3\xAC", "rep lodsb al, byte ptr [esi]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x67\xF3\xAD", "rep lodsw ax, word ptr [esi]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x67\xF3\xAE", "repe scasb al, byte ptr es:[edi]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x67\xF3\xAF", "repe scasw ax, word ptr es:[edi]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\x67\xF2\x6C", "repne insb byte ptr es:[edi], dx"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\x67\xF2\x6D", "repne insd dword ptr es:[edi], dx"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\x67\xF2\x6E", "repne outsb dx, byte ptr [esi]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\x67\xF2\x6F", "repne outsd dx, dword ptr [esi]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\x67\xF2\xA4", "repne movsb byte ptr es:[edi], byte ptr [esi]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\x67\xF2\xA5", "repne movsd dword ptr es:[edi], dword ptr [esi]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\x67\xF2\xA6", "repne cmpsb byte ptr [esi], byte ptr es:[edi]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\x67\xF2\xA7", "repne cmpsd dword ptr [esi], dword ptr es:[edi]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\x67\xF2\xAA", "repne stosb byte ptr es:[edi], al"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\x67\xF2\xAB", "repne stosd dword ptr es:[edi], eax"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\x67\xF2\xAC", "repne lodsb al, byte ptr [esi]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\x67\xF2\xAD", "repne lodsd eax, dword ptr [esi]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\x67\xF2\xAE", "repne scasb al, byte ptr es:[edi]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\x67\xF2\xAF", "repne scasd eax, dword ptr es:[edi]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\x67\xF3\x6C", "rep insb byte ptr es:[edi], dx"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\x67\xF3\x6D", "rep insd dword ptr es:[edi], dx"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\x67\xF3\x6E", "rep outsb dx, byte ptr [esi]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\x67\xF3\x6F", "rep outsd dx, dword ptr [esi]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\x67\xF3\xA4", "rep movsb byte ptr es:[edi], byte ptr [esi]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\x67\xF3\xA5", "rep movsd dword ptr es:[edi], dword ptr [esi]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\x67\xF3\xA6", "repe cmpsb byte ptr [esi], byte ptr es:[edi]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\x67\xF3\xA7", "repe cmpsd dword ptr [esi], dword ptr es:[edi]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\x67\xF3\xAA", "rep stosb byte ptr es:[edi], al"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\x67\xF3\xAB", "rep stosd dword ptr es:[edi], eax"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\x67\xF3\xAC", "rep lodsb al, byte ptr [esi]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\x67\xF3\xAD", "rep lodsd eax, dword ptr [esi]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\x67\xF3\xAE", "repe scasb al, byte ptr es:[edi]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\x67\xF3\xAF", "repe scasd eax, dword ptr es:[edi]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x6C", "insb byte ptr es:[edi], dx"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x6D", "insd dword ptr es:[edi], dx"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x6E", "outsb dx, byte ptr [esi]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x6F", "outsd dx, dword ptr [esi]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\xA4", "movsb byte ptr es:[edi], byte ptr [esi]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\xA5", "movsd dword ptr es:[edi], dword ptr [esi]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\xA6", "cmpsb byte ptr [esi], byte ptr es:[edi]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\xA7", "cmpsd dword ptr [esi], dword ptr es:[edi]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\xAA", "stosb byte ptr es:[edi], al"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\xAB", "stosd dword ptr es:[edi], eax"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\xAC", "lodsb al, byte ptr [esi]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\xAD", "lodsd eax, dword ptr [esi]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\xAE", "scasb al, byte ptr es:[edi]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\xAF", "scasd eax, dword ptr es:[edi]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\x6C", "insb byte ptr es:[edi], dx"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\x6D", "insw word ptr es:[edi], dx"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\x6E", "outsb dx, byte ptr [esi]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\x6F", "outsw dx, word ptr [esi]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\xA4", "movsb byte ptr es:[edi], byte ptr [esi]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\xA5", "movsw word ptr es:[edi], word ptr [esi]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\xA6", "cmpsb byte ptr [esi], byte ptr es:[edi]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\xA7", "cmpsw word ptr [esi], word ptr es:[edi]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\xAA", "stosb byte ptr es:[edi], al"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\xAB", "stosw word ptr es:[edi], ax"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\xAC", "lodsb al, byte ptr [esi]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\xAD", "lodsw ax, word ptr [esi]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\xAE", "scasb al, byte ptr es:[edi]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\xAF", "scasw ax, word ptr es:[edi]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x67\x6C", "insb byte ptr es:[di], dx"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x67\x6D", "insd dword ptr es:[di], dx"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x67\x6E", "outsb dx, byte ptr [si]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x67\x6F", "outsd dx, dword ptr [si]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x67\xA4", "movsb byte ptr es:[di], byte ptr [si]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x67\xA5", "movsd dword ptr es:[di], dword ptr [si]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x67\xA6", "cmpsb byte ptr [si], byte ptr es:[di]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x67\xA7", "cmpsd dword ptr [si], dword ptr es:[di]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x67\xAA", "stosb byte ptr es:[di], al"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x67\xAB", "stosd dword ptr es:[di], eax"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x67\xAC", "lodsb al, byte ptr [si]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x67\xAD", "lodsd eax, dword ptr [si]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x67\xAE", "scasb al, byte ptr es:[di]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x67\xAF", "scasd eax, dword ptr es:[di]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\xF2\x6C", "repne insb byte ptr es:[edi], dx"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\xF2\x6D", "repne insd dword ptr es:[edi], dx"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\xF2\x6E", "repne outsb dx, byte ptr [esi]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\xF2\x6F", "repne outsd dx, dword ptr [esi]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\xF2\xA4", "repne movsb byte ptr es:[edi], byte ptr [esi]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\xF2\xA5", "repne movsd dword ptr es:[edi], dword ptr [esi]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\xF2\xA6", "repne cmpsb byte ptr [esi], byte ptr es:[edi]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\xF2\xA7", "repne cmpsd dword ptr [esi], dword ptr es:[edi]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\xF2\xAA", "repne stosb byte ptr es:[edi], al"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\xF2\xAB", "repne stosd dword ptr es:[edi], eax"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\xF2\xAC", "repne lodsb al, byte ptr [esi]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\xF2\xAD", "repne lodsd eax, dword ptr [esi]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\xF2\xAE", "repne scasb al, byte ptr es:[edi]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\xF2\xAF", "repne scasd eax, dword ptr es:[edi]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\xF3\x6C", "rep insb byte ptr es:[edi], dx"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\xF3\x6D", "rep insd dword ptr es:[edi], dx"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\xF3\x6E", "rep outsb dx, byte ptr [esi]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\xF3\x6F", "rep outsd dx, dword ptr [esi]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\xF3\xA4", "rep movsb byte ptr es:[edi], byte ptr [esi]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\xF3\xA5", "rep movsd dword ptr es:[edi], dword ptr [esi]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\xF3\xA6", "repe cmpsb byte ptr [esi], byte ptr es:[edi]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\xF3\xA7", "repe cmpsd dword ptr [esi], dword ptr es:[edi]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\xF3\xAA", "rep stosb byte ptr es:[edi], al"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\xF3\xAB", "rep stosd dword ptr es:[edi], eax"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\xF3\xAC", "rep lodsb al, byte ptr [esi]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\xF3\xAD", "rep lodsd eax, dword ptr [esi]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\xF3\xAE", "repe scasb al, byte ptr es:[edi]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\xF3\xAF", "repe scasd eax, dword ptr es:[edi]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\x67\x6C", "insb byte ptr es:[di], dx"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\x67\x6D", "insw word ptr es:[di], dx"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\x67\x6E", "outsb dx, byte ptr [si]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\x67\x6F", "outsw dx, word ptr [si]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\x67\xA4", "movsb byte ptr es:[di], byte ptr [si]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\x67\xA5", "movsw word ptr es:[di], word ptr [si]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\x67\xA6", "cmpsb byte ptr [si], byte ptr es:[di]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\x67\xA7", "cmpsw word ptr [si], word ptr es:[di]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\x67\xAA", "stosb byte ptr es:[di], al"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\x67\xAB", "stosw word ptr es:[di], ax"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\x67\xAC", "lodsb al, byte ptr [si]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\x67\xAD", "lodsw ax, word ptr [si]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\x67\xAE", "scasb al, byte ptr es:[di]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\x67\xAF", "scasw ax, word ptr es:[di]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\xF2\x6C", "repne insb byte ptr es:[edi], dx"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\xF2\x6D", "repne insw word ptr es:[edi], dx"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\xF2\x6E", "repne outsb dx, byte ptr [esi]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\xF2\x6F", "repne outsw dx, word ptr [esi]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\xF2\xA4", "repne movsb byte ptr es:[edi], byte ptr [esi]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\xF2\xA5", "repne movsw word ptr es:[edi], word ptr [esi]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\xF2\xA6", "repne cmpsb byte ptr [esi], byte ptr es:[edi]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\xF2\xA7", "repne cmpsw word ptr [esi], word ptr es:[edi]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\xF2\xAA", "repne stosb byte ptr es:[edi], al"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\xF2\xAB", "repne stosw word ptr es:[edi], ax"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\xF2\xAC", "repne lodsb al, byte ptr [esi]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\xF2\xAD", "repne lodsw ax, word ptr [esi]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\xF2\xAE", "repne scasb al, byte ptr es:[edi]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\xF2\xAF", "repne scasw ax, word ptr es:[edi]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\xF3\x6C", "rep insb byte ptr es:[edi], dx"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\xF3\x6D", "rep insw word ptr es:[edi], dx"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\xF3\x6E", "rep outsb dx, byte ptr [esi]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\xF3\x6F", "rep outsw dx, word ptr [esi]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\xF3\xA4", "rep movsb byte ptr es:[edi], byte ptr [esi]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\xF3\xA5", "rep movsw word ptr es:[edi], word ptr [esi]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\xF3\xA6", "repe cmpsb byte ptr [esi], byte ptr es:[edi]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\xF3\xA7", "repe cmpsw word ptr [esi], word ptr es:[edi]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\xF3\xAA", "rep stosb byte ptr es:[edi], al"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\xF3\xAB", "rep stosw word ptr es:[edi], ax"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\xF3\xAC", "rep lodsb al, byte ptr [esi]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\xF3\xAD", "rep lodsw ax, word ptr [esi]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\xF3\xAE", "repe scasb al, byte ptr es:[edi]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\xF3\xAF", "repe scasw ax, word ptr es:[edi]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x67\xF2\x6C", "repne insb byte ptr es:[di], dx"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x67\xF2\x6D", "repne insd dword ptr es:[di], dx"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x67\xF2\x6E", "repne outsb dx, byte ptr [si]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x67\xF2\x6F", "repne outsd dx, dword ptr [si]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x67\xF2\xA4", "repne movsb byte ptr es:[di], byte ptr [si]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x67\xF2\xA5", "repne movsd dword ptr es:[di], dword ptr [si]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x67\xF2\xA6", "repne cmpsb byte ptr [si], byte ptr es:[di]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x67\xF2\xA7", "repne cmpsd dword ptr [si], dword ptr es:[di]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x67\xF2\xAA", "repne stosb byte ptr es:[di], al"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x67\xF2\xAB", "repne stosd dword ptr es:[di], eax"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x67\xF2\xAC", "repne lodsb al, byte ptr [si]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x67\xF2\xAD", "repne lodsd eax, dword ptr [si]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x67\xF2\xAE", "repne scasb al, byte ptr es:[di]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x67\xF2\xAF", "repne scasd eax, dword ptr es:[di]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x67\xF3\x6C", "rep insb byte ptr es:[di], dx"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x67\xF3\x6D", "rep insd dword ptr es:[di], dx"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x67\xF3\x6E", "rep outsb dx, byte ptr [si]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x67\xF3\x6F", "rep outsd dx, dword ptr [si]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x67\xF3\xA4", "rep movsb byte ptr es:[di], byte ptr [si]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x67\xF3\xA5", "rep movsd dword ptr es:[di], dword ptr [si]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x67\xF3\xA6", "repe cmpsb byte ptr [si], byte ptr es:[di]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x67\xF3\xA7", "repe cmpsd dword ptr [si], dword ptr es:[di]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x67\xF3\xAA", "rep stosb byte ptr es:[di], al"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x67\xF3\xAB", "rep stosd dword ptr es:[di], eax"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x67\xF3\xAC", "rep lodsb al, byte ptr [si]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x67\xF3\xAD", "rep lodsd eax, dword ptr [si]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x67\xF3\xAE", "repe scasb al, byte ptr es:[di]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x67\xF3\xAF", "repe scasd eax, dword ptr es:[di]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\x67\xF2\x6C", "repne insb byte ptr es:[di], dx"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\x67\xF2\x6D", "repne insw word ptr es:[di], dx"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\x67\xF2\x6E", "repne outsb dx, byte ptr [si]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\x67\xF2\x6F", "repne outsw dx, word ptr [si]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\x67\xF2\xA4", "repne movsb byte ptr es:[di], byte ptr [si]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\x67\xF2\xA5", "repne movsw word ptr es:[di], word ptr [si]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\x67\xF2\xA6", "repne cmpsb byte ptr [si], byte ptr es:[di]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\x67\xF2\xA7", "repne cmpsw word ptr [si], word ptr es:[di]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\x67\xF2\xAA", "repne stosb byte ptr es:[di], al"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\x67\xF2\xAB", "repne stosw word ptr es:[di], ax"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\x67\xF2\xAC", "repne lodsb al, byte ptr [si]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\x67\xF2\xAD", "repne lodsw ax, word ptr [si]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\x67\xF2\xAE", "repne scasb al, byte ptr es:[di]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\x67\xF2\xAF", "repne scasw ax, word ptr es:[di]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\x67\xF3\x6C", "rep insb byte ptr es:[di], dx"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\x67\xF3\x6D", "rep insw word ptr es:[di], dx"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\x67\xF3\x6E", "rep outsb dx, byte ptr [si]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\x67\xF3\x6F", "rep outsw dx, word ptr [si]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\x67\xF3\xA4", "rep movsb byte ptr es:[di], byte ptr [si]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\x67\xF3\xA5", "rep movsw word ptr es:[di], word ptr [si]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\x67\xF3\xA6", "repe cmpsb byte ptr [si], byte ptr es:[di]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\x67\xF3\xA7", "repe cmpsw word ptr [si], word ptr es:[di]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\x67\xF3\xAA", "rep stosb byte ptr es:[di], al"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\x67\xF3\xAB", "rep stosw word ptr es:[di], ax"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\x67\xF3\xAC", "rep lodsb al, byte ptr [si]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\x67\xF3\xAD", "rep lodsw ax, word ptr [si]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\x67\xF3\xAE", "repe scasb al, byte ptr es:[di]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\x67\xF3\xAF", "repe scasw ax, word ptr es:[di]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x6C", "insb byte ptr [rdi], dx"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x6D", "insd dword ptr [rdi], dx"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x6E", "outsb dx, byte ptr [rsi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x6F", "outsd dx, dword ptr [rsi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\xA4", "movsb byte ptr [rdi], byte ptr [rsi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\xA5", "movsd dword ptr [rdi], dword ptr [rsi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\xA6", "cmpsb byte ptr [rsi], byte ptr [rdi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\xA7", "cmpsd dword ptr [rsi], dword ptr [rdi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\xAA", "stosb byte ptr [rdi], al"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\xAB", "stosd dword ptr [rdi], eax"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\xAC", "lodsb al, byte ptr [rsi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\xAD", "lodsd eax, dword ptr [rsi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\xAE", "scasb al, byte ptr [rdi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\xAF", "scasd eax, dword ptr [rdi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x6C", "insb byte ptr [rdi], dx"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x6D", "insw word ptr [rdi], dx"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x6E", "outsb dx, byte ptr [rsi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x6F", "outsw dx, word ptr [rsi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\xA4", "movsb byte ptr [rdi], byte ptr [rsi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\xA5", "movsw word ptr [rdi], word ptr [rsi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\xA6", "cmpsb byte ptr [rsi], byte ptr [rdi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\xA7", "cmpsw word ptr [rsi], word ptr [rdi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\xAA", "stosb byte ptr [rdi], al"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\xAB", "stosw word ptr [rdi], ax"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\xAC", "lodsb al, byte ptr [rsi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\xAD", "lodsw ax, word ptr [rsi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\xAE", "scasb al, byte ptr [rdi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\xAF", "scasw ax, word ptr [rdi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x67\x6C", "insb byte ptr [edi], dx"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x67\x6D", "insd dword ptr [edi], dx"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x67\x6E", "outsb dx, byte ptr [esi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x67\x6F", "outsd dx, dword ptr [esi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x67\xA4", "movsb byte ptr [edi], byte ptr [esi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x67\xA5", "movsd dword ptr [edi], dword ptr [esi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x67\xA6", "cmpsb byte ptr [esi], byte ptr [edi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x67\xA7", "cmpsd dword ptr [esi], dword ptr [edi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x67\xAA", "stosb byte ptr [edi], al"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x67\xAB", "stosd dword ptr [edi], eax"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x67\xAC", "lodsb al, byte ptr [esi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x67\xAD", "lodsd eax, dword ptr [esi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x67\xAE", "scasb al, byte ptr [edi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x67\xAF", "scasd eax, dword ptr [edi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\xF2\x6C", "repne insb byte ptr [rdi], dx"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\xF2\x6D", "repne insd dword ptr [rdi], dx"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\xF2\x6E", "repne outsb dx, byte ptr [rsi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\xF2\x6F", "repne outsd dx, dword ptr [rsi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\xF2\xA4", "repne movsb byte ptr [rdi], byte ptr [rsi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\xF2\xA5", "repne movsd dword ptr [rdi], dword ptr [rsi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\xF2\xA6", "repne cmpsb byte ptr [rsi], byte ptr [rdi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\xF2\xA7", "repne cmpsd dword ptr [rsi], dword ptr [rdi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\xF2\xAA", "repne stosb byte ptr [rdi], al"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\xF2\xAB", "repne stosd dword ptr [rdi], eax"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\xF2\xAC", "repne lodsb al, byte ptr [rsi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\xF2\xAD", "repne lodsd eax, dword ptr [rsi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\xF2\xAE", "repne scasb al, byte ptr [rdi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\xF2\xAF", "repne scasd eax, dword ptr [rdi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\xF3\x6C", "rep insb byte ptr [rdi], dx"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\xF3\x6D", "rep insd dword ptr [rdi], dx"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\xF3\x6E", "rep outsb dx, byte ptr [rsi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\xF3\x6F", "rep outsd dx, dword ptr [rsi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\xF3\xA4", "rep movsb byte ptr [rdi], byte ptr [rsi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\xF3\xA5", "rep movsd dword ptr [rdi], dword ptr [rsi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\xF3\xA6", "repe cmpsb byte ptr [rsi], byte ptr [rdi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\xF3\xA7", "repe cmpsd dword ptr [rsi], dword ptr [rdi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\xF3\xAA", "rep stosb byte ptr [rdi], al"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\xF3\xAB", "rep stosd dword ptr [rdi], eax"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\xF3\xAC", "rep lodsb al, byte ptr [rsi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\xF3\xAD", "rep lodsd eax, dword ptr [rsi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\xF3\xAE", "repe scasb al, byte ptr [rdi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\xF3\xAF", "repe scasd eax, dword ptr [rdi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x67\x6C", "insb byte ptr [edi], dx"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x67\x6D", "insw word ptr [edi], dx"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x67\x6E", "outsb dx, byte ptr [esi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x67\x6F", "outsw dx, word ptr [esi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x67\xA4", "movsb byte ptr [edi], byte ptr [esi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x67\xA5", "movsw word ptr [edi], word ptr [esi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x67\xA6", "cmpsb byte ptr [esi], byte ptr [edi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x67\xA7", "cmpsw word ptr [esi], word ptr [edi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x67\xAA", "stosb byte ptr [edi], al"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x67\xAB", "stosw word ptr [edi], ax"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x67\xAC", "lodsb al, byte ptr [esi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x67\xAD", "lodsw ax, word ptr [esi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x67\xAE", "scasb al, byte ptr [edi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x67\xAF", "scasw ax, word ptr [edi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\xF2\x6C", "repne insb byte ptr [rdi], dx"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\xF2\x6D", "repne insw word ptr [rdi], dx"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\xF2\x6E", "repne outsb dx, byte ptr [rsi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\xF2\x6F", "repne outsw dx, word ptr [rsi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\xF2\xA4", "repne movsb byte ptr [rdi], byte ptr [rsi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\xF2\xA5", "repne movsw word ptr [rdi], word ptr [rsi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\xF2\xA6", "repne cmpsb byte ptr [rsi], byte ptr [rdi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\xF2\xA7", "repne cmpsw word ptr [rsi], word ptr [rdi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\xF2\xAA", "repne stosb byte ptr [rdi], al"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\xF2\xAB", "repne stosw word ptr [rdi], ax"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\xF2\xAC", "repne lodsb al, byte ptr [rsi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\xF2\xAD", "repne lodsw ax, word ptr [rsi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\xF2\xAE", "repne scasb al, byte ptr [rdi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\xF2\xAF", "repne scasw ax, word ptr [rdi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\xF3\x6C", "rep insb byte ptr [rdi], dx"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\xF3\x6D", "rep insw word ptr [rdi], dx"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\xF3\x6E", "rep outsb dx, byte ptr [rsi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\xF3\x6F", "rep outsw dx, word ptr [rsi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\xF3\xA4", "rep movsb byte ptr [rdi], byte ptr [rsi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\xF3\xA5", "rep movsw word ptr [rdi], word ptr [rsi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\xF3\xA6", "repe cmpsb byte ptr [rsi], byte ptr [rdi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\xF3\xA7", "repe cmpsw word ptr [rsi], word ptr [rdi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\xF3\xAA", "rep stosb byte ptr [rdi], al"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\xF3\xAB", "rep stosw word ptr [rdi], ax"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\xF3\xAC", "rep lodsb al, byte ptr [rsi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\xF3\xAD", "rep lodsw ax, word ptr [rsi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\xF3\xAE", "repe scasb al, byte ptr [rdi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\xF3\xAF", "repe scasw ax, word ptr [rdi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x67\xF2\x6C", "repne insb byte ptr [edi], dx"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x67\xF2\x6D", "repne insd dword ptr [edi], dx"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x67\xF2\x6E", "repne outsb dx, byte ptr [esi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x67\xF2\x6F", "repne outsd dx, dword ptr [esi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x67\xF2\xA4", "repne movsb byte ptr [edi], byte ptr [esi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x67\xF2\xA5", "repne movsd dword ptr [edi], dword ptr [esi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x67\xF2\xA6", "repne cmpsb byte ptr [esi], byte ptr [edi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x67\xF2\xA7", "repne cmpsd dword ptr [esi], dword ptr [edi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x67\xF2\xAA", "repne stosb byte ptr [edi], al"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x67\xF2\xAB", "repne stosd dword ptr [edi], eax"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x67\xF2\xAC", "repne lodsb al, byte ptr [esi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x67\xF2\xAD", "repne lodsd eax, dword ptr [esi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x67\xF2\xAE", "repne scasb al, byte ptr [edi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x67\xF2\xAF", "repne scasd eax, dword ptr [edi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x67\xF3\x6C", "rep insb byte ptr [edi], dx"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x67\xF3\x6D", "rep insd dword ptr [edi], dx"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x67\xF3\x6E", "rep outsb dx, byte ptr [esi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x67\xF3\x6F", "rep outsd dx, dword ptr [esi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x67\xF3\xA4", "rep movsb byte ptr [edi], byte ptr [esi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x67\xF3\xA5", "rep movsd dword ptr [edi], dword ptr [esi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x67\xF3\xA6", "repe cmpsb byte ptr [esi], byte ptr [edi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x67\xF3\xA7", "repe cmpsd dword ptr [esi], dword ptr [edi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x67\xF3\xAA", "rep stosb byte ptr [edi], al"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x67\xF3\xAB", "rep stosd dword ptr [edi], eax"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x67\xF3\xAC", "rep lodsb al, byte ptr [esi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x67\xF3\xAD", "rep lodsd eax, dword ptr [esi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x67\xF3\xAE", "repe scasb al, byte ptr [edi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x67\xF3\xAF", "repe scasd eax, dword ptr [edi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x67\xF2\x6C", "repne insb byte ptr [edi], dx"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x67\xF2\x6D", "repne insw word ptr [edi], dx"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x67\xF2\x6E", "repne outsb dx, byte ptr [esi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x67\xF2\x6F", "repne outsw dx, word ptr [esi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x67\xF2\xA4", "repne movsb byte ptr [edi], byte ptr [esi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x67\xF2\xA5", "repne movsw word ptr [edi], word ptr [esi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x67\xF2\xA6", "repne cmpsb byte ptr [esi], byte ptr [edi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x67\xF2\xA7", "repne cmpsw word ptr [esi], word ptr [edi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x67\xF2\xAA", "repne stosb byte ptr [edi], al"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x67\xF2\xAB", "repne stosw word ptr [edi], ax"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x67\xF2\xAC", "repne lodsb al, byte ptr [esi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x67\xF2\xAD", "repne lodsw ax, word ptr [esi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x67\xF2\xAE", "repne scasb al, byte ptr [edi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x67\xF2\xAF", "repne scasw ax, word ptr [edi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x67\xF3\x6C", "rep insb byte ptr [edi], dx"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x67\xF3\x6D", "rep insw word ptr [edi], dx"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x67\xF3\x6E", "rep outsb dx, byte ptr [esi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x67\xF3\x6F", "rep outsw dx, word ptr [esi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x67\xF3\xA4", "rep movsb byte ptr [edi], byte ptr [esi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x67\xF3\xA5", "rep movsw word ptr [edi], word ptr [esi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x67\xF3\xA6", "repe cmpsb byte ptr [esi], byte ptr [edi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x67\xF3\xA7", "repe cmpsw word ptr [esi], word ptr [edi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x67\xF3\xAA", "rep stosb byte ptr [edi], al"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x67\xF3\xAB", "rep stosw word ptr [edi], ax"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x67\xF3\xAC", "rep lodsb al, byte ptr [esi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x67\xF3\xAD", "rep lodsw ax, word ptr [esi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x67\xF3\xAE", "repe scasb al, byte ptr [edi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x67\xF3\xAF", "repe scasw ax, word ptr [edi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x48\xA4", "movsb byte ptr [rdi], byte ptr [rsi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x48\xA5", "movsq qword ptr [rdi], qword ptr [rsi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x48\xA6", "cmpsb byte ptr [rsi], byte ptr [rdi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x48\xA7", "cmpsq qword ptr [rsi], qword ptr [rdi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x48\xAA", "stosb byte ptr [rdi], al"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x48\xAB", "stosq qword ptr [rdi], rax"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x48\xAC", "lodsb al, byte ptr [rsi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x48\xAD", "lodsq rax, qword ptr [rsi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x48\xAE", "scasb al, byte ptr [rdi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x48\xAF", "scasq rax, qword ptr [rdi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x48\xA4", "movsb byte ptr [rdi], byte ptr [rsi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x48\xA5", "movsq qword ptr [rdi], qword ptr [rsi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x48\xA6", "cmpsb byte ptr [rsi], byte ptr [rdi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x48\xA7", "cmpsq qword ptr [rsi], qword ptr [rdi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x48\xAA", "stosb byte ptr [rdi], al"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x48\xAB", "stosq qword ptr [rdi], rax"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x48\xAC", "lodsb al, byte ptr [rsi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x48\xAD", "lodsq rax, qword ptr [rsi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x48\xAE", "scasb al, byte ptr [rdi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x48\xAF", "scasq rax, qword ptr [rdi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x67\x48\xA4", "movsb byte ptr [edi], byte ptr [esi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x67\x48\xA5", "movsq qword ptr [edi], qword ptr [esi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x67\x48\xA6", "cmpsb byte ptr [esi], byte ptr [edi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x67\x48\xA7", "cmpsq qword ptr [esi], qword ptr [edi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x67\x48\xAA", "stosb byte ptr [edi], al"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x67\x48\xAB", "stosq qword ptr [edi], rax"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x67\x48\xAC", "lodsb al, byte ptr [esi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x67\x48\xAD", "lodsq rax, qword ptr [esi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x67\x48\xAE", "scasb al, byte ptr [edi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x67\x48\xAF", "scasq rax, qword ptr [edi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\xF2\x48\xA4", "repne movsb byte ptr [rdi], byte ptr [rsi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\xF2\x48\xA5", "repne movsq qword ptr [rdi], qword ptr [rsi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\xF2\x48\xA6", "repne cmpsb byte ptr [rsi], byte ptr [rdi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\xF2\x48\xA7", "repne cmpsq qword ptr [rsi], qword ptr [rdi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\xF2\x48\xAA", "repne stosb byte ptr [rdi], al"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\xF2\x48\xAB", "repne stosq qword ptr [rdi], rax"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\xF2\x48\xAC", "repne lodsb al, byte ptr [rsi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\xF2\x48\xAD", "repne lodsq rax, qword ptr [rsi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\xF2\x48\xAE", "repne scasb al, byte ptr [rdi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\xF2\x48\xAF", "repne scasq rax, qword ptr [rdi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\xF3\x48\xA4", "rep movsb byte ptr [rdi], byte ptr [rsi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\xF3\x48\xA5", "rep movsq qword ptr [rdi], qword ptr [rsi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\xF3\x48\xA6", "repe cmpsb byte ptr [rsi], byte ptr [rdi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\xF3\x48\xA7", "repe cmpsq qword ptr [rsi], qword ptr [rdi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\xF3\x48\xAA", "rep stosb byte ptr [rdi], al"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\xF3\x48\xAB", "rep stosq qword ptr [rdi], rax"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\xF3\x48\xAC", "rep lodsb al, byte ptr [rsi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\xF3\x48\xAD", "rep lodsq rax, qword ptr [rsi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\xF3\x48\xAE", "repe scasb al, byte ptr [rdi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\xF3\x48\xAF", "repe scasq rax, qword ptr [rdi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x67\x48\xA4", "movsb byte ptr [edi], byte ptr [esi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x67\x48\xA5", "movsq qword ptr [edi], qword ptr [esi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x67\x48\xA6", "cmpsb byte ptr [esi], byte ptr [edi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x67\x48\xA7", "cmpsq qword ptr [esi], qword ptr [edi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x67\x48\xAA", "stosb byte ptr [edi], al"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x67\x48\xAB", "stosq qword ptr [edi], rax"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x67\x48\xAC", "lodsb al, byte ptr [esi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x67\x48\xAD", "lodsq rax, qword ptr [esi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x67\x48\xAE", "scasb al, byte ptr [edi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x67\x48\xAF", "scasq rax, qword ptr [edi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\xF2\x48\xA4", "repne movsb byte ptr [rdi], byte ptr [rsi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\xF2\x48\xA5", "repne movsq qword ptr [rdi], qword ptr [rsi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\xF2\x48\xA6", "repne cmpsb byte ptr [rsi], byte ptr [rdi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\xF2\x48\xA7", "repne cmpsq qword ptr [rsi], qword ptr [rdi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\xF2\x48\xAA", "repne stosb byte ptr [rdi], al"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\xF2\x48\xAB", "repne stosq qword ptr [rdi], rax"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\xF2\x48\xAC", "repne lodsb al, byte ptr [rsi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\xF2\x48\xAD", "repne lodsq rax, qword ptr [rsi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\xF2\x48\xAE", "repne scasb al, byte ptr [rdi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\xF2\x48\xAF", "repne scasq rax, qword ptr [rdi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\xF3\x48\xA4", "rep movsb byte ptr [rdi], byte ptr [rsi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\xF3\x48\xA5", "rep movsq qword ptr [rdi], qword ptr [rsi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\xF3\x48\xA6", "repe cmpsb byte ptr [rsi], byte ptr [rdi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\xF3\x48\xA7", "repe cmpsq qword ptr [rsi], qword ptr [rdi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\xF3\x48\xAA", "rep stosb byte ptr [rdi], al"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\xF3\x48\xAB", "rep stosq qword ptr [rdi], rax"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\xF3\x48\xAC", "rep lodsb al, byte ptr [rsi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\xF3\x48\xAD", "rep lodsq rax, qword ptr [rsi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\xF3\x48\xAE", "repe scasb al, byte ptr [rdi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\xF3\x48\xAF", "repe scasq rax, qword ptr [rdi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x67\xF2\x48\xA4", "repne movsb byte ptr [edi], byte ptr [esi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x67\xF2\x48\xA5", "repne movsq qword ptr [edi], qword ptr [esi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x67\xF2\x48\xA6", "repne cmpsb byte ptr [esi], byte ptr [edi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x67\xF2\x48\xA7", "repne cmpsq qword ptr [esi], qword ptr [edi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x67\xF2\x48\xAA", "repne stosb byte ptr [edi], al"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x67\xF2\x48\xAB", "repne stosq qword ptr [edi], rax"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x67\xF2\x48\xAC", "repne lodsb al, byte ptr [esi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x67\xF2\x48\xAD", "repne lodsq rax, qword ptr [esi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x67\xF2\x48\xAE", "repne scasb al, byte ptr [edi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x67\xF2\x48\xAF", "repne scasq rax, qword ptr [edi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x67\xF3\x48\xA4", "rep movsb byte ptr [edi], byte ptr [esi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x67\xF3\x48\xA5", "rep movsq qword ptr [edi], qword ptr [esi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x67\xF3\x48\xA6", "repe cmpsb byte ptr [esi], byte ptr [edi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x67\xF3\x48\xA7", "repe cmpsq qword ptr [esi], qword ptr [edi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x67\xF3\x48\xAA", "rep stosb byte ptr [edi], al"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x67\xF3\x48\xAB", "rep stosq qword ptr [edi], rax"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x67\xF3\x48\xAC", "rep lodsb al, byte ptr [esi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x67\xF3\x48\xAD", "rep lodsq rax, qword ptr [esi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x67\xF3\x48\xAE", "repe scasb al, byte ptr [edi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x67\xF3\x48\xAF", "repe scasq rax, qword ptr [edi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x67\xF2\x48\xA4", "repne movsb byte ptr [edi], byte ptr [esi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x67\xF2\x48\xA5", "repne movsq qword ptr [edi], qword ptr [esi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x67\xF2\x48\xA6", "repne cmpsb byte ptr [esi], byte ptr [edi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x67\xF2\x48\xA7", "repne cmpsq qword ptr [esi], qword ptr [edi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x67\xF2\x48\xAA", "repne stosb byte ptr [edi], al"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x67\xF2\x48\xAB", "repne stosq qword ptr [edi], rax"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x67\xF2\x48\xAC", "repne lodsb al, byte ptr [esi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x67\xF2\x48\xAD", "repne lodsq rax, qword ptr [esi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x67\xF2\x48\xAE", "repne scasb al, byte ptr [edi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x67\xF2\x48\xAF", "repne scasq rax, qword ptr [edi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x67\xF3\x48\xA4", "rep movsb byte ptr [edi], byte ptr [esi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x67\xF3\x48\xA5", "rep movsq qword ptr [edi], qword ptr [esi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x67\xF3\x48\xA6", "repe cmpsb byte ptr [esi], byte ptr [edi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x67\xF3\x48\xA7", "repe cmpsq qword ptr [esi], qword ptr [edi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x67\xF3\x48\xAA", "rep stosb byte ptr [edi], al"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x67\xF3\x48\xAB", "rep stosq qword ptr [edi], rax"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x67\xF3\x48\xAC", "rep lodsb al, byte ptr [esi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x67\xF3\x48\xAD", "rep lodsq rax, qword ptr [esi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x67\xF3\x48\xAE", "repe scasb al, byte ptr [edi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x67\xF3\x48\xAF", "repe scasq rax, qword ptr [edi]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x0f\x01\x05\xa0\x90\x04\x08", "sgdt [rip + 0x80490a0]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x0f\x01\x05\xa0\x90\x04\x08", "sgdt [rip + 0x80490a0]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x0f\x01\x05\xa0\x90\x04\x08", "sgdt [0x80490a0]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\x0f\x01\x05\xa0\x90\x04\x08", "sgdt [0x80490a0]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x0f\x01\x05", "sgdt [di]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\x0f\x01\x05", "sgdt [di]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x0f\x01\x0d\xa0\x90\x04\x08", "sidt [rip + 0x80490a0]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x0f\x01\x0d\xa0\x90\x04\x08", "sidt [rip + 0x80490a0]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x0f\x01\x0d\xa0\x90\x04\x08", "sidt [0x80490a0]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\x0f\x01\x0d\xa0\x90\x04\x08", "sidt [0x80490a0]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x0f\x01\x0d", "sidt [di]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\x0f\x01\x0d", "sidt [di]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x0f\x01\x15\xa0\x90\x04\x08", "lgdt [rip + 0x80490a0]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x0f\x01\x15\xa0\x90\x04\x08", "lgdt [rip + 0x80490a0]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x0f\x01\x15\xa0\x90\x04\x08", "lgdt [0x80490a0]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\x0f\x01\x15\xa0\x90\x04\x08", "lgdt [0x80490a0]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x0f\x01\x15", "lgdt [di]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\x0f\x01\x15", "lgdt [di]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x0f\x01\x1d\xa0\x90\x04\x08", "lidt [rip + 0x80490a0]"),
(CS_ARCH_X86, CS_MODE_64, CS_OPT_SYNTAX_INTEL, 0x649123ffe1, b"\x66\x0f\x01\x1d\xa0\x90\x04\x08", "lidt [rip + 0x80490a0]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x0f\x01\x1d\xa0\x90\x04\x08", "lidt [0x80490a0]"),
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0x9123ffe1, b"\x66\x0f\x01\x1d\xa0\x90\x04\x08", "lidt [0x80490a0]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x0f\x01\x1d", "lidt [di]"),
(CS_ARCH_X86, CS_MODE_16, CS_OPT_SYNTAX_INTEL, 0xffe1, b"\x66\x0f\x01\x1d", "lidt [di]"),
# issues 702 https://github.com/aquynh/capstone/issues/702
(CS_ARCH_X86, CS_MODE_32, CS_OPT_SYNTAX_INTEL, 0, b"\x85\xC8", "test eax, ecx")
)
_python3 = sys.version_info.major == 3
def to_hex(s):
if _python3:
return " ".join("0x{0:02x}".format(c) for c in s) # <-- Python 3 is OK
else:
return " ".join("0x{0:02x}".format(ord(c)) for c in s)
def str_syntax(syntax):
slist = {
0: "",
CS_OPT_SYNTAX_INTEL: "intel",
CS_OPT_SYNTAX_ATT: "att",
}
return slist[syntax]
def str_arch_mode(a, m):
amlist = {
(CS_ARCH_X86, CS_MODE_16): "X86-16bit",
(CS_ARCH_X86, CS_MODE_32): "X86-32bit",
(CS_ARCH_X86, CS_MODE_64): "X86-64bit",
}
return amlist[(a, m)]
# ## Test cs_disasm_quick()
def test_regression(verbose):
for (arch, mode, syntax, address, code, expected_output) in all_tests:
#print("%s %s: %s = " %(str_arch_mode(arch, mode), str_syntax(syntax), to_hex(code)), end=""),
output = "%s %s: %s = " %(str_arch_mode(arch, mode), str_syntax(syntax), to_hex(code))
md = Cs(arch, mode)
if syntax != 0:
md.syntax = syntax
insn = list(md.disasm(code, address))[0]
output2 = "%s %s" % (insn.mnemonic, insn.op_str)
if output2 != expected_output:
print(output, output2)
print("\t --> ERROR: expected output = %s" %(expected_output))
elif verbose:
print(output, output2)
if __name__ == '__main__':
import sys
if len(sys.argv) == 2 and sys.argv[1] == "-v":
test_regression(True) # quiet
else:
test_regression(False) # verbose
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/capstone/suite/regress.py
|
#!/usr/bin/python
# Simple fuzzing tool by disassembling random code. By Nguyen Anh Quynh, 2014
# Syntax:
# ./suite/fuzz.py --> Fuzz all archs
# ./suite/fuzz.py x86 --> Fuzz all X86 (all 16bit, 32bit, 64bit)
# ./suite/fuzz.py x86-16 --> Fuzz X86-32 arch only
# ./suite/fuzz.py x86-32 --> Fuzz X86-32 arch only
# ./suite/fuzz.py x86-64 --> Fuzz X86-64 arch only
# ./suite/fuzz.py arm --> Fuzz all ARM (arm, thumb)
# ./suite/fuzz.py aarch64 --> Fuzz ARM-64
# ./suite/fuzz.py mips --> Fuzz all Mips (32bit, 64bit)
# ./suite/fuzz.py ppc --> Fuzz PPC
from capstone import *
from time import time
from random import randint
import sys
# file providing code to disassemble
FILE = '/usr/bin/python'
TIMES = 64
INTERVALS = (4, 5, 7, 9, 11, 13)
all_tests = (
(CS_ARCH_X86, CS_MODE_16, "X86-16bit (Intel syntax)", 0),
(CS_ARCH_X86, CS_MODE_16, "X86-16bit (ATT syntax)", CS_OPT_SYNTAX_ATT),
(CS_ARCH_X86, CS_MODE_32, "X86-32 (Intel syntax)", 0),
(CS_ARCH_X86, CS_MODE_32, "X86-32 (ATT syntax)", CS_OPT_SYNTAX_ATT),
(CS_ARCH_X86, CS_MODE_64, "X86-64 (Intel syntax)", 0),
(CS_ARCH_X86, CS_MODE_64, "X86-64 (ATT syntax)", CS_OPT_SYNTAX_ATT),
(CS_ARCH_ARM, CS_MODE_ARM, "ARM", 0),
(CS_ARCH_ARM, CS_MODE_THUMB, "THUMB (ARM)", 0),
(CS_ARCH_MIPS, CS_MODE_MIPS32 + CS_MODE_BIG_ENDIAN, "MIPS-32 (Big-endian)", 0),
(CS_ARCH_MIPS, CS_MODE_MIPS64 + CS_MODE_LITTLE_ENDIAN, "MIPS-64-EL (Little-endian)", 0),
(CS_ARCH_ARM64, CS_MODE_ARM, "ARM-64 (AArch64)", 0),
(CS_ARCH_PPC, CS_MODE_BIG_ENDIAN, "PPC", 0),
(CS_ARCH_PPC, CS_MODE_BIG_ENDIAN, "PPC, print register with number only", CS_OPT_SYNTAX_NOREGNAME),
(CS_ARCH_SPARC, CS_MODE_BIG_ENDIAN, "Sparc", 0),
(CS_ARCH_SYSZ, 0, "SystemZ", 0),
(CS_ARCH_XCORE, 0, "XCore", 0),
(CS_ARCH_M68K, 0, "M68K", 0),
(CS_ARCH_RISCV, CS_MODE_RISCV32, "riscv32", 0),
(CS_ARCH_RISCV, CS_MODE_RISCV64, "riscv64", 0),
)
# for debugging
def to_hex(s):
return " ".join("0x" + "{0:x}".format(ord(c)).zfill(2) for c in s) # <-- Python 3 is OK
# read @size bytes from @f & return data.
# return None when there is not enough data
def get_code(f, size):
code = f.read(size)
if len(code) != size: # reached end-of-file?
# then reset file position to begin-of-file
f.seek(0)
return None
return code
def cs(md, code):
insns = md.disasm(code, 0)
for i in insns:
if i.address == 0x100000:
print i
def cs_lite(md, code):
insns = md.disasm_lite(code, 0)
for (addr, size, mnem, ops) in insns:
if addr == 0x100000:
print i
cfile = open(FILE)
for (arch, mode, comment, syntax) in all_tests:
try:
request = sys.argv[1]
if not request in comment.lower():
continue
except:
pass
try:
md = Cs(arch, mode)
md.detail = True
if syntax != 0:
md.syntax = syntax
# test disasm()
print("\nFuzzing disasm() @platform: %s" %comment)
for ii in INTERVALS:
print("Interval: %u" %ii)
for j in xrange(1, TIMES):
while (True):
code = get_code(cfile, j * ii)
if code is None:
# EOF? break
break
#print to_hex(code)
cs(md, code)
# test disasm_lite()
print("Fuzzing disasm_lite() @platform: %s" %comment)
for ii in INTERVALS:
print("Interval: %u" %ii)
for j in xrange(1, TIMES):
while (True):
code = get_code(cfile, j * ii)
if code is None:
# EOF? break
break
#print to_hex(code)
cs_lite(md, code)
except CsError as e:
print("ERROR: %s" %e)
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/capstone/suite/fuzz.py
|
#!/usr/bin/python
import unittest
from os.path import dirname, basename, isfile
import glob
# Find all unittest type in this directory and run it.
class RegressTest(unittest.TestCase):
pass
def main():
unittest.main()
if __name__ == '__main__':
directory = dirname(__file__)
if directory == '':
directory = '.'
modules = glob.glob(directory+"/*.py")
__all__ = [ basename(f)[:-3] for f in modules if isfile(f)]
suite = unittest.TestSuite()
for module in __all__:
m = __import__(module)
for cl in dir(m):
try:
realcl = getattr(m,cl)
if issubclass(realcl, unittest.TestCase):
suite.addTest(realcl())
except Exception as e:
pass
unittest.TextTestRunner().run(suite)
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/capstone/suite/regress/regress.py
|
#!/usr/bin/python
# print MappingInsn.inc file from LLVM GenAsmMatcher.inc, for Capstone disassembler.
# by Nguyen Anh Quynh, 2019
import sys
if len(sys.argv) == 1:
print("Syntax: %s <GenAsmMatcher.inc> <GenInstrInfo.inc> <MappingInsnOp.inc>" %sys.argv[0])
sys.exit(1)
f = open(sys.argv[3])
mapping = f.readlines()
f.close()
print("""/* Capstone Disassembly Engine, http://www.capstone-engine.org */
/* This is auto-gen data for Capstone disassembly engine (www.capstone-engine.org) */
/* By Nguyen Anh Quynh <aquynh@gmail.com>, 2013-2019 */
""")
# lib/Target/X86/X86GenAsmMatcher.inc
# static const MatchEntry MatchTable1[] = {
# { 0 /* aaa */, X86::AAA, Convert_NoOperands, Feature_Not64BitMode, { }, },
# extract insn from GenAsmMatcher Table
# return (arch, mnem, insn_id)
def extract_insn(line):
tmp = line.split(',')
insn_raw = tmp[1].strip()
insn_mnem = tmp[0].split(' ')[3]
# X86 mov.s
if '.' in insn_mnem:
tmp = insn_mnem.split('.')
insn_mnem = tmp[0]
tmp = insn_raw.split('::')
arch = tmp[0]
# AArch64 -> ARM64
if arch.upper() == 'AARCH64':
arch = 'ARM64'
return (arch, insn_mnem, tmp[1])
# extract all insn lines from GenAsmMatcher
# return arch, insn_id_list, insn_lines
def extract_matcher(filename):
f = open(filename)
lines = f.readlines()
f.close()
match_count = 0
count = 0
#insn_lines = []
insn_id_list = {}
arch = None
first_insn = None
# 1st enum is register enum
for line in lines:
line = line.rstrip()
if len(line.strip()) == 0:
continue
if 'MatchEntry MatchTable1[] = {' in line.strip():
match_count += 1
#print(line.strip())
continue
line = line.strip()
if match_count == 1:
count += 1
if line == '};':
# done with first enum
break
else:
_arch, mnem, insn_id = extract_insn(line)
if count == 1:
arch, first_insn = _arch, insn_id
if not insn_id in insn_id_list:
# print("***", arch, mnem, insn_id)
insn_id_list[insn_id] = mnem
#insn_lines.append(line)
#return arch, first_insn, insn_id_list, insn_lines
return arch, first_insn, insn_id_list
#arch, first_insn, insn_id_list, match_lines = extract_matcher(sys.argv[1])
arch, first_insn, insn_id_list = extract_matcher(sys.argv[1])
arch = arch.upper()
#for line in insn_id_list:
# print(line)
#{ /* X86_AAA, X86_INS_AAA: aaa */
# X86_EFLAGS_UNDEFINED_OF | X86_EFLAGS_UNDEFINED_SF | X86_EFLAGS_UNDEFINED_ZF | X86_EFLAGS_MODIFY_AF | X86_EFLAGS_UNDEFINED_PF | X86_EFLAGS_MODIFY_CF,
# { 0 }
#},
def print_entry(arch, insn_id, mnem, mapping, mnem_can_be_wrong):
insn = "%s_%s" %(arch, insn_id)
# first, try to find this entry in old MappingInsn.inc file
for i in range(len(mapping)):
if mapping[i].startswith('{') and '/*' in mapping[i]:
#print(mapping[i])
tmp = mapping[i].split('/*')
tmp = tmp[1].strip()
tmp = tmp.split(',')
#print("insn2 = |%s|" %tmp.strip())
if tmp[0].strip() == insn:
if not mnem_can_be_wrong:
print('''
{\t/* %s, %s_INS_%s: %s */
\t%s
\t%s
},'''% (insn, arch, mnem, mnem.lower(), mapping[i + 1].strip(), mapping[i + 2].strip()))
else:
print('''
{\t/* %s, %s
\t%s
\t%s
},'''% (insn, ''.join(tmp[1:]).strip(), mapping[i + 1].strip(), mapping[i + 2].strip()))
return
print('''
{\t/* %s, %s_INS_%s: %s */
\t0,
\t{ 0 }
},'''% (insn, arch, mnem, mnem.lower()))
# extract from GenInstrInfo.inc, because the insn id is in order
enum_count = 0
meet_insn = False
f = open(sys.argv[2])
lines = f.readlines()
f.close()
count = 0
last_mnem = None
# 1st enum is register enum
for line in lines:
line = line.rstrip()
if len(line.strip()) == 0:
continue
if line.strip() == 'enum {':
enum_count += 1
#print(line.strip())
continue
line = line.strip()
if enum_count == 1:
if 'INSTRUCTION_LIST_END' in line:
break
else:
insn = None
if meet_insn:
# enum items
insn = line.split('=')[0].strip()
if 'CALLSTACK' in insn or 'TAILJUMP' in insn:
# pseudo instruction
insn = None
elif line.startswith(first_insn):
insn = line.split('=')[0].strip()
meet_insn = True
if insn:
count += 1
if insn == 'BSWAP16r_BAD':
last_mnem = 'BSWAP'
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn == 'CMOVNP_Fp32':
last_mnem = 'FCMOVNP'
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn == 'CMOVP_Fp3':
last_mnem = 'FCMOVP'
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn == 'CMPSDrm_Int':
last_mnem = 'CMPSD'
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn == 'MOVSX16rm16':
last_mnem = 'MOVSX'
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn == 'MOVZX16rm16':
last_mnem = 'MOVZX'
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn == 'ST_Fp32m':
last_mnem = 'FST'
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn == 'CMOVNP_Fp64':
last_mnem = 'FCMOVNU'
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn == 'CMPSDrr_Int':
last_mnem = 'CMPSD'
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn == 'CMPSSrm_Int':
last_mnem = 'CMPSS'
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn == 'VCMPSDrm_Int':
last_mnem = 'VCMPSD'
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn == 'VCMPSSrm_Int':
last_mnem = 'VCMPSS'
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn == 'VPCMOVYrrr_REV':
last_mnem = 'VPCMOV'
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn == 'VRNDSCALESDZm':
last_mnem = 'VRNDSCALESD'
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn == 'VRNDSCALESSZm':
last_mnem = 'VRNDSCALESS'
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn == 'VMAXCPDZ128rm':
last_mnem = 'VMAXPD'
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn == 'VMAXCPSZ128rm':
last_mnem = 'VMAXPS'
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn == 'VMAXCSDZrm':
last_mnem = 'VMAXSD'
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn == 'VMAXCSSZrm':
last_mnem = 'VMAXSS'
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn == 'VMINCPDZ128rm':
last_mnem = 'VMINPD'
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn == 'VMINCPSZ128rm':
last_mnem = 'VMINPS'
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn == 'VMINCSDZrm':
last_mnem = 'VMINSD'
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn == 'VMINCSSZrm':
last_mnem = 'VMINSS'
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn == 'VMOV64toPQIZrm':
last_mnem = 'VMOVQ'
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn == 'VPERMIL2PDYrr_REV':
last_mnem = 'VPERMILPD'
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn == 'VPERMIL2PSYrr_REV':
last_mnem = 'VPERMILPS'
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn == 'VCVTSD2SI64Zrm_Int':
last_mnem = 'VCVTSD2SI'
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn == 'VCVTSD2SSrm_Int':
last_mnem = 'VCVTSD2SS'
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn == 'VCVTSS2SI64Zrm_Int':
last_mnem = 'VCVTSS2SI'
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn == 'VCVTTSD2SI64Zrm_Int':
last_mnem = 'VCVTTSD2SI'
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn == 'VCVTTSS2SI64Zrm_Int':
last_mnem = 'VCVTTSS2SI'
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn.startswith('VFMSUBADD'):
if insn[len('VFMSUBADD')].isdigit():
last_mnem = insn[:len('VFMSUBADD123xy')]
else:
last_mnem = insn[:len('VFMSUBADDSS')]
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn.startswith('VFMADDSUB'):
if insn[len('VFMADDSUB')].isdigit():
last_mnem = insn[:len('VFMADDSUB123xy')]
else:
last_mnem = insn[:len('VFMADDSUBSS')]
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn.startswith('VFMADD'):
if insn[len('VFMADD')].isdigit():
last_mnem = insn[:len('VFMADD123PD')]
else:
last_mnem = insn[:len('VFMADDPD')]
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn.startswith('VFMSUB'):
if insn[len('VFMSUB')].isdigit():
last_mnem = insn[:len('VFMSUB123PD')]
else:
last_mnem = insn[:len('VFMSUBPD')]
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn.startswith('VFNMADD'):
if insn[len('VFNMADD')].isdigit():
last_mnem = insn[:len('VFNMADD123xy')]
else:
last_mnem = insn[:len('VFNMADDSS')]
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn.startswith('VFNMSUB'):
if insn[len('VFNMSUB')].isdigit():
last_mnem = insn[:len('VFNMSUB123xy')]
else:
last_mnem = insn[:len('VFNMSUBSS')]
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn in insn_id_list:
# trust old mapping table
last_mnem = insn_id_list[insn].upper()
print_entry(arch.upper(), insn, insn_id_list[insn].upper(), mapping, False)
else:
# the last option when we cannot find mnem: use the last good mnem
print_entry(arch.upper(), insn, last_mnem, mapping, True)
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/capstone/suite/synctools/mapping_insn_op.py
|
#!/usr/bin/python
# convert LLVM GenSystemRegister.inc for Capstone disassembler.
# by Nguyen Anh Quynh, 2019
import sys
if len(sys.argv) == 1:
print("Syntax: %s <GenSystemRegister.inc>" %sys.argv[0])
sys.exit(1)
f = open(sys.argv[1])
lines = f.readlines()
f.close()
#arch = sys.argv[2].upper()
print("""
/* Capstone Disassembly Engine, http://www.capstone-engine.org */
/* By Nguyen Anh Quynh <aquynh@gmail.com>, 2013-2019 */
/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
|* *|
|* GenSystemRegister Source Fragment *|
|* *|
|* Automatically generated file, do not edit! *|
|* *|
\*===----------------------------------------------------------------------===*/
""")
# extract BankedRegValues enum
count = 0
for line in lines:
line = line.rstrip()
if len(line.strip()) == 0:
continue
if line.strip() == 'enum BankedRegValues {':
count += 1
print(line.strip())
continue
line = line.strip()
if count == 1:
if line == '};':
# done with first enum
break
else:
# skip pseudo instructions
print("\t%s" %(line))
print('};\n')
# extract MClassSysRegsList
count = 0
for line in lines:
line = line.rstrip()
if len(line.strip()) == 0:
continue
if 'MClassSysRegsList[]' in line:
count += 1
print('static const MClassSysReg MClassSysRegsList[] = {')
continue
if count == 1:
if line.strip() == '};':
# done with first enum
break
else:
# enum items
# { "apsr_g", 0x400, 0x0, 0x400, {ARM::FeatureDSP} }, // 0
line2 = line.replace('::', '_')
sysreg = line2[line2.index('"') + 1 : line2.index('",')]
tmp = line2.split(',')
print("%s, ARM_SYSREG_%s%s" %(line2[:line2.index('",') + 1], sysreg.upper(), line2[line2.index('",') + 1 :]))
print('};\n')
# extract BankedRegsList
count = 0
for line in lines:
line = line.rstrip()
if len(line.strip()) == 0:
continue
if 'BankedRegsList[]' in line:
count += 1
print('static const BankedReg BankedRegsList[] = {')
continue
if count == 1:
if line.strip() == '};':
# done with first enum
break
else:
# enum items
line2 = line.replace('::', '_')
sysreg = line2[line2.index('"') + 1 : line2.index('",')]
tmp = line2.split(',')
print("%s, ARM_SYSREG_%s%s" %(line2[:line2.index('",') + 1], sysreg.upper(), line2[line2.index('",') + 1 :]))
print('};\n')
# lookupMClassSysRegByM2M3Encoding8
count = 0
for line in lines:
line = line.rstrip()
if len(line.strip()) == 0:
continue
if 'lookupMClassSysRegByM2M3Encoding8' in line and '{' in line:
count += 1
print('const MClassSysReg *lookupMClassSysRegByM2M3Encoding8(uint16_t encoding)\n{')
print(' unsigned int i;')
continue
if count == 1 and 'IndexType Index[] = {' in line:
count += 1
if count == 2:
if line.strip() == '};':
# done with array, or this function?
print(line)
break
else:
# enum items
print(line)
print("""
i = binsearch_IndexTypeEncoding(Index, ARR_SIZE(Index), encoding);
if (i == -1)
return NULL;
else
return &MClassSysRegsList[Index[i].index];
}
""")
# lookupMClassSysRegByM1Encoding12
count = 0
for line in lines:
line = line.rstrip()
if len(line.strip()) == 0:
continue
if 'lookupMClassSysRegByM1Encoding12' in line and '{' in line:
count += 1
print('const MClassSysReg *lookupMClassSysRegByM1Encoding12(uint16_t encoding)\n{')
print(' unsigned int i;')
continue
if count == 1 and 'IndexType Index[] = {' in line:
count += 1
if count == 2:
if line.strip() == '};':
# done with array, or this function?
print(line)
break
else:
# enum items
print(line)
print("""
i = binsearch_IndexTypeEncoding(Index, ARR_SIZE(Index), encoding);
if (i == -1)
return NULL;
else
return &MClassSysRegsList[Index[i].index];
}
""")
# lookupBankedRegByEncoding
count = 0
for line in lines:
line = line.rstrip()
if len(line.strip()) == 0:
continue
if 'lookupBankedRegByEncoding' in line and '{' in line:
count += 1
print('const BankedReg *lookupBankedRegByEncoding(uint8_t encoding)\n{')
print(' unsigned int i;')
continue
if count == 1 and 'IndexType Index[] = {' in line:
count += 1
if count == 2:
if line.strip() == '};':
# done with array, or this function?
print(line)
break
else:
# enum items
print(line)
print("""
i = binsearch_IndexTypeEncoding(Index, ARR_SIZE(Index), encoding);
if (i == -1)
return NULL;
else
return &BankedRegsList[Index[i].index];
}
""")
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/capstone/suite/synctools/systemregister.py
|
#!/usr/bin/python
# convert LLVM GenRegisterInfo.inc for Capstone disassembler.
# by Nguyen Anh Quynh, 2019
import sys
if len(sys.argv) == 1:
print("Syntax: %s <GenRegisterInfo.inc> <architecture>" %sys.argv[0])
sys.exit(1)
f = open(sys.argv[1])
lines = f.readlines()
f.close()
arch = sys.argv[2]
print("""
/* Capstone Disassembly Engine, http://www.capstone-engine.org */
/* By Nguyen Anh Quynh <aquynh@gmail.com>, 2013-2019 */
/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\\
|* *|
|* Target Register Enum Values *|
|* *|
|* Automatically generated file, do not edit! *|
|* *|
\*===----------------------------------------------------------------------===*/
#ifdef GET_REGINFO_ENUM
#undef GET_REGINFO_ENUM
""")
enum_count = 0
# 1st enum is register enum
for line in lines:
line = line.rstrip()
if len(line.strip()) == 0:
continue
if line.strip() == 'enum {':
enum_count += 1
print(line)
continue
if enum_count == 1:
if line.strip() == '};':
print(line)
# done with first enum
break
else:
# enum items
print(" %s_%s" %(arch, line.strip()))
# 2nd enum is register class
enum_count = 0
print("\n// Register classes")
for line in lines:
line = line.rstrip()
if len(line.strip()) == 0:
continue
if line.strip() == 'enum {':
enum_count += 1
if enum_count == 2:
print(line)
continue
if enum_count == 2:
if line.strip() == '};':
# done with 2nd enum
print(line.strip())
break
else:
# enum items
print(" %s_%s" %(arch, line.strip()))
if arch.upper() == 'ARM':
# 3rd enum is Subregister indices
enum_count = 0
print("\n// Subregister indices")
for line in lines:
line = line.rstrip()
if len(line.strip()) == 0:
continue
if line.strip() == 'enum {':
enum_count += 1
if enum_count == 3:
print(line)
continue
if enum_count == 3:
if line.strip() == '};':
# done with 2nd enum
print(line.strip())
break
else:
# enum items
print(" %s_%s" %(arch, line.strip()))
if arch.upper() == 'AARCH64':
# 3rd enum is Register alternate name indices
enum_count = 0
print("\n// Register alternate name indices")
for line in lines:
line = line.rstrip()
if len(line.strip()) == 0:
continue
if line.strip() == 'enum {':
enum_count += 1
if enum_count == 3:
print(line)
continue
if enum_count == 3:
if line.strip() == '};':
# done with 2nd enum
print(line.strip())
break
else:
# enum items
print(" %s_%s" %(arch, line.strip()))
# 4th enum is Subregister indices
enum_count = 0
print("\n// Subregister indices")
for line in lines:
line = line.rstrip()
if len(line.strip()) == 0:
continue
if line.strip() == 'enum {':
enum_count += 1
if enum_count == 4:
print(line)
continue
if enum_count == 4:
if line.strip() == '};':
# done with 2nd enum
print(line.strip())
break
else:
# enum items
print(" %s_%s" %(arch, line.strip()))
# end of enum
print("")
print("#endif // GET_REGINFO_ENUM")
print("""
#ifdef GET_REGINFO_MC_DESC
#undef GET_REGINFO_MC_DESC
""")
# extract RegDiffLists
finding_struct = True
for line in lines:
line = line.rstrip()
if len(line.strip()) == 0:
continue
if arch + 'RegDiffLists' in line:
finding_struct = False
print("static const MCPhysReg " + arch + "RegDiffLists[] = {")
continue
if finding_struct:
continue
else:
print(line)
if line == '};':
# done with this struct
print("")
break
# extract SubRegIdxLists
finding_struct = True
for line in lines:
line = line.rstrip()
if len(line.strip()) == 0:
continue
if arch + 'SubRegIdxLists' in line:
finding_struct = False
print("static const uint16_t " + arch + "SubRegIdxLists[] = {")
continue
if finding_struct:
continue
else:
print(line)
if line == '};':
# done with this struct
print("")
break
# extract RegDesc
finding_struct = True
for line in lines:
line = line.rstrip()
if len(line.strip()) == 0:
continue
if arch + 'RegDesc' in line:
finding_struct = False
print("static const MCRegisterDesc " + arch + "RegDesc[] = {")
continue
if finding_struct:
continue
else:
print(line)
if line == '};':
# done with this struct
print("")
break
# extract register classes
finding_struct = True
for line in lines:
line = line.rstrip()
if len(line.strip()) == 0:
continue
if 'Register classes' in line and 'namespace' in line:
finding_struct = False
continue
if finding_struct:
continue
else:
if 'const' in line:
line2 = line.replace('const', 'static const')
print(line2)
elif '::' in line:
line2 = line.replace('::', '_')
print(line2)
elif 'end anonymous namespace' in line:
# done with this struct
break
else:
print(line)
print("\n")
# extract MCRegisterClasses
finding_struct = True
for line in lines:
line = line.rstrip()
if len(line.strip()) == 0:
continue
if 'MCRegisterClass ' + arch + 'MCRegisterClasses[] = {' in line:
finding_struct = False
print("static const MCRegisterClass " + arch + "MCRegisterClasses[] = {")
continue
if finding_struct:
continue
else:
if line == '};':
# done with this struct
print('};\n')
break
elif '::' in line:
line = line.replace('::', '_')
# { GR8, GR8Bits, 130, 20, sizeof(GR8Bits), X86_GR8RegClassID, 1, 1, 1, 1 },
tmp = line.split(',')
print(" %s, %s, %s }," %(tmp[0].strip(), tmp[1].strip(), tmp[4].strip()))
print("#endif // GET_REGINFO_MC_DESC")
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/capstone/suite/synctools/registerinfo.py
|
#!/usr/bin/python
# convert LLVM GenSystemOperands.inc of AArch64 for Capstone disassembler.
# by Nguyen Anh Quynh, 2019
import sys
if len(sys.argv) == 1:
print("Syntax: %s <GenSystemOperands.inc> <GenSystemOperands.inc> <GenSystemOperands_enum.inc>" %sys.argv[0])
sys.exit(1)
f = open(sys.argv[1])
lines = f.readlines()
f.close()
f1 = open(sys.argv[2], 'w+')
f2 = open(sys.argv[3], 'w+')
f1.write("/* Capstone Disassembly Engine, http://www.capstone-engine.org */\n")
f1.write("/* By Nguyen Anh Quynh <aquynh@gmail.com>, 2013-2019 */\n")
f1.write("\n")
f2.write("/* Capstone Disassembly Engine, http://www.capstone-engine.org */\n")
f2.write("/* By Nguyen Anh Quynh <aquynh@gmail.com>, 2013-2019 */\n")
f2.write("\n")
# extract PStateValues enum
count = 0
for line in lines:
line = line.rstrip()
if len(line.strip()) == 0:
continue
if line.strip() == 'enum PStateValues {':
count += 1
f2.write(line.strip() + "\n")
continue
line = line.strip()
if count == 1:
if line == '};':
# done with first enum
f2.write(line + "\n")
f2.write("\n")
break
else:
# skip pseudo instructions
f2.write(" AArch64PState_%s\n" %(line))
def print_line(line):
f1.write(line + "\n")
# extract ExactFPImmValues enum
count = 0
for line in lines:
line = line.rstrip()
if len(line.strip()) == 0:
continue
if line.strip() == 'enum ExactFPImmValues {':
count += 1
f2.write(line.strip() + "\n")
continue
line = line.strip()
if count == 1:
if line == '};':
# done with first enum
f2.write(line + "\n")
f2.write("\n")
break
else:
# skip pseudo instructions
f2.write(" AArch64ExactFPImm_%s\n" %(line))
# extract ATsList[]
count = 0
c = 0
for line in lines:
line = line.rstrip()
if len(line.strip()) == 0:
continue
if line.strip() == 'const AT ATsList[] = {':
count += 1
print_line('static const AT ATsList[] = {')
continue
line = line.strip()
if count == 1:
if line == '};':
# done with first enum
print_line('};\n')
break
else:
# skip pseudo instructions
line = line.replace('::', '_')
#line = line.replace('{}', '{ 0 }')
line = line.replace('{}', '')
tmp = line.split(',')
print_line(" %s, %s }, // %u" %(tmp[0].lower(), tmp[1], c))
c += 1
# lookupATByEncoding
count = 0
for line in lines:
line = line.rstrip()
if len(line.strip()) == 0:
continue
if 'lookupATByEncoding' in line and '{' in line:
count += 1
print_line('const AT *lookupATByEncoding(uint16_t Encoding)\n{')
print_line(' unsigned int i;')
continue
if count == 1 and 'IndexType Index[] = {' in line:
count += 1
if count == 2:
if line.strip() == '};':
# done with array, or this function?
print_line(line)
break
else:
# enum items
print_line(line)
print_line("""
i = binsearch_IndexTypeEncoding(Index, ARR_SIZE(Index), Encoding);
if (i == -1)
return NULL;
else
return &ATsList[Index[i].index];
}
""")
# extract DBsList[]
count = 0
for line in lines:
line = line.rstrip()
if len(line.strip()) == 0:
continue
if line.strip() == 'const DB DBsList[] = {':
count += 1
print_line('static const DB DBsList[] = {')
continue
line = line.strip()
if count == 1:
if line == '};':
# done with first enum
print_line('};\n')
break
else:
# skip pseudo instructions
line = line.replace('::', '_')
#line = line.replace('{}', '{ 0 }')
line = line.replace('{}', '')
print_line(" %s" %(line))
# lookupDBByEncoding
count = 0
for line in lines:
line = line.rstrip()
if len(line.strip()) == 0:
continue
if 'lookupDBByEncoding' in line and '{' in line:
count += 1
print_line('const DB *lookupDBByEncoding(uint16_t Encoding)\n{')
print_line(' unsigned int i;')
continue
if count == 1 and 'IndexType Index[] = {' in line:
count += 1
if count == 2:
if line.strip() == '};':
# done with array, or this function?
print_line(line)
break
else:
# enum items
print_line(line)
print_line("""
i = binsearch_IndexTypeEncoding(Index, ARR_SIZE(Index), Encoding);
if (i == -1)
return NULL;
else
return &DBsList[Index[i].index];
}
""")
# extract DCsList[]
count = 0
c = 0
for line in lines:
line = line.rstrip()
if len(line.strip()) == 0:
continue
if line.strip() == 'const DC DCsList[] = {':
count += 1
print_line('static const DC DCsList[] = {')
continue
line = line.strip()
if count == 1:
if line == '};':
# done with first enum
print_line('};\n')
break
else:
# skip pseudo instructions
line = line.replace('::', '_')
#line = line.replace('{}', '{ 0 }')
line = line.replace('{}', '')
tmp = line.split(',')
print_line(" %s, %s }, // %u" %(tmp[0].lower(), tmp[1], c))
c += 1
# lookupDCByEncoding
count = 0
for line in lines:
line = line.rstrip()
if len(line.strip()) == 0:
continue
if 'lookupDCByEncoding' in line and '{' in line:
count += 1
print_line('const DC *lookupDCByEncoding(uint16_t Encoding)\n{')
print_line(' unsigned int i;')
continue
if count == 1 and 'IndexType Index[] = {' in line:
count += 1
if count == 2:
if line.strip() == '};':
# done with array, or this function?
print_line(line)
break
else:
# enum items
print_line(line)
print_line("""
i = binsearch_IndexTypeEncoding(Index, ARR_SIZE(Index), Encoding);
if (i == -1)
return NULL;
else
return &DCsList[Index[i].index];
}
""")
# extract ICsList
count = 0
c = 0
for line in lines:
line = line.rstrip()
if len(line.strip()) == 0:
continue
if line.strip() == 'const IC ICsList[] = {':
count += 1
print_line('static const IC ICsList[] = {')
continue
line = line.strip()
if count == 1:
if line == '};':
# done with first enum
print_line('};\n')
break
else:
# skip pseudo instructions
line = line.replace('::', '_')
#line = line.replace('{}', '{ 0 }')
line = line.replace('{}', '')
#tmp = line.split(',')
#print_line(" %s, %s }, // %u" %(tmp[0].lower(), tmp[1], c))
print_line(" %s" %line.lower())
c += 1
# lookupICByEncoding
count = 0
for line in lines:
line = line.rstrip()
if len(line.strip()) == 0:
continue
if 'lookupICByEncoding' in line and '{' in line:
count += 1
print_line('const IC *lookupICByEncoding(uint16_t Encoding)\n{')
print_line(' unsigned int i;')
continue
if count == 1 and 'IndexType Index[] = {' in line:
count += 1
if count == 2:
if line.strip() == '};':
# done with array, or this function?
print_line(line)
break
else:
# enum items
print_line(line)
print_line("""
i = binsearch_IndexTypeEncoding(Index, ARR_SIZE(Index), Encoding);
if (i == -1)
return NULL;
else
return &ICsList[Index[i].index];
}
""")
# extract TLBIsList
count = 0
c = 0
for line in lines:
line = line.rstrip()
if len(line.strip()) == 0:
continue
if line.strip() == 'const TLBI TLBIsList[] = {':
count += 1
print_line('static const TLBI TLBIsList[] = {')
continue
line = line.strip()
if count == 1:
if line == '};':
# done with first enum
print_line('};\n')
break
else:
# skip pseudo instructions
line = line.replace('::', '_')
#line = line.replace('{}', '{ 0 }')
line = line.replace('{}', '')
tmp = line.split(',')
print_line(" %s, %s, %s }, // %u" %(tmp[0].lower(), tmp[1], tmp[2], c))
#print_line(" %s" %line.lower())
c += 1
# lookupTLBIByEncoding
count = 0
for line in lines:
line = line.rstrip()
if len(line.strip()) == 0:
continue
if 'lookupTLBIByEncoding' in line and '{' in line:
count += 1
print_line('const TLBI *lookupTLBIByEncoding(uint16_t Encoding)\n{')
print_line(' unsigned int i;')
continue
if count == 1 and 'IndexType Index[] = {' in line:
count += 1
if count == 2:
if line.strip() == '};':
# done with array, or this function?
print_line(line)
break
else:
# enum items
print_line(line)
print_line("""
i = binsearch_IndexTypeEncoding(Index, ARR_SIZE(Index), Encoding);
if (i == -1)
return NULL;
else
return &TLBIsList[Index[i].index];
}
""")
# extract SVEPRFMsList
count = 0
c = 0
for line in lines:
line = line.rstrip()
if len(line.strip()) == 0:
continue
if line.strip() == 'const SVEPRFM SVEPRFMsList[] = {':
count += 1
print_line('static const SVEPRFM SVEPRFMsList[] = {')
continue
line = line.strip()
if count == 1:
if line == '};':
# done with first enum
print_line('};\n')
break
else:
# skip pseudo instructions
line = line.replace('::', '_')
#line = line.replace('{}', '{ 0 }')
line = line.replace('{}', '')
tmp = line.split(',')
print_line(" %s, %s }, // %u" %(tmp[0].lower(), tmp[1], c))
#print_line(" %s" %line.lower())
c += 1
# lookupSVEPRFMByEncoding
count = 0
for line in lines:
line = line.rstrip()
if len(line.strip()) == 0:
continue
if 'lookupSVEPRFMByEncoding' in line and '{' in line:
count += 1
print_line('const SVEPRFM *lookupSVEPRFMByEncoding(uint16_t Encoding)\n{')
print_line(' unsigned int i;')
continue
if count == 1 and 'IndexType Index[] = {' in line:
count += 1
if count == 2:
if line.strip() == '};':
# done with array, or this function?
print_line(line)
break
else:
# enum items
print_line(line)
print_line("""
i = binsearch_IndexTypeEncoding(Index, ARR_SIZE(Index), Encoding);
if (i == -1)
return NULL;
else
return &SVEPRFMsList[Index[i].index];
}
""")
# extract PRFMsList
count = 0
c = 0
for line in lines:
line = line.rstrip()
if len(line.strip()) == 0:
continue
if line.strip() == 'const PRFM PRFMsList[] = {':
count += 1
print_line('static const PRFM PRFMsList[] = {')
continue
line = line.strip()
if count == 1:
if line == '};':
# done with first enum
print_line('};\n')
break
else:
# skip pseudo instructions
line = line.replace('::', '_')
#line = line.replace('{}', '{ 0 }')
line = line.replace('{}', '')
#tmp = line.split(',')
#print_line(" %s, %s }, // %u" %(tmp[0].lower(), tmp[1], c))
print_line(" %s" %line.lower())
c += 1
# lookupPRFMByEncoding
count = 0
for line in lines:
line = line.rstrip()
if len(line.strip()) == 0:
continue
if 'lookupPRFMByEncoding' in line and '{' in line:
count += 1
print_line('const PRFM *lookupPRFMByEncoding(uint16_t Encoding)\n{')
print_line(' unsigned int i;')
continue
if count == 1 and 'IndexType Index[] = {' in line:
count += 1
if count == 2:
if line.strip() == '};':
# done with array, or this function?
print_line(line)
break
else:
# enum items
print_line(line)
print_line("""
i = binsearch_IndexTypeEncoding(Index, ARR_SIZE(Index), Encoding);
if (i == -1)
return NULL;
else
return &PRFMsList[Index[i].index];
}
""")
# extract PSBsList
count = 0
c = 0
for line in lines:
line = line.rstrip()
if len(line.strip()) == 0:
continue
if line.strip() == 'const PSB PSBsList[] = {':
count += 1
print_line('static const PSB PSBsList[] = {')
continue
line = line.strip()
if count == 1:
if line == '};':
# done with first enum
print_line('};\n')
break
else:
# skip pseudo instructions
line = line.replace('::', '_')
#line = line.replace('{}', '{ 0 }')
line = line.replace('{}', '')
#tmp = line.split(',')
#print_line(" %s, %s }, // %u" %(tmp[0].lower(), tmp[1], c))
print_line(" %s" %line.lower())
c += 1
# lookupPSBByEncoding
count = 0
for line in lines:
line = line.rstrip()
if len(line.strip()) == 0:
continue
if 'lookupPSBByEncoding' in line and '{' in line:
count += 1
print_line('const PSB *AArch64PSBHint_lookupPSBByEncoding(uint16_t Encoding)\n{')
print_line(' unsigned int i;')
continue
if count == 1 and 'IndexType Index[] = {' in line:
count += 1
if count == 2:
if line.strip() == '};':
# done with array, or this function?
print_line(line)
break
else:
# enum items
print_line(line)
print_line("""
i = binsearch_IndexTypeEncoding(Index, ARR_SIZE(Index), Encoding);
if (i == -1)
return NULL;
else
return &PSBsList[Index[i].index];
}
""")
# extract ISBsList
count = 0
c = 0
for line in lines:
line = line.rstrip()
if len(line.strip()) == 0:
continue
if line.strip() == 'const ISB ISBsList[] = {':
count += 1
print_line('static const ISB ISBsList[] = {')
continue
line = line.strip()
if count == 1:
if line == '};':
# done with first enum
print_line('};\n')
break
else:
# skip pseudo instructions
line = line.replace('::', '_')
#line = line.replace('{}', '{ 0 }')
line = line.replace('{}', '')
#tmp = line.split(',')
#print_line(" %s, %s }, // %u" %(tmp[0].lower(), tmp[1], c))
print_line(" %s" %line.lower())
c += 1
# lookupISBByName
count = 0
for line in lines:
line = line.rstrip()
if len(line.strip()) == 0:
continue
if 'lookupISBByEncoding' in line and '{' in line:
count += 1
print_line('const ISB *lookupISBByEncoding(uint16_t Encoding)\n{')
print_line(' unsigned int i;')
continue
if count == 1 and 'IndexType Index[] = {' in line:
count += 1
if count == 2:
if line.strip() == '};':
# done with array, or this function?
print_line(line)
break
else:
# enum items
print_line(line)
print_line("""
i = binsearch_IndexTypeEncoding(Index, ARR_SIZE(Index), Encoding);
if (i == -1)
return NULL;
else
return &ISBsList[Index[i].index];
}
""")
# extract TSBsList
count = 0
c = 0
for line in lines:
line = line.rstrip()
if len(line.strip()) == 0:
continue
if line.strip() == 'const TSB TSBsList[] = {':
count += 1
print_line('static const TSB TSBsList[] = {')
continue
line = line.strip()
if count == 1:
if line == '};':
# done with first enum
print_line('};\n')
break
else:
# skip pseudo instructions
line = line.replace('::', '_')
#line = line.replace('{}', '{ 0 }')
line = line.replace('{}', '')
tmp = line.split(',')
print_line(" %s, %s }, // %u" %(tmp[0].lower(), tmp[1], c))
#print_line(" %s" %line.lower())
c += 1
# lookupTSBByEncoding
count = 0
for line in lines:
line = line.rstrip()
if len(line.strip()) == 0:
continue
if 'lookupTSBByEncoding' in line and '{' in line:
count += 1
print_line('const TSB *lookupTSBByEncoding(uint16_t Encoding)\n{')
continue
if count == 1 and 'IndexType Index[] = {' in line:
count += 1
if count == 2:
if line.strip() == '};':
# done with array, or this function?
print_line(line)
break
else:
# enum items
print_line(line)
print_line("""
if (Encoding >= ARR_SIZE(TSBsList))
return NULL;
else
return &TSBsList[Index[Encoding].index];
}
""")
# extract SysRegsList
count = 0
c = 0
for line in lines:
line = line.rstrip()
if len(line.strip()) == 0:
continue
if line.strip() == 'const SysReg SysRegsList[] = {':
count += 1
print_line('static const SysReg SysRegsList[] = {')
continue
line = line.strip()
if count == 1:
if line == '};':
# done with first enum
print_line('};\n')
break
else:
# skip pseudo instructions
line = line.replace('::', '_')
#line = line.replace('{}', '{ 0 }')
line = line.replace('{}', '')
tmp = line.split(',')
print_line(" %s, %s, %s, %s }, // %u" %(tmp[0].lower(), tmp[1], tmp[2], tmp[3], c))
#print_line(" %s" %line.lower())
c += 1
# lookupSysRegByEncoding
count = 0
for line in lines:
line = line.rstrip()
if len(line.strip()) == 0:
continue
if 'lookupSysRegByEncoding' in line and '{' in line:
count += 1
print_line('const SysReg *lookupSysRegByEncoding(uint16_t Encoding)\n{')
print_line(' unsigned int i;')
continue
if count == 1 and 'IndexType Index[] = {' in line:
count += 1
if count == 2:
if line.strip() == '};':
# done with array, or this function?
print_line(line)
break
else:
# enum items
print_line(line)
print_line("""
i = binsearch_IndexTypeEncoding(Index, ARR_SIZE(Index), Encoding);
if (i == -1)
return NULL;
else
return &SysRegsList[Index[i].index];
}
""")
# extract PStatesList
count = 0
c = 0
for line in lines:
line = line.rstrip()
if len(line.strip()) == 0:
continue
if line.strip() == 'const PState PStatesList[] = {':
count += 1
print_line('static const PState PStatesList[] = {')
continue
line = line.strip()
if count == 1:
if line == '};':
# done with first enum
print_line('};\n')
break
else:
# skip pseudo instructions
line = line.replace('::', '_')
#line = line.replace('{}', '{ 0 }')
line = line.replace('{}', '')
tmp = line.split(',')
print_line(" %s, %s }, // %u" %(tmp[0].lower(), tmp[1], c))
#print_line(" %s" %line.lower())
c += 1
# lookupPStateByEncoding
count = 0
for line in lines:
line = line.rstrip()
if len(line.strip()) == 0:
continue
if 'lookupPStateByEncoding' in line and '{' in line:
count += 1
print_line('const PState *lookupPStateByEncoding(uint16_t Encoding)\n{')
print_line(' unsigned int i;')
continue
if count == 1 and 'IndexType Index[] = {' in line:
count += 1
if count == 2:
if line.strip() == '};':
# done with array, or this function?
print_line(line)
break
else:
# enum items
print_line(line)
print_line("""
i = binsearch_IndexTypeEncoding(Index, ARR_SIZE(Index), Encoding);
if (i == -1)
return NULL;
else
return &PStatesList[Index[i].index];
}
""")
# extract SVEPREDPATsList
count = 0
c = 0
for line in lines:
line = line.rstrip()
if len(line.strip()) == 0:
continue
if line.strip() == 'const SVEPREDPAT SVEPREDPATsList[] = {':
count += 1
print_line('static const SVEPREDPAT SVEPREDPATsList[] = {')
continue
line = line.strip()
if count == 1:
if line == '};':
# done with first enum
print_line('};\n')
break
else:
# skip pseudo instructions
line = line.replace('::', '_')
#line = line.replace('{}', '{ 0 }')
line = line.replace('{}', '')
tmp = line.split(',')
#print_line(" %s, %s }, // %u" %(tmp[0].lower(), tmp[1], c))
print_line(" %s" %line.lower())
c += 1
# lookupSVEPREDPATByEncoding
count = 0
for line in lines:
line = line.rstrip()
if len(line.strip()) == 0:
continue
if 'lookupSVEPREDPATByEncoding' in line and '{' in line:
count += 1
print_line('const SVEPREDPAT *lookupSVEPREDPATByEncoding(uint16_t Encoding)\n{')
print_line(' unsigned int i;')
continue
if count == 1 and 'IndexType Index[] = {' in line:
count += 1
if count == 2:
if line.strip() == '};':
# done with array, or this function?
print_line(line)
break
else:
# enum items
print_line(line)
print_line("""
i = binsearch_IndexTypeEncoding(Index, ARR_SIZE(Index), Encoding);
if (i == -1)
return NULL;
else
return &SVEPREDPATsList[Index[i].index];
}
""")
# extract ExactFPImmsList
count = 0
c = 0
for line in lines:
line = line.rstrip()
if len(line.strip()) == 0:
continue
if line.strip() == 'const ExactFPImm ExactFPImmsList[] = {':
count += 1
print_line('static const ExactFPImm ExactFPImmsList[] = {')
continue
line = line.strip()
if count == 1:
if line == '};':
# done with first enum
print_line('};\n')
break
else:
# skip pseudo instructions
line = line.replace('::', '_')
#line = line.replace('{}', '{ 0 }')
line = line.replace('{}', '')
tmp = line.split(',')
#print_line(" %s, %s }, // %u" %(tmp[0].lower(), tmp[1], c))
print_line(" %s" %line.lower())
c += 1
# lookupExactFPImmByEnum
count = 0
for line in lines:
line = line.rstrip()
if len(line.strip()) == 0:
continue
if 'lookupExactFPImmByEnum' in line and '{' in line:
count += 1
print_line('const ExactFPImm *lookupExactFPImmByEnum(uint16_t Encoding)\n{')
continue
if count == 1 and 'IndexType Index[] = {' in line:
count += 1
if count == 2:
if line.strip() == '};':
# done with array, or this function?
print_line(line)
break
else:
# enum items
print_line(line)
print_line("""
if (Encoding >= ARR_SIZE(ExactFPImmsList))
return NULL;
else
return &ExactFPImmsList[Index[Encoding].index];
}
""")
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/capstone/suite/synctools/systemoperand.py
|
#!/usr/bin/python
# print out all registers from LLVM GenRegisterInfo.inc for Capstone disassembler.
# NOTE: the list then must be filtered, manually.
# by Nguyen Anh Quynh, 2019
import sys
if len(sys.argv) == 1:
print("Syntax: %s <GenRegisterInfo.inc> <architecture>" %sys.argv[0])
sys.exit(1)
f = open(sys.argv[1])
lines = f.readlines()
f.close()
arch = sys.argv[2].upper()
enum_count = 0
print("""/* Capstone Disassembly Engine, http://www.capstone-engine.org */
/* This is auto-gen data for Capstone disassembly engine (www.capstone-engine.org) */
/* By Nguyen Anh Quynh <aquynh@gmail.com>, 2013-2019 */
""")
# 1st enum is register enum
for line in lines:
line = line.rstrip()
if len(line.strip()) == 0:
continue
if line.strip() == 'enum {':
enum_count += 1
continue
if enum_count == 1:
if line == '};':
# done with first enum
break
else:
# enum items
if 'NoRegister' in line or 'TARGET_REGS' in line:
continue
reg = line.strip().split('=')[0].strip()
if reg.startswith('H') or reg.endswith('PH') or reg.endswith('IH') or reg.endswith('WH'):
print("{ %s_%s, 0 }," %(arch, reg))
elif 'K' in reg or 'BND' in reg:
print("{ %s_%s, 0 }," %(arch, reg))
elif reg in ('DF', 'SSP', 'R8BH', 'R9BH', 'R10BH', 'R11BH', 'R12BH', 'R13BH', 'R14BH', 'R15BH'):
print("{ %s_%s, 0 }," %(arch, reg))
else:
print("{ %s_%s, %s_REG_%s }," %(arch, reg, arch, reg))
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/capstone/suite/synctools/mapping_reg.py
|
#!/usr/bin/python
# print out all registers from LLVM GenRegisterInfo.inc for Capstone disassembler.
# NOTE: the list then must be filtered, manually.
# by Nguyen Anh Quynh, 2019
import sys
if len(sys.argv) == 1:
print("Syntax: %s <GenRegisterInfo.inc> <architecture>" %sys.argv[0])
sys.exit(1)
f = open(sys.argv[1])
lines = f.readlines()
f.close()
arch = sys.argv[2].upper()
enum_count = 0
# 1st enum is register enum
for line in lines:
line = line.rstrip()
if len(line.strip()) == 0:
continue
if line.strip() == 'enum {':
enum_count += 1
continue
if enum_count == 1:
if line == '};':
# done with first enum
break
else:
# enum items
if 'NoRegister' in line or 'TARGET_REGS' in line:
continue
reg = line.strip().split('=')[0].strip()
if reg.startswith('H') or reg.endswith('PH') or or reg.endswith('IH') or or reg.endswith('WH'):
print(" %s_REG_%s = REMOVE," %(arch, reg))
elif 'K' in reg or 'BND' in reg:
print(" %s_REG_%s = REMOVE," %(arch, reg))
elif reg in ('DF', 'SSP', 'R8BH', 'R9BH', 'R10BH', 'R11BH', 'R12BH', 'R13BH', 'R14BH', 'R15BH'):
print(" %s_REG_%s = REMOVE," %(arch, reg))
else:
print(" %s_REG_%s," %(arch, reg))
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/capstone/suite/synctools/register.py
|
#!/usr/bin/python
# print list of instructions LLVM inc files, for Capstone disassembler.
# this will be put into capstone/<arch>.h
# by Nguyen Anh Quynh, 2019
import sys
if len(sys.argv) == 1:
print("Syntax: %s <GenAsmMatcher.inc>" %sys.argv[0])
sys.exit(1)
print("""/* Capstone Disassembly Engine, http://www.capstone-engine.org */
/* This is auto-gen data for Capstone disassembly engine (www.capstone-engine.org) */
/* By Nguyen Anh Quynh <aquynh@gmail.com>, 2013-2019 */
""")
# lib/Target/X86/X86GenAsmMatcher.inc
# static const MatchEntry MatchTable1[] = {
# { 0 /* aaa */, X86::AAA, Convert_NoOperands, Feature_Not64BitMode, { }, },
# extract insn from GenAsmMatcher Table
# return (arch, mnem, insn_id)
def extract_insn(line):
tmp = line.split(',')
insn_raw = tmp[1].strip()
insn_mnem = tmp[0].split(' ')[3]
# X86 mov.s
if '.' in insn_mnem:
tmp = insn_mnem.split('.')
insn_mnem = tmp[0]
tmp = insn_raw.split('::')
arch = tmp[0]
# AArch64 -> ARM64
if arch.upper() == 'AARCH64':
arch = 'ARM64'
return (arch, insn_mnem, tmp[1])
# extract all insn lines from GenAsmMatcher
# return arch, first_insn, insn_id_list
def extract_matcher(filename):
f = open(filename)
lines = f.readlines()
f.close()
match_count = 0
mnem_list = []
insn_id_list = {}
arch = None
first_insn = None
pattern = None
# first we try to find Table1, or Table0
for line in lines:
if 'MatchEntry MatchTable0[] = {' in line.strip():
pattern = 'MatchEntry MatchTable0[] = {'
elif 'MatchEntry MatchTable1[] = {' in line.strip():
pattern = 'MatchEntry MatchTable1[] = {'
# last pattern, done
break
# 1st enum is register enum
for line in lines:
line = line.rstrip()
if len(line.strip()) == 0:
continue
if pattern in line.strip():
match_count += 1
#print(line.strip())
continue
line = line.strip()
if match_count == 1:
if line == '};':
# done with first enum
break
else:
_arch, mnem, insn_id = extract_insn(line)
# skip pseudo instructions
if not mnem.startswith('__'):
# PPC
if mnem.endswith('-') or mnem.endswith('+'):
mnem = mnem[:-1]
if not first_insn:
arch, first_insn = _arch, insn_id
if not insn_id in insn_id_list:
# save this
insn_id_list[insn_id] = mnem
if not mnem in mnem_list:
print("%s_INS_%s," %(arch, mnem.upper()))
mnem_list.append(mnem)
#return arch, first_insn, insn_id_list
return arch, first_insn, insn_id_list
# GenAsmMatcher.inc
#arch, first_insn, insn_id_list, match_lines = extract_matcher(sys.argv[1])
arch, first_insn, insn_id_list = extract_matcher(sys.argv[1])
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/capstone/suite/synctools/insn3.py
|
#!/usr/bin/python
# compare instructions in 2 files of MappingInsn.inc
# find instructions in MappingInsn1, that does not exist in MappingInsn2
# by Nguyen Anh Quynh, 2019
import sys
if len(sys.argv) == 1:
print("Syntax: %s <MappingInsn1.inc> <MappingInsn2.inc>" %sys.argv[0])
sys.exit(1)
f = open(sys.argv[1])
mapping1 = f.readlines()
f.close()
f = open(sys.argv[2])
mapping2 = f.readlines()
f.close()
insn1 = []
for line in mapping1:
if 'X86_INS_' in line:
tmp = line.split(',')
insn_id = tmp[0].strip()
insn1.append(insn_id)
insn2 = []
for line in mapping2:
if 'X86_INS_' in line:
tmp = line.split(',')
insn_id = tmp[0].strip()
insn2.append(insn_id)
for insn_id in insn1:
if not insn_id in insn2:
print("instruction %s is not in list 2" %insn_id)
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/capstone/suite/synctools/compare_mapping_insn.py
|
#!/usr/bin/python
# check MappingInsn.inc to find potential incorrect mapping - for Capstone disassembler.
# by Nguyen Anh Quynh, 2019
import sys
if len(sys.argv) == 1:
print("Syntax: %s <MappingInsn.inc>" %sys.argv[0])
sys.exit(1)
# ARM_CMPri, ARM_INS_CMN,
f = open(sys.argv[1])
lines = f.readlines()
f.close()
for line in lines:
if '_INS_' in line:
tmp = line.strip().split(',')
if len(tmp) == 3 and tmp[2] == '':
id_private = tmp[0].strip()
id_public = tmp[1].strip()
pos = id_public.find('_INS_')
mnem = id_public[pos + len('_INS_'):]
if not mnem in id_private:
print("%s -> %s" %(id_private, id_public))
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/capstone/suite/synctools/insn_check.py
|
#!/usr/bin/python
# print list of instructions LLVM inc files, for Capstone disassembler.
# this will be put into capstone/<arch>.h
# by Nguyen Anh Quynh, 2019
import sys
if len(sys.argv) == 1:
print("Syntax: %s <GenAsmMatcher.inc>" %sys.argv[0])
sys.exit(1)
print("""/* Capstone Disassembly Engine, http://www.capstone-engine.org */
/* This is auto-gen data for Capstone disassembly engine (www.capstone-engine.org) */
/* By Nguyen Anh Quynh <aquynh@gmail.com>, 2013-2019 */
""")
# lib/Target/X86/X86GenAsmMatcher.inc
# static const MatchEntry MatchTable1[] = {
# { 0 /* aaa */, X86::AAA, Convert_NoOperands, Feature_Not64BitMode, { }, },
# extract insn from GenAsmMatcher Table
# return (arch, mnem, insn_id)
def extract_insn(line):
tmp = line.split(',')
insn_raw = tmp[1].strip()
insn_mnem = tmp[0].split(' ')[3]
# X86 mov.s
if '.' in insn_mnem:
tmp = insn_mnem.split('.')
insn_mnem = tmp[0]
tmp = insn_raw.split('::')
arch = tmp[0]
# AArch64 -> ARM64
if arch.upper() == 'AARCH64':
arch = 'ARM64'
return (arch, insn_mnem, tmp[1])
# extract all insn lines from GenAsmMatcher
# return arch, first_insn, insn_id_list
def extract_matcher(filename):
f = open(filename)
lines = f.readlines()
f.close()
match_count = 0
mnem_list = []
insn_id_list = {}
arch = None
first_insn = None
pattern = None
# first we try to find Table1, or Table0
for line in lines:
if 'MatchEntry MatchTable0[] = {' in line.strip():
pattern = 'MatchEntry MatchTable0[] = {'
elif 'MatchEntry MatchTable1[] = {' in line.strip():
pattern = 'MatchEntry MatchTable1[] = {'
# last pattern, done
break
# 1st enum is register enum
for line in lines:
line = line.rstrip()
if len(line.strip()) == 0:
continue
if pattern in line.strip():
match_count += 1
#print(line.strip())
continue
line = line.strip()
if match_count == 1:
if line == '};':
# done with first enum
break
else:
_arch, mnem, insn_id = extract_insn(line)
# skip pseudo instructions
if not mnem.startswith('__'):
# PPC
if mnem.endswith('-') or mnem.endswith('+'):
mnem = mnem[:-1]
if not first_insn:
arch, first_insn = _arch, insn_id
if not insn_id in insn_id_list:
# save this
insn_id_list[insn_id] = mnem
if not mnem in mnem_list:
print('\t"%s", // %s_INS_%s,' %(mnem.lower(), arch, mnem.upper()))
mnem_list.append(mnem)
#return arch, first_insn, insn_id_list
return arch, first_insn, insn_id_list
# GenAsmMatcher.inc
#arch, first_insn, insn_id_list, match_lines = extract_matcher(sys.argv[1])
arch, first_insn, insn_id_list = extract_matcher(sys.argv[1])
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/capstone/suite/synctools/mapping_insn_name-arch.py
|
#!/usr/bin/python
# print MappingInsn.inc file from LLVM GenAsmMatcher.inc, for Capstone disassembler.
# by Nguyen Anh Quynh, 2019
import sys
if len(sys.argv) == 1:
print("Syntax: %s <GenAsmMatcher.inc> <GenInstrInfo.inc> MappingInsn.inc" %sys.argv[0])
sys.exit(1)
f = open(sys.argv[3])
mapping = f.readlines()
f.close()
print("""/* Capstone Disassembly Engine, http://www.capstone-engine.org */
/* This is auto-gen data for Capstone disassembly engine (www.capstone-engine.org) */
/* By Nguyen Anh Quynh <aquynh@gmail.com>, 2013-2019 */
""")
# lib/Target/X86/X86GenAsmMatcher.inc
# static const MatchEntry MatchTable1[] = {
# { 0 /* aaa */, X86::AAA, Convert_NoOperands, Feature_Not64BitMode, { }, },
# extract insn from GenAsmMatcher Table
# return (arch, mnem, insn_id)
def extract_insn(line):
tmp = line.split(',')
insn_raw = tmp[1].strip()
insn_mnem = tmp[0].split(' ')[3]
# X86 mov.s
if '.' in insn_mnem:
tmp = insn_mnem.split('.')
insn_mnem = tmp[0]
tmp = insn_raw.split('::')
arch = tmp[0]
# AArch64 -> ARM64
#if arch.upper() == 'AARCH64':
# arch = 'ARM64'
return (arch, insn_mnem, tmp[1])
# extract all insn lines from GenAsmMatcher
# return arch, first_insn, insn_id_list
def extract_matcher(filename):
f = open(filename)
lines = f.readlines()
f.close()
match_count = 0
insn_id_list = {}
arch = None
first_insn = None
pattern = None
# first we try to find Table1, or Table0
for line in lines:
if 'MatchEntry MatchTable0[] = {' in line.strip():
pattern = 'MatchEntry MatchTable0[] = {'
elif 'AArch64::' in line and pattern:
# We do not care about Apple Assembly
break
elif 'MatchEntry MatchTable1[] = {' in line.strip():
pattern = 'MatchEntry MatchTable1[] = {'
# last pattern, done
break
for line in lines:
line = line.rstrip()
# skip empty line
if len(line.strip()) == 0:
continue
if pattern in line.strip():
match_count += 1
#print(line.strip())
continue
line = line.strip()
if match_count == 1:
if line == '};':
# done with first enum
break
else:
_arch, mnem, insn_id = extract_insn(line)
# skip pseudo instructions
if not mnem.startswith('__'):
# PPC
if mnem.endswith('-') or mnem.endswith('+'):
mnem = mnem[:-1]
if not first_insn:
arch, first_insn = _arch, insn_id
if not insn_id in insn_id_list:
# save this
insn_id_list[insn_id] = mnem
#return arch, first_insn, insn_id_list
return arch, first_insn, insn_id_list
#arch, first_insn, insn_id_list, match_lines = extract_matcher(sys.argv[1])
arch, first_insn, insn_id_list = extract_matcher(sys.argv[1])
#arch = arch.upper()
#print("first insn = %s" %first_insn)
#for line in insn_id_list:
# print(line)
#{
# X86_AAA, X86_INS_AAA,
##ifndef CAPSTONE_DIET
# { 0 }, { 0 }, { X86_GRP_NOT64BITMODE, 0 }, 0, 0
##endif
#},
def print_entry(arch, insn_id, mnem, mapping, mnem_can_be_wrong):
#insn = "%s_%s" %(arch.upper(), insn_id)
insn = "%s_%s" %(arch, insn_id)
arch1 = arch
if arch.upper() == 'AARCH64':
arch1 = 'ARM64'
#if '64' in insn_id:
# is64bit = '1'
#else:
# is64bit = '0'
# first, try to find this entry in old MappingInsn.inc file
for i in range(len(mapping)):
tmp = mapping[i].split(',')
if tmp[0].strip() == insn:
if not mnem_can_be_wrong:
print('''
{
\t%s, %s_INS_%s,
#ifndef CAPSTONE_DIET
\t%s
#endif
},'''% (insn, arch1, mnem, mapping[i + 2].strip()))
else: # ATTENTION: mnem can be wrong
if not tmp[1].endswith(mnem):
#print("======== cannot find %s, mapping to %s (instead of %s)" %(insn, tmp[1].strip(), mnem))
pass
print('''
{
\t%s, %s,
#ifndef CAPSTONE_DIET
\t%s
#endif
},'''% (insn, tmp[1].strip(), mapping[i + 2].strip()))
return
if mnem_can_be_wrong:
#print("======== CANNOT FIND %s, mapping to %s" %(insn, mnem))
return
pass
# this insn does not exist in mapping table
print('''
{
\t%s, %s_INS_%s,
#ifndef CAPSTONE_DIET
\t{ 0 }, { 0 }, { 0 }, 0, 0
#endif
},'''% (insn, arch1, mnem))
# extract from GenInstrInfo.inc, because the insn id is in order
enum_count = 0
meet_insn = False
f = open(sys.argv[2])
lines = f.readlines()
f.close()
count = 0
last_mnem = None
# 1st enum is register enum
for line in lines:
line = line.rstrip()
if len(line.strip()) == 0:
continue
# skip pseudo instructions
if len(line.strip()) == 0:
continue
if line.strip() == 'enum {':
enum_count += 1
#print(line.strip())
continue
line = line.strip()
if enum_count == 1:
# skip pseudo instructions
if '__' in line or 'setjmp' in line or 'longjmp' in line or 'Pseudo' in line:
continue
elif 'INSTRUCTION_LIST_END' in line:
break
else:
insn = line.split('=')[0].strip()
'''
insn = None
if meet_insn:
# enum items
insn = line.split('=')[0].strip()
if 'CALLSTACK' in insn or 'TAILJUMP' in insn:
# pseudo instruction
insn = None
elif line.startswith(first_insn):
insn = line.split('=')[0].strip()
meet_insn = True
if insn:
count += 1
if insn == 'BSWAP16r_BAD':
last_mnem = 'BSWAP'
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn == 'CMOVNP_Fp32':
last_mnem = 'FCMOVNP'
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn == 'CMOVP_Fp3':
last_mnem = 'FCMOVP'
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn == 'CMPSDrm_Int':
last_mnem = 'CMPSD'
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn == 'MOVSX16rm16':
last_mnem = 'MOVSX'
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn == 'MOVZX16rm16':
last_mnem = 'MOVZX'
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn == 'ST_Fp32m':
last_mnem = 'FST'
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn == 'CMOVNP_Fp64':
last_mnem = 'FCMOVNU'
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn == 'CMPSDrr_Int':
last_mnem = 'CMPSD'
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn == 'CMPSSrm_Int':
last_mnem = 'CMPSS'
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn == 'VCMPSDrm_Int':
last_mnem = 'VCMPSD'
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn == 'VCMPSSrm_Int':
last_mnem = 'VCMPSS'
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn == 'VPCMOVYrrr_REV':
last_mnem = 'VPCMOV'
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn == 'VRNDSCALESDZm':
last_mnem = 'VRNDSCALESD'
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn == 'VRNDSCALESSZm':
last_mnem = 'VRNDSCALESS'
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn == 'VMAXCPDZ128rm':
last_mnem = 'VMAXPD'
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn == 'VMAXCPSZ128rm':
last_mnem = 'VMAXPS'
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn == 'VMAXCSDZrm':
last_mnem = 'VMAXSD'
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn == 'VMAXCSSZrm':
last_mnem = 'VMAXSS'
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn == 'VMINCPDZ128rm':
last_mnem = 'VMINPD'
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn == 'VMINCPSZ128rm':
last_mnem = 'VMINPS'
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn == 'VMINCSDZrm':
last_mnem = 'VMINSD'
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn == 'VMINCSSZrm':
last_mnem = 'VMINSS'
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn == 'VMOV64toPQIZrm':
last_mnem = 'VMOVQ'
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn == 'VPERMIL2PDYrr_REV':
last_mnem = 'VPERMILPD'
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn == 'VPERMIL2PSYrr_REV':
last_mnem = 'VPERMILPS'
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn == 'VCVTSD2SI64Zrm_Int':
last_mnem = 'VCVTSD2SI'
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn == 'VCVTSD2SSrm_Int':
last_mnem = 'VCVTSD2SS'
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn == 'VCVTSS2SI64Zrm_Int':
last_mnem = 'VCVTSS2SI'
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn == 'VCVTTSD2SI64Zrm_Int':
last_mnem = 'VCVTTSD2SI'
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn == 'VCVTTSS2SI64Zrm_Int':
last_mnem = 'VCVTTSS2SI'
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn.startswith('VFMSUBADD'):
if insn[len('VFMSUBADD')].isdigit():
last_mnem = insn[:len('VFMSUBADD123xy')]
else:
last_mnem = insn[:len('VFMSUBADDSS')]
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn.startswith('VFMADDSUB'):
if insn[len('VFMADDSUB')].isdigit():
last_mnem = insn[:len('VFMADDSUB123xy')]
else:
last_mnem = insn[:len('VFMADDSUBSS')]
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn.startswith('VFMADD'):
if insn[len('VFMADD')].isdigit():
last_mnem = insn[:len('VFMADD123PD')]
else:
last_mnem = insn[:len('VFMADDPD')]
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn.startswith('VFMSUB'):
if insn[len('VFMSUB')].isdigit():
last_mnem = insn[:len('VFMSUB123PD')]
else:
last_mnem = insn[:len('VFMSUBPD')]
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn.startswith('VFNMADD'):
if insn[len('VFNMADD')].isdigit():
last_mnem = insn[:len('VFNMADD123xy')]
else:
last_mnem = insn[:len('VFNMADDSS')]
print_entry(arch.upper(), insn, last_mnem, mapping, False)
elif insn.startswith('VFNMSUB'):
if insn[len('VFNMSUB')].isdigit():
last_mnem = insn[:len('VFNMSUB123xy')]
else:
last_mnem = insn[:len('VFNMSUBSS')]
print_entry(arch.upper(), insn, last_mnem, mapping, False)
'''
if insn in insn_id_list:
# trust old mapping table
last_mnem = insn_id_list[insn].upper()
print_entry(arch, insn, insn_id_list[insn].upper(), mapping, False)
else:
# the last option when we cannot find mnem: use the last good mnem
print_entry(arch, insn, last_mnem, mapping, True)
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/capstone/suite/synctools/mapping_insn-arch.py
|
#!/usr/bin/python
# convert LLVM GenDisassemblerTables.inc for Capstone disassembler.
# for X86, this separate ContextDecision tables into another file
# by Nguyen Anh Quynh, 2019
import sys
if len(sys.argv) == 1:
print("Syntax: %s <GenDisassemblerTables.inc> <X86GenDisassemblerTables.inc> <X86GenDisassemblerTables2.inc>" %sys.argv[0])
sys.exit(1)
f = open(sys.argv[1])
lines = f.readlines()
f.close()
f1 = open(sys.argv[2], 'w+')
f2 = open(sys.argv[3], 'w+')
f1.write("/* Capstone Disassembly Engine, http://www.capstone-engine.org */\n")
f1.write("/* By Nguyen Anh Quynh <aquynh@gmail.com>, 2013-2019 */\n")
f1.write("\n")
f2.write("/* Capstone Disassembly Engine, http://www.capstone-engine.org */\n")
f2.write("/* By Nguyen Anh Quynh <aquynh@gmail.com>, 2013-2019 */\n")
f2.write("\n")
# static const struct ContextDecision x86DisassemblerOneByteOpcodes = {
# static const struct ContextDecision x86DisassemblerXOP8Opcodes = {
write_to_f2 = False
for line in lines:
if 'ContextDecision x86DisassemblerOneByteOpcodes = {' in line:
# done with f1, start writing to f2
write_to_f2 = True
if write_to_f2:
f2.write(line)
else:
f1.write(line)
f1.close()
f2.close()
|
nvtrust-main
|
infrastructure/kvm/qemu/qemu_source/capstone/suite/synctools/disassemblertables.py
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.