таблицы кодирования инструкции по x86

Я нахожусь в середине перезаписи моего ассемблера. В то время как в нем мне любопытно на предмет реализации дизассемблирования также. Я хочу сделать это простым и компактным, и существуют понятия, которые я могу использовать при выполнении так.

Возможно определить отдых x86 кодирования инструкции из кода операции (возможно, байты префикса требуются также, немного). Я знаю, что многие люди записали таблицы для того, чтобы сделать его.

Мне не интересно о мнемонике, но кодировании инструкции, потому что это - фактическая тяжелая проблема там. Для каждого числа кода операции я должен знать:

• эта инструкция содержит modrm?
• сколько непосредственных полей эта инструкция имеет?
• какое кодирование непосредственное использует?
• непосредственное в поле указатель команд - относительный адрес?
• какие регистры modrm использует для операнда и регистрирует поля?

sandpile.org имеет несколько вполне много, в чем я нуждался бы, но это находится в формате, который не легко проанализировать.

Прежде чем я начну писать и проверять те таблицы сам, я решил записать этот вопрос. Вы знаете об этом виде таблиц, существующих где-нибудь? В форме, которая не требует слишком большого усилия проанализировать.

b   byte
w   word
v   word or dword (or qword), depends on operand size attribute (0x66)
z   word or dword (or dword), depends on operand size attribute
J   instruction-relative address (next character describes type)
G   instruction group, has modrm-field (next character describes operand type)
R   has modrm-field (next two characters describe register and operand type)
M   modrm, but operand field must point to memory
O   direct offset (next character describes type)
F   FPU
T   separate table
_   defined, but no arguments

x    0    1    2    3    4    5    6    7    8    9    A    B    C    D    E    F
0  Rbb  Rvv  Rbb  Rvv    b    z            Rbb  Rvv  Rbb  Rvv    b    z         T
1  Rbb  Rvv  Rbb  Rvv    b    z            Rbb  Rvv  Rbb  Rvv    b    z
2  Rbb  Rvv  Rbb  Rvv    b    z            Rbb  Rvv  Rbb  Rvv    b    z
3  Rbb  Rvv  Rbb  Rvv    b    z            Rbb  Rvv  Rbb  Rvv    b    z
4    _    _    _    _    _    _    _    _    _    _    _    _    _    _    _    _
5    _    _    _    _    _    _    _    _    _    _    _    _    _    _    _    _
6    _    _  Mvv                             z Rvvz    b Rvvb
7   Jb   Jb   Jb   Jb   Jb   Jb   Jb   Jb   Jb   Jb   Jb   Jb   Jb   Jb   Jb   Jb
8  Gbb  Gvz  Gbb  Gvb  Rbb  Rvv  Rbb  Rvv  Rbb  Rvv  Rbb  Rvv       Mvv
9    _    _    _    _    _    _    _    _                        _    _    _    _
A   Ob   Ov   Ob   Ov    _    _    _    _    b    z    _    _    _    _    _    _
B    b    b    b    b    b    b    b    b    v    v    v    v    v    v    v    v
C  Gbb  Gvb    w    _                                            _    b    _    _
D   Gb   Gv   Gb   Gv                        F    F    F    F    F    F    F    F
E                                           Jz   Jz        Jb
F                        _    _   Gb   Gv    _    _    _    _    _    _   Gb   Gv

Здесь у меня есть таблица для первого операнда. Формат таков, что таблица может быть проанализирована прямо из текстового файла, который содержит его. Я оставил далеко некоторый CISC и связанные с сегментацией инструкции.

Для двух байтовых команд, которые возможности, мне нужны четыре таких таблицы. Для трех байтовых команд мне будут нужны две таблицы больше. Инструкции FPU требуют 8 таблиц, которые, к счастью, очень просты. После этого у меня был бы довольно большой блок x86 инструкций покрытым. Хотя я иду очень хорошо со всего одной или двумя таблицами.

Далее, немного групп инструкции могли бы потребовать, чтобы некоторые небольшие массивы распознали тип инструкции.