ASCII码对照表

一些IDA宏定义,背不掉所以直接Backup一份QWQ

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
/*

This file contains definitions used by the Hex-Rays decompiler output.
It has type definitions and convenience macros to make the
output more readable.

Copyright © 2007-2011 Hex-Rays

*/

#if defined(GNUC)
typedef long long ll;
typedef unsigned long long ull;
#define __int64 long long
#define __int32 int
#define __int16 short
#define __int8 char
#define MAKELL(num) num ## LL
#define FMT_64 “ll”
#elif defined(_MSC_VER)
typedef __int64 ll;
typedef unsigned __int64 ull;
#define MAKELL(num) num ## i64
#define FMT_64 “I64”
#elif defined (BORLANDC)
typedef __int64 ll;
typedef unsigned __int64 ull;
#define MAKELL(num) num ## i64
#define FMT_64 “L”
#else
#error “unknown compiler”
#endif
typedef unsigned int uint;
typedef unsigned char uchar;
typedef unsigned short ushort;
typedef unsigned long ulong;

typedef char int8;
typedef signed char sint8;
typedef unsigned char uint8;
typedef short int16;
typedef signed short sint16;
typedef unsigned short uint16;
typedef int int32;
typedef signed int sint32;
typedef unsigned int uint32;
typedef ll int64;
typedef ll sint64;
typedef ull uint64;

// Partially defined types:
#define _BYTE uint8
#define _WORD uint16
#define _DWORD uint32
#define _QWORD uint64
#if !defined(_MSC_VER)
#define _LONGLONG __int128
#endif

#ifndef WINDOWS
typedef int8 BYTE;
typedef int16 WORD;
typedef int32 DWORD;
typedef int32 LONG;
#endif
typedef int64 QWORD;
#ifndef __cplusplus
typedef int bool; // we want to use bool in our C programs
#endif

// Some convenience macros to make partial accesses nicer
// first unsigned macros:
#define LOBYTE(x) (((_BYTE)&(x))) // low byte
#define LOWORD(x) (((_WORD)&(x))) // low word
#define LODWORD(x) (((_DWORD)&(x))) // low dword
#define HIBYTE(x) (((_BYTE)&(x)+1))
#define HIWORD(x) (((_WORD)&(x)+1))
#define HIDWORD(x) (((_DWORD)&(x)+1))
#define BYTEn(x, n) (((_BYTE)&(x)+n))
#define WORDn(x, n) (((_WORD)&(x)+n))
#define BYTE1(x) BYTEn(x, 1) // byte 1 (counting from 0)
#define BYTE2(x) BYTEn(x, 2)
#define BYTE3(x) BYTEn(x, 3)
#define BYTE4(x) BYTEn(x, 4)
#define BYTE5(x) BYTEn(x, 5)
#define BYTE6(x) BYTEn(x, 6)
#define BYTE7(x) BYTEn(x, 7)
#define BYTE8(x) BYTEn(x, 8)
#define BYTE9(x) BYTEn(x, 9)
#define BYTE10(x) BYTEn(x, 10)
#define BYTE11(x) BYTEn(x, 11)
#define BYTE12(x) BYTEn(x, 12)
#define BYTE13(x) BYTEn(x, 13)
#define BYTE14(x) BYTEn(x, 14)
#define BYTE15(x) BYTEn(x, 15)
#define WORD1(x) WORDn(x, 1)
#define WORD2(x) WORDn(x, 2) // third word of the object, unsigned
#define WORD3(x) WORDn(x, 3)
#define WORD4(x) WORDn(x, 4)
#define WORD5(x) WORDn(x, 5)
#define WORD6(x) WORDn(x, 6)
#define WORD7(x) WORDn(x, 7)

// now signed macros (the same but with sign extension)
#define SLOBYTE(x) (((int8)&(x)))
#define SLOWORD(x) (((int16)&(x)))
#define SLODWORD(x) (((int32)&(x)))
#define SHIBYTE(x) (((int8)&(x)+1))
#define SHIWORD(x) (((int16)&(x)+1))
#define SHIDWORD(x) (((int32)&(x)+1))
#define SBYTEn(x, n) (((int8)&(x)+n))
#define SWORDn(x, n) (((int16)&(x)+n))
#define SBYTE1(x) SBYTEn(x, 1)
#define SBYTE2(x) SBYTEn(x, 2)
#define SBYTE3(x) SBYTEn(x, 3)
#define SBYTE4(x) SBYTEn(x, 4)
#define SBYTE5(x) SBYTEn(x, 5)
#define SBYTE6(x) SBYTEn(x, 6)
#define SBYTE7(x) SBYTEn(x, 7)
#define SBYTE8(x) SBYTEn(x, 8)
#define SBYTE9(x) SBYTEn(x, 9)
#define SBYTE10(x) SBYTEn(x, 10)
#define SBYTE11(x) SBYTEn(x, 11)
#define SBYTE12(x) SBYTEn(x, 12)
#define SBYTE13(x) SBYTEn(x, 13)
#define SBYTE14(x) SBYTEn(x, 14)
#define SBYTE15(x) SBYTEn(x, 15)
#define SWORD1(x) SWORDn(x, 1)
#define SWORD2(x) SWORDn(x, 2)
#define SWORD3(x) SWORDn(x, 3)
#define SWORD4(x) SWORDn(x, 4)
#define SWORD5(x) SWORDn(x, 5)
#define SWORD6(x) SWORDn(x, 6)
#define SWORD7(x) SWORDn(x, 7)

// Helper functions to represent some assembly instructions.

#ifdef __cplusplus

// Fill memory block with an integer value
inline void memset32(void *ptr, uint32 value, int count)
{
uint32 *p = (uint32 *)ptr;
for ( int i=0; i < count; i++ )
*p++ = value;
}

// Generate a reference to pair of operands
template int16 PAIR( int8 high, T low) { return ((( int16)high) << sizeof(high)*8) | uint8(low); }
template int32 PAIR( int16 high, T low) { return ((( int32)high) << sizeof(high)*8) | uint16(low); }
template int64 PAIR( int32 high, T low) { return ((( int64)high) << sizeof(high)*8) | uint32(low); }
template uint16 PAIR(uint8 high, T low) { return (((uint16)high) << sizeof(high)*8) | uint8(low); }
template uint32 PAIR(uint16 high, T low) { return (((uint32)high) << sizeof(high)*8) | uint16(low); }
template uint64 PAIR(uint32 high, T low) { return (((uint64)high) << sizeof(high)*8) | uint32(low); }

// rotate left
template T ROL(T value, uint count)
{
const uint nbits = sizeof(T) * 8;
count %= nbits;

T high = value >> (nbits - count);
value <<= count;
value |= high;
return value;
}

// rotate right
template T ROR(T value, uint count)
{
const uint nbits = sizeof(T) * 8;
count %= nbits;

T low = value << (nbits - count);
value >>= count;
value |= low;
return value;
}

// carry flag of left shift
template int8 MKCSHL(T value, uint count)
{
const uint nbits = sizeof(T) * 8;
count %= nbits;

return (value >> (nbits-count)) & 1;
}

// carry flag of right shift
template int8 MKCSHR(T value, uint count)
{
return (value >> (count-1)) & 1;
}

// sign flag
template int8 SETS(T x)
{
if ( sizeof(T) == 1 )
return int8(x) < 0;
if ( sizeof(T) == 2 )
return int16(x) < 0;
if ( sizeof(T) == 4 )
return int32(x) < 0;
return int64(x) < 0;
}

// overflow flag of subtraction (x-y)
template<class T, class U> int8 OFSUB(T x, U y)
{
if ( sizeof(T) < sizeof(U) )
{
U x2 = x;
int8 sx = SETS(x2);
return (sx ^ SETS(y)) & (sx ^ SETS(x2-y));
}
else
{
T y2 = y;
int8 sx = SETS(x);
return (sx ^ SETS(y2)) & (sx ^ SETS(x-y2));
}
}

// overflow flag of addition (x+y)
template<class T, class U> int8 OFADD(T x, U y)
{
if ( sizeof(T) < sizeof(U) )
{
U x2 = x;
int8 sx = SETS(x2);
return ((1 ^ sx) ^ SETS(y)) & (sx ^ SETS(x2+y));
}
else
{
T y2 = y;
int8 sx = SETS(x);
return ((1 ^ sx) ^ SETS(y2)) & (sx ^ SETS(x+y2));
}
}

// carry flag of subtraction (x-y)
template<class T, class U> int8 CFSUB(T x, U y)
{
int size = sizeof(T) > sizeof(U) ? sizeof(T) : sizeof(U);
if ( size == 1 )
return uint8(x) < uint8(y);
if ( size == 2 )
return uint16(x) < uint16(y);
if ( size == 4 )
return uint32(x) < uint32(y);
return uint64(x) < uint64(y);
}

// carry flag of addition (x+y)
template<class T, class U> int8 CFADD(T x, U y)
{
int size = sizeof(T) > sizeof(U) ? sizeof(T) : sizeof(U);
if ( size == 1 )
return uint8(x) > uint8(x+y);
if ( size == 2 )
return uint16(x) > uint16(x+y);
if ( size == 4 )
return uint32(x) > uint32(x+y);
return uint64(x) > uint64(x+y);
}

#else
// The following definition is not quite correct because it always returns
// uint64. The above C++ functions are good, though.
#define PAIR(high, low) (((uint64)(high)<<sizeof(high)*8) | low)
// For C, we just provide macros, they are not quite correct.
#define ROL(x, y) rotl(x, y) // Rotate left
#define ROR(x, y) rotr(x, y) // Rotate right
#define CFSHL(x, y) invalid_operation // Generate carry flag for (x<<y)
#define CFSHR(x, y) invalid_operation // Generate carry flag for (x>>y)
#define CFADD(x, y) invalid_operation // Generate carry flag for (x+y)
#define CFSUB(x, y) invalid_operation // Generate carry flag for (x-y)
#define OFADD(x, y) invalid_operation // Generate overflow flag for (x+y)
#define OFSUB(x, y) invalid_operation // Generate overflow flag for (x-y)
#endif

// No definition for rcl/rcr because the carry flag is unknown
#define RCL(x, y) invalid_operation // Rotate left thru carry
#define RCR(x, y) invalid_operation // Rotate right thru carry
#define MKCRCL(x, y) invalid_operation // Generate carry flag for a RCL
#define MKCRCR(x, y) invalid_operation // Generate carry flag for a RCR
#define SETP(x, y) invalid_operation // Generate parity flag for (x-y)

// In the decompilation listing there are some objects declarared as _UNKNOWN
// because we could not determine their types. Since the C compiler does not
// accept void item declarations, we replace them by anything of our choice,
// for example a char:

#define _UNKNOWN char

#ifdef _MSC_VER
#define snprintf _snprintf
#define vsnprintf _vsnprintf
#endif

IDC脚本常用函数

原文链接:
https://blog.csdn.net/u011478909/article/details/53540196
https://blog.csdn.net/jazrynwong/article/details/84875699