1
/* Copyright (c) 2007, Google Inc.
4
* Redistribution and use in source and binary forms, with or without
5
* modification, are permitted provided that the following conditions are
8
* * Redistributions of source code must retain the above copyright
9
* notice, this list of conditions and the following disclaimer.
10
* * Redistributions in binary form must reproduce the above
11
* copyright notice, this list of conditions and the following disclaimer
12
* in the documentation and/or other materials provided with the
14
* * Neither the name of Google Inc. nor the names of its
15
* contributors may be used to endorse or promote products derived from
16
* this software without specific prior written permission.
18
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31
* Author: Joi Sigurdsson
33
* Several simple types used by the disassembler and some of the patching
37
#ifndef GOOGLE_PERFTOOLS_MINI_DISASSEMBLER_TYPES_H_
38
#define GOOGLE_PERFTOOLS_MINI_DISASSEMBLER_TYPES_H_
42
// Categories of instructions that we care about
43
enum InstructionType {
44
// This opcode is not used
46
// This disassembler does not recognize this opcode (error)
48
// This is not an instruction but a reference to another table
50
// This byte is a prefix byte that we can ignore
52
// This is a prefix byte that switches to the nondefault address size
54
// This is a prefix byte that switches to the nondefault operand size
56
// A jump or call instruction
58
// A return instruction
60
// Any other type of instruction (in this case we don't care what it is)
64
// Lists IA-32 operand sizes in multiples of 8 bits
71
OS_DOUBLE_QUAD_WORD = 16,
72
OS_32_BIT_POINTER = 32/8,
73
OS_48_BIT_POINTER = 48/8,
74
OS_SINGLE_PRECISION_FLOATING = 32/8,
75
OS_DOUBLE_PRECISION_FLOATING = 64/8,
76
OS_DOUBLE_EXTENDED_PRECISION_FLOATING = 80/8,
77
OS_128_BIT_PACKED_SINGLE_PRECISION_FLOATING = 128/8,
78
OS_PSEUDO_DESCRIPTOR = 6
81
// Operand addressing methods from the IA-32 manual. The enAmMask value
82
// is a mask for the rest. The other enumeration values are named for the
83
// names given to the addressing methods in the manual, e.g. enAm_D is for
84
// the D addressing method.
86
// The reason we use a full 4 bytes and a mask, is that we need to combine
87
// these flags with the enOperandType to store the details
88
// on the operand in a single integer.
89
enum AddressingMethod {
90
AM_NOT_USED = 0, // This operand is not used for this instruction
91
AM_MASK = 0x00FF0000, // Mask for the rest of the values in this enumeration
92
AM_A = 0x00010000, // A addressing type
93
AM_C = 0x00020000, // C addressing type
94
AM_D = 0x00030000, // D addressing type
95
AM_E = 0x00040000, // E addressing type
96
AM_F = 0x00050000, // F addressing type
97
AM_G = 0x00060000, // G addressing type
98
AM_I = 0x00070000, // I addressing type
99
AM_J = 0x00080000, // J addressing type
100
AM_M = 0x00090000, // M addressing type
101
AM_O = 0x000A0000, // O addressing type
102
AM_P = 0x000B0000, // P addressing type
103
AM_Q = 0x000C0000, // Q addressing type
104
AM_R = 0x000D0000, // R addressing type
105
AM_S = 0x000E0000, // S addressing type
106
AM_T = 0x000F0000, // T addressing type
107
AM_V = 0x00100000, // V addressing type
108
AM_W = 0x00110000, // W addressing type
109
AM_X = 0x00120000, // X addressing type
110
AM_Y = 0x00130000, // Y addressing type
111
AM_REGISTER = 0x00140000, // Specific register is always used as this op
112
AM_IMPLICIT = 0x00150000, // An implicit, fixed value is used
115
// Operand types from the IA-32 manual. The enOtMask value is
116
// a mask for the rest. The rest of the values are named for the
117
// names given to these operand types in the manual, e.g. enOt_ps
118
// is for the ps operand type in the manual.
120
// The reason we use a full 4 bytes and a mask, is that we need
121
// to combine these flags with the enAddressingMethod to store the details
122
// on the operand in a single integer.
124
OT_MASK = 0xFF000000,
132
OT_PS = 0x08000000, // actually unsupported for (we don't know its size)
139
OT_SD = 0x0F000000, // scalar double-precision floating-point value
140
OT_PD = 0x10000000, // double-precision floating point
141
// dummy "operand type" for address mode M - which doesn't specify
143
OT_ADDRESS_MODE_M = 0x80000000
146
// Everything that's in an Opcode (see below) except the three
147
// alternative opcode structs for different prefixes.
148
struct SpecificOpcode {
149
// Index to continuation table, or 0 if this is the last
150
// byte in the opcode.
154
InstructionType type_;
156
// Description of the type of the dest, src and aux operands,
157
// put together from an enOperandType flag and an enAddressingMethod
163
// We indicate the mnemonic for debugging purposes
164
const char* mnemonic_;
167
// The information we keep in our tables about each of the different
168
// valid instructions recognized by the IA-32 architecture.
170
// Index to continuation table, or 0 if this is the last
171
// byte in the opcode.
175
InstructionType type_;
177
// Description of the type of the dest, src and aux operands,
178
// put together from an enOperandType flag and an enAddressingMethod
184
// We indicate the mnemonic for debugging purposes
185
const char* mnemonic_;
187
// Alternative opcode info if certain prefixes are specified.
188
// In most cases, all of these are zeroed-out. Only used if
189
// bPrefixDependent is true.
190
bool is_prefix_dependent_;
191
SpecificOpcode opcode_if_f2_prefix_;
192
SpecificOpcode opcode_if_f3_prefix_;
193
SpecificOpcode opcode_if_66_prefix_;
196
// Information about each table entry.
198
// Table of instruction entries
199
const Opcode* table_;
200
// How many bytes left to shift ModR/M byte <b>before</b> applying mask
201
unsigned char shift_;
202
// Mask to apply to byte being looked at before comparing to table
204
// Minimum/maximum indexes in table.
205
unsigned char min_lim_;
206
unsigned char max_lim_;
209
// Information about each entry in table used to decode ModR/M byte.
211
// Is the operand encoded as bytes in the instruction (rather than
212
// if it's e.g. a register in which case it's just encoded in the
214
bool is_encoded_in_instruction_;
216
// Is there a SIB byte? In this case we always need to decode it.
219
// What is the size of the operand (only important if it's encoded
220
// in the instruction)?
221
OperandSize operand_size_;
224
}; // namespace sidestep
226
#endif // GOOGLE_PERFTOOLS_MINI_DISASSEMBLER_TYPES_H_
added
removed
src/windows/mini_disassembler_types.h
