Delphi 嵌入汇编


Delphi 与汇编入门

// 作者 万一

http://www.cnblogs.com/del/category/121079.html

function add(x, y: Integer): Integer;
var count: Integer;
begin
asm
MOV EAX, x {把 x 值放入寄存器 EAX}
MOV ECX, y {把 y 值放入寄存器 ECX}
ADD EAX, ECX {把 EAX + ECX 的值放入 EAX}
MOV count, EAX {把 EAX 的值给变量 count}
end;
Result := count; {返回值}
//asm 中每个语句换行即可分句, 无须 ; 在这里加上也没有问题}
end;

procedure TForm1.Button1Click(Sender: TObject);
var i: Integer;
begin
i := add(2, 8); // EPrivilege with message Privileged instruction
Memo1.Lines.Add(format('%d', [i]));
end;

procedure Proc(w, x, y, z:integer);
var a, b, c, d, e, f, g: Integer;
begin
asm
mov a, eax
mov b, ebx
mov c, ecx
mov d, edx
end;
Form1.Memo1.Lines.Add(format('%d %d %d %d',[a, b, c, d]));
end;

function Proc2(w, x, y, z: Integer): Integer;
var a, b, c, d, e, f, g: Integer;
begin
asm
mov a, eax
mov b, ebx
mov c, ecx
mov d, edx
end;
//Form1.Memo1.Lines.Add(format('%d %d %d %d',[a, b, c, d])); // 如果加上此句注释则返回值为 0 ,不加此句则为 11
end;

procedure TForm1.Button3Click(Sender: TObject);
var i: Integer;
begin
Proc(11, 22, 33, 44);
// 前三个参数通过寄存器传递, 其他参数存于栈.
// EAX 先接受第一个参数再接受返回值, EBX ECX 接受后面两个参数.
// 0 0 33 22
i := Proc2(11, 22, 33, 44);
Memo1.Lines.Add(format('%d', [i])); // 11
end;

procedure TForm1.Button4Click(Sender: TObject);
var i: Integer; // 4 字节、32 位
w: Word; // 2 字节、16 位
b1, b2: Byte; // 1 字节、 4 位
begin
{
EAX 32 位
--------------------------------
| | AX 16 位 |
----------------
|AH 8 位|AL 8 位|
}
i := maxint;
w := 0;
b1 := 0;
b2 := 0;
asm
mov eax, i // EAX 寄存器 返回类型 Integer、LongWord、AnsiString、Pointer、Class
mov w, ax // AX 寄存器 返回类型 SmallInt、Word
mov b1, ah
mov b2, al // AL 寄存器 返回类型 Char、Byte
end;
Form1.Memo1.Lines.Add(Format('w=%d b1=%d b2=%d',[w, b1, b2]));
// w=65535; b1=255; b2=255 给 ecx 赋值后, cx ch cl 都有值了!

i := 8;
w := 0;
b1 := 0;
b2 := 0;
asm
mov ebx, i
mov w, bx
mov b1, bh
mov b2, bl
end;
Form1.Memo1.Lines.Add(Format('w=%d b1=%d b2=%d',[w, b1, b2]));
// w=8 b1=0 b2=8

i := 60000;
w := 0;
b1 := 0;
b2 := 0;
asm
mov edx, i
mov w, dx
mov b1, dh
mov b2, dl
end;
Form1.Memo1.Lines.Add(Format('w=%d b1=%d b2=%d',[w, b1, b2]));
// w=60000 b1=234 b2=96
end;

function AsmFun(x: Integer): Integer;
asm
add eax, eax // 相当于 Result := x * 2;
// eax 可以获取第一个参数, 同时又是函数的返回值, 所以可以如此简洁!}
end;

procedure TForm1.Button5Click(Sender: TObject);
var i: Integer;
begin
i := AsmFun(8);
Memo1.Lines.Add(format('%d', [i])); // 16
end;

function Fun(x: Integer): Integer;
asm
mov ecx, &x // 在汇编中访问 Delphi 的变量 x 可以使用 & 操作符
dec ecx // 汇编中的 dec 是减 1 指令, 和 Delphi 是一样的}
mov @Result, ecx // 在本例中去掉 @ 也可以, 暂时不知怎么回事
end;

procedure TForm1.Button6Click(Sender: TObject);
var i: Integer;
begin
i := Fun(9);
Memo1.Lines.Add(format('%d', [i])); // 8
end;

function Fun2(var x,y: Integer): Integer;
asm
mov eax, x {现在 eax 中只是 x 的地址}
mov eax, [eax] { [eax] 是取值, 是不是类似于 P^ ? }
mov edx, y
add eax, [edx]
//mov @Result, eax {在这里, 这句可有可无}
end;


procedure TForm1.Button7Click(Sender: TObject);
var a, b: Integer;
begin
a := 1;
b := 8;
a := Fun2(a, b);
Memo1.Lines.Add(IntToStr(a)); {9}
end;

// 常量可以在汇编语句中运算
function Fun3: Integer;
const
a = 11;
b = 5;
asm
mov eax, a - b
end;

//变量不可以, 方法中的参数也都属于变量

function Fun4: Integer;
var x, y: Integer;
asm
mov x, 11
mov y, 5
//mov eax, x-y {不能这样使用}
mov eax, x
sub eax, y {sub 是减, 就像 add 是加一样}
end;

procedure TForm1.Button8Click(Sender: TObject);
var i: Integer;
begin
i := Fun3;
Memo1.Lines.Add(format('%d', [i])); // 6
i := Fun4;
Memo1.Lines.Add(format('%d', [i])); // 6
end;

// 使用应该保护的 ebx 寄存器
function Fun5(x: Integer): Integer;
{
前面提到 32 位的寄存器有: EAX EBX ECX EDX ESP EBP ESI EDI;
其中, EAX ECX EDX 是自由使用的.
那么剩下的 EBX ESP EBP ESI EDI 五个寄存器就是应该保护的!
所谓保护, 并不是不可以使用,
而是在使用前先把其中的值寄存在另外一个地方, 用完后再恢复其值.
如果不这样做, 有可能会发生意想不到的错误.
}
asm
push ebx // push 是入栈指令, 栈就是系统自动分配的内存
mov ebx, x
inc ebx
mov @Result, ebx
pop ebx // pop 是出栈指令, 也就是恢复 ebx 寄存器原来的值
end;

procedure TForm1.Button9Click(Sender: TObject);
var i: Integer;
begin
i := Fun5(8);
Memo1.Lines.Add(format('%d', [i])); // 9
end;

//十进制
function Fun6: Integer;
asm
mov eax, 255
end;

//十进制数后面也可以加个 D(大小写无关)
function Fun7: Integer;
asm
mov eax, 255D
end;

//二进制后面加 B(大小写无关)
function Fun8: Integer;
asm
mov eax, 11111111B
end;

//八进制后面加 O(大小写无关)
function Fun9: Integer;
asm
mov eax, 377O
end;

//十六进制前面加 $
function Fun10: Integer;
asm
mov eax, $FF
end;

//十六进制也可以是后面加 H(大小写无关)
function Fun11: Integer;
asm
mov eax, 0FFH {使用这种方法, 数字的首位不能是字母, 不然会被认为成标识符}
end;

//非汇编代码的 Delphi 只支持用 $ 表示十六进制
function Fun12: Integer;
begin
Result := $FF;
end;

procedure TForm1.Button10Click(Sender: TObject);
begin
with Memo1.Lines do
begin
Add(format('%d', [Fun6])); // 255
Add(format('%d', [Fun7])); // 255
Add(format('%d', [Fun8])); // 255
Add(format('%d', [Fun9])); // 255
Add(format('%d', [Fun10])); // 255
Add(format('%d', [Fun11])); // 255
Add(format('%d', [Fun12])); // 255
end;
end;

procedure TForm1.Button11Click(Sender: TObject);
var ByteNum: Byte;
begin
{ 逻辑非 Not:
not 1 = 0;
not 0 = 1;
}
//赋值 11111111B (255) 取反:
asm
mov al, 11111111B {eax 包含 ax; ax 包含 al; al 是 eax 的低八位}
not al {给 11111111 取反会得到 00000000}
mov ByteNum, al {把寄存器 al 中的值给变量 ByteNum}
end;
Memo1.Lines.Add(IntToStr(ByteNum)); {0}

{ 逻辑或 Or:
1 or 0 = 1;
0 or 1 = 1;
1 or 1 = 1; // 逻辑异或 1 Xor 1 = 0;
0 or 0 = 0;
}
asm
mov al, 10101010B {170}
mov cl, 01010101B {85}
or al, cl
mov ByteNum, al
end;
Memo1.Lines.Add(IntToStr(ByteNum)); {255}

{ 逻辑与 And:
1 and 1 = 1;
1 and 0 = 0;
0 and 1 = 0;
0 and 0 = 0;
}
asm
mov al, 11111111B {255}
mov cl, 11111111B {255}
and al, cl
mov ByteNum, al
end;
Memo1.Lines.Add(IntToStr(ByteNum)); {255}

{ 逻辑异或 Xor:
1 Xor 0 = 1;
0 Xor 1 = 1;
1 Xor 1 = 0; // 常用来置 0 , 与逻辑或不同: 1 or 1 = 1;
0 Xor 0 = 0;
}

asm
mov al, 11111111B {255}
mov cl, 11111111B {255}
xor al, cl
mov ByteNum, al
end;
Memo1.Lines.Add(IntToStr(ByteNum)); {0}
end;

procedure TForm1.Button12Click(Sender: TObject);
var ByteNum: Byte;
begin
//右移 shr
asm
mov al, 10000000B {128}
shr al, 1 {shr 10000000 一次会得到 01000000}
mov ByteNum, al
end;
Memo1.Lines.Add(IntToStr(ByteNum)); {64; shr 相当于 ÷2}

//左移 shl
asm
mov al, 00000001B {1}
shl al, 1 {shl 一次会得到 00000010}
shl al, 1 {shl 两次会得到 00000100}
mov ByteNum, al
end;
Memo1.Lines.Add(IntToStr(ByteNum)); {4; shl 相当于 ×2}
end;

procedure TForm1.Button13Click(Sender: TObject);
var B: Byte;
W: Word;
C: Cardinal;
begin
{Byte 是1字节(8位)无符号整型, 其最大值是 111111112}
asm
mov B, 11111111B;
end;
Memo1.Lines.Add(IntToStr(B)); {255}

{Word 是2字节(16位)无符号整型, 其最大值是 11111111 111111112}
asm
mov W, 1111111111111111B;
end;
Memo1.Lines.Add(IntToStr(W)); {65535}

{Cardinal 是4字节(32位)无符号整型, 其最大值是 11111111 11111111 11111111 111111112}
asm
mov C, 11111111111111111111111111111111B;
end;
Memo1.Lines.Add(IntToStr(C)); {4294967295}

{它们的最小值都是 0}
end;

procedure TForm1.Button14Click(Sender: TObject);
var I: Integer;
begin
// Integer 类型是4字节(32位)有符号整数, 最高位是符号位, 如果是正数, 符号位是 0、负数的符号位是1
// 所以 Integer 的最大值是: 01111111 11111111 11111111 111111112
asm
mov I, 01111111111111111111111111111111B;
end;
Memo1.Lines.Add(IntToStr(I)); {2147483647}

//有符号整数的负数等于相同正数的反码 + 1; Integer 最大值是:
//01111111 11111111 11111111 111111112; 其反码是:
//10000000 00000000 00000000 000000002; 反码 + 1 以后是:
//10000000 00000000 00000000 000000012
asm
mov I, 10000000000000000000000000000001B;
end;
Memo1.Lines.Add(IntToStr(I)); {-2147483647}

//那 Integer 的最小值是多少呢?
//应该是: 10000000 00000000 00000000 000000002
asm
mov I, 10000000000000000000000000000000B;
end;
Memo1.Lines.Add(IntToStr(I)); {-2147483648}

//11111111 11111111 11111111 111111112 是?
asm
mov I, 11111111111111111111111111111111B;
end;
Memo1.Lines.Add(IntToStr(I)); {-1}

//Integer 类型的 0 在内存中是: 00000000 00000000 00000000 000000002
asm
mov I, 00000000000000000000000000000000B;
end;
Memo1.Lines.Add(IntToStr(I)); {0}

//Integer 类型的 10010 的二进制是: 00000000 00000000 00000000 011001002
asm
mov I, 00000000000000000000000001100100B;
end;
Memo1.Lines.Add(IntToStr(I)); {100}

//算 Integer 类型的 -10010:
//00000000 00000000 00000000 01100100 的反码是:
//11111111 11111111 11111111 10011011 ; 反码 + 1 以后是:
//11111111 11111111 11111111 10011100
asm
mov I, 11111111111111111111111110011100B;
end;
Memo1.Lines.Add(IntToStr(I)); {-100}
end;


联系电话:
020-00000000
联系电话:
020-00000000
联系电话:
020-12345678