
平台论坛博客文库

› 论坛 › 程序设计 › C/C++ › 测试 a64 汇编语言汇编译器

12 3 / 3 页下一页

测试 a64 汇编语言汇编译器 [复制链接]

mik

荣誉版主

论坛徽章:: 0

电梯直达

1楼 [收藏(0)] [报告]

发表于 2006-04-10 16:16 |只看该作者 |倒序浏览

a64 是我在业余时间,开设计到编码实现上,断断续续用了5个月时间写出来的! 我完全没有看过任何关于编译器开发的书籍,凭着自已的想象,手中只有一份 AMD 的x86-64 架构的手册, 从这份 AMD 手册摸索其64位技术!

a64是一款基于AMD x86-64 架构的64位汇编编译器。我不知道，Intel的EM64T技术是否能适用。

A64采用Intel的语法格式，与nasm的语法格式差不多。只是3个主要的语法差别。

（一）、内存操作数以及远程跳转的造型上不同：
例如：mov [eax], 1 和 call far es:[eax]
像以上这条指令，你必须明确地对目的操作数作出造型，否则，编译器会报错。
（1） Microsoft 的Masm 语法是这样的：

mov dword ptr [eax], 1
call far ptr es:[eax]

复制代码

（2） GNU assembler 的语法是这样的：

movl $1,(%eax)
lcall %es:(%eax)

复制代码

(3) Nasm 的语法是这样的：

mov dword [eax], 1
call far [es:eax]

复制代码

(4) 最后，在a64中我定义的语法是这样的：

mov (dword)[eax],1
call (far)es:[eax]

复制代码

在我定义的造型语法，是取自于C语言的类型造型方法，我认为这样更为好看，更自然。

（二）、转移指令中的标号表示方法上的不同
在a64中我定义的标号是这样的：

@label:
jmp @label

复制代码

而其它三款编译器都是这样：

label：
jmp label

复制代码

为什么要加上@ ？是不是有点多余？
我觉得加上@能明确知道这是一个标号，并能这样实现比较容易，最后我认为这样看也比较顺眼！

（三）a64指令是区别大小写的，其它几款不是。在a64中注释以！字符开头。
举个例子，总结语法：

!--------------------------------------------------------------
! unsigned int str_str(const char *dest, const char* source)
!
! reture value:
! 0: no found
! unsigned int: found & get postion
!--------------------------------------------------------------
.bits 32
@str_str:
mov edi, [esp+4]
mov esi, [esp+8]
sub esp, 8
mov [esp+4], edi
mov [esp], esi
mov eax, 1
@loop3:
mov ebx, esi
mov edx, edi
inc esi
inc edi
mov cl, [ebx]
!-----------
! found & no found
test cl,cl
jz @result
cmp (byte)[edx], 0
jz @no
!-----------
cmp cl, [edx]
jz @loop3
@yes:
inc (dword)[esp+4]
mov edi, [esp+4]
mov esi, [esp]
inc eax
jmp @loop3
@no:
xor eax, eax
@result:
add esp, 8
ret

复制代码

在附件中, 有我上传到论坛的 a64 软件!!! 各位可下载去测试
我希望,各位版主能帮个忙,帮我置顶,以便更多的人进行测试!

a64

67.52 KB, 下载次数: 85

a64

文库|博客

mik

荣誉版主

论坛徽章:: 0

2楼 [报告]

发表于 2006-04-10 16:18 |只看该作者

语法元素：

（一） a64 最大特色是支持64位的指令。它缺省的模式是64-bit 模式
所以，当你要写32位代码时，最好明确指明是32-bit 模式。用以下命令指示：
.bits 32 当然，在64-bit下也能编译32位代码，只是有些代码是有区别的，但区别不大
例如：

mov eax,[eax]

复制代码

这样的指令在32位下和64位下是不同的。在64位下，内存地址缺省是64位，所以
在32位下编码是：

a64支持x86-64的全系列指令模式，包括：16-bit，32-bit 以及64-bit
分别用：

.bits 16
.bits 32
.bits 64

复制代码

来指示。
在a64中可以随意地改变编码模式，例如：

.bits 16 ！指意16位代码
mov ax,0
test al,al
.bits 32 ！指示32位代码
mov eax,0
mov ebx,[eax]
.bits 64 ！指示64位代码
mov eax,0
mov rbx,[r10+r9*8+0x1122] ！包含64位长的寄存器，和一些扩展寄存器

复制代码

结果编码为：

b8 0 0 mov ax,0
84 c0 test al,al
b8 0 0 0 0 mov eax,0
8b 18 mov ebx,[eax]
b8 0 0 0 0 mov eax, 0
4b 8b 9c ca 22 11 0 0 mov rbx,[r10+r9*8+0x1122]

复制代码

实战分享：从技术角度谈机器学习入门| 【大话IT】RadonDB低门槛向MySQL集群下战书 | ChinaUnix打赏功能已上线！ | 新一代分布式关系型数据库RadonDB知多少？

mik

荣誉版主

论坛徽章:: 0

3楼 [报告]

发表于 2006-04-10 16:19 |只看该作者

a64 命令：
（1）、a64 <源文件>
例如： a64 test.s 它会生成一个纯二进制目标文件 test
a64 支持 .s 和 .asm的源文件

（2） a64 –print-encode <源文件>
例如： a64 –print-encode test.s a64直接在屏幕上显示生成的编码，这不过是一个过渡性的命令选项。

（3） a64 –f<目标文件格式>
这个命令选项暂时还没什么作用，因为还没实现目标文件格式

（4） 64 –-version 或 –v 打印 a64 版本

（5） a64 –-verbose 打印 a64 信息

（6） a64 –-help 打印帮助信息

(7) a64 test.s -o test 定义输出文件

mik

荣誉版主

论坛徽章:: 0

4楼 [报告]

发表于 2006-04-10 16:21 |只看该作者

a64的缺点：
（一）目前，a64只支持通用指令，暂时还不支持 X87（浮点指令）、MMX（64位多媒体指令）
MMX（128位扩展多媒指令）、AMD 3Dnow 指令。

（二） a64在错误处理上还不太好

（三） a64目前最大缺点是：目前只能输出纯二进制文件，也就是 bin 格式的文件，
还不能输出 elf 格式文件。因为，我还没弄懂 elf 文件格式的细节，所以还没实现
所以，a64现在还没有什么实际的作用，只可以写操作系统引导代码之类的，

(四) 太少语法元素,目前还不支持变量定义,过程定义等等..... 因为没有时间去做!!!!

angelanpan

丰衣足食

论坛徽章:: 0

5楼 [报告]

发表于 2006-04-10 16:22 |只看该作者

牛
赞一下

mik

荣誉版主

论坛徽章:: 0

6楼 [报告]

发表于 2006-04-10 16:22 |只看该作者

测试方法：
（1）由于a64还不能生成elf 的object文件，所以只能用打印输出编码的方式来观察a64生成的代码对不对。

用以下命令来观察：

a64 --print-encode test.s

复制代码

这样a64会直接输出编码。

（2）也可以这样，用a64 生成代码，然后用nasm的ndisasm 和反编译看一看是否正确

a64 test.s a64会输出目标文件 test
ndisasm –u test 用ndisasm –u 命令来dump 目标代码

复制代码

（3）还可以这样：同样的源代码，分别用a64、nasm 以及 gnu as 来生成，看产生的代码是否一致！不过，记住，一条指令可以生成几种形式。

举个例子：
1、a64 源代码：

.bits 32
adc al,0x0c
adc bl,0x0c

复制代码

2、gnu as 形式的源代码：

adc $0x0c, %al
adc $0x0c, %bl

复制代码

结果：
1、 a64 生成的：

14 c 80 d3 c

复制代码

2、 as 生成的：

tt.o: file format elf32-i386
Disassembly of section .text:
00000000 <.text>:
0: 12 05 0c 00 00 00 adc 0xc,%al
6: 12 1d 0c 00 00 00 adc 0xc,%bl

复制代码

可以看到，a64生成的代码和as 生成的代码都是正确的，不过a64产生的代码更短，更优！

我推荐使用ndisasm来dump 代码观察测试。！！！！

mik

荣誉版主

论坛徽章:: 0

7楼 [报告]

发表于 2006-04-10 16:23 |只看该作者

编写64位代码:
举个例子:

.bits 64
mov rax,0x1122334455667788
mov r13,0x11
mov rax,[0x1122334455667788]
mov r14,[0x11]
push (word)[0x1122334455667788]
test (qword)[0x1122334455667788], 0

复制代码

a64 生成的代码如下:

48 b8 88 77 66 55 44 33 22 11
49 bd 11 0 0 0 0 0 0 0
48 a1 88 77 66 55 44 33 22 11
4c 8b 35 11 0 0 0 0 0 0 0
66 ff 35 88 77 66 55
48 f7 5 88 77 66 55 0 0 0 0 0 0 0 0

复制代码

mik

荣誉版主

论坛徽章:: 0

8楼 [报告]

发表于 2006-04-10 16:28 |只看该作者

在x86-64 指令集中，比较难产生代码的指令是那么转移指令，例如：jmp 和 call之类的指令，难在由于x86指令是不定长的，jmp 和 call这些转移指令，最短2个字节，最长可达8-10个字节。这有点类似：鸡与鸡蛋的关系！所以难度可想而之！
我在a64编译器产品的处理上，用了我自认为是极为巧妙的方法实现，并没有用到什么特别的数据结构。
以下举几个例子，例中分别用了 a64, gnu assembler(gas) 以及 nasm 作为对比。它们的指令是一样的，只是表达的语法不同而已。

1、a64 源文件：

.bits 32
@label:
mov [ecx+0x0c], edx
mov eax, edx
@label2:
mov (dword)[ecx], 0x01
call @label1
jmp @label1
jmp @label
@label3:
mov eax,1
@label1: call @label

复制代码

2、gas 源文件：

label:
mov %edx, 0x0c(%ecx)
mov %edx, %eax
label2:
movl $0x01, (%ecx)
call label1
jmp label1
jmp label
label3:
mov $0x01, %eax
label1: call label

复制代码

3、nasm 源文件：

bits 32
label:
mov [ecx+0x0c], edx
mov eax, edx
label2:
mov dword[ecx], 0x01
call label1
jmp label1
jmp label
label3:
mov eax,1
label1: call label

复制代码

以下是编译生成的代码
1、 a64生成的：

89 51 c 89 d0 c7 1 1 0 0 0 e8 9 0 0 0 eb 7 eb ec b8 1 0 0 0 e8 e2 ff ff ff

复制代码

2、 gas 生成的：

00000000 <label>:
0: 89 51 0c mov %edx,0xc(%ecx)
3: 89 d0 mov %edx,%eax
00000005 <label2>:
5: c7 01 01 00 00 00 movl $0x1,(%ecx)
b: e8 09 00 00 00 call 19 <label1>
10: eb 07 jmp 19 <label1>
12: eb ec jmp 0 <label>
00000014 <label3>:
14: b8 01 00 00 00 mov $0x1,%eax
00000019 <label1>:
19: e8 e2 ff ff ff call 0 <label>

复制代码

3、 nasm 生成的：

00000000 89510C mov [ecx+0xc],edx
00000003 89D0 mov eax,edx
00000005 C70101000000 mov dword [ecx],0x1
0000000B E80C000000 call 0x1c
00000010 E907000000 jmp 0x1c
00000015 EBE9 jmp short 0x0
00000017 B801000000 mov eax,0x1
0000001C E8DFFFFFFF call 0x0

复制代码

a64 和 gnu as 生成的代码是一样的，而与nasm生成代码有些差异，但nasm的也是对的，
nasm在处理 jmp label1这条指令上用的是5个字节的指令。

a64 和 gas 产生的是2个字节的指令。在这方面 nasm 稍差一点。

下面，我们再来看几条更为复杂的转移指令形式的结果。
1、首先是a64源文件：

.bits 32
@label:
mov [ecx+0x0c], edx
mov eax, edx
@label2:
mov (dword)[ecx], 0x01
call @label1
jmp @label1
jmp @label3
@label3:
jmp @label3
call @label4
@label4:
call @label4
@label1: call @label

复制代码

2、来看看gas 的源文件

label:
mov %edx, 0x0c(%ecx)
mov %dex, %eax
label2:
movl $0x01, (%ecx)
call label1
jmp label1
jmp label3
label3:
jmp label3
call label4
label4:
call label4
label1: call label

复制代码

3、最后是nasm的源文件，基本上与 a64的语法一致，只是有一点点不同

bits 32
label:
mov [ecx+0x0c], edx
mov eax, edx
label2:
mov dword [ecx], 0x01
call label1
jmp label1
jmp label3
label3:
jmp label3
call label4
label4:
call label4
label1: call label

复制代码

以上示例代码中，有7条转移指令，相互交错在一起。看一看结果

1、 a64产生的结果

89 51 c 89 d0 c7 1 1 0 0 0 e8 10 0 0 0 eb e eb 0 eb fe e8 0 0 0 0 e8 fb ff ff ff e8 db ff ff ff

复制代码

2、 gas生产的结果子（objdump 出来的）

00000000 <label>:
0: 89 51 0c mov %edx,0xc(%ecx)
3: 89 d0 mov %edx,%eax
00000005 <label2>:
5: c7 01 01 00 00 00 movl $0x1,(%ecx)
b: e8 10 00 00 00 call 20 <label1>
10: eb 0e jmp 20 <label1>
12: eb 00 jmp 14 <label3>
00000014 <label3>:
14: eb fe jmp 14 <label3>
16: e8 00 00 00 00 call 1b <label4>
0000001b <label4>:
1b: e8 fb ff ff ff call 1b <label4>
00000020 <label1>:
20: e8 db ff ff ff call 0 <label>

复制代码

3、 nasm产生的结果 (用nasm自带的ndisasm )

00000000 89510C mov [ecx+0xc],edx
00000003 89D0 mov eax,edx
00000005 C70101000000 mov dword [ecx],0x1
0000000B E816000000 call 0x26
00000010 E911000000 jmp 0x26
00000015 E900000000 jmp 0x1a
0000001A EBFE jmp short 0x1a
0000001C E800000000 call 0x21
00000021 E8FBFFFFFF call 0x21
00000026 E8D5FFFFFF call 0x0

复制代码

总结：a64与gas的结果是一样的，nasm的稍有不同， nasm用了5个字节来产生jmp指令，nasm的代码稍为差一些。

对比 a64 、gas 与代码
1、 a64文件

!------------------------------------------
! unsigned int str_len(const char *s)
!
! return value:
! unsigned int: the length of strings
!-----------------------------------------
.bits 32
!.global str_len
@str_len:
xor eax, eax
mov edx, [esp+4]
@loop:
mov bl, [edx]
inc eax
inc edx
test bl,bl
jnz @loop
dec eax
ret
!-------------------------------------
! char get_char(const char *s)
!
! return value:
! char: get char of string[ith]
!--------------------------------------
!.global get_char
@get_char:
mov edx, [esp+4]
mov ecx,[esp+8]
@loop1:
mov al,[edx]
test al, al
jz @out
inc edx
dec ecx
test ecx, ecx
jnz @loop1
@out:
ret
!----------------------------------
! int str_ch(const char *d, char c)
!
! return: 0: no found
! value: found & postion;
!---------------------------
!.global str_ch
@str_ch:
xor eax, eax
mov edx,[esp+4]
mov ecx,[esp+8]
@loop2:
inc eax
mov bl, [edx]
test bl, bl
jz @out1
inc edx
cmp cl, bl
jnz @loop2
jmp @out2
@out1:
xor eax, eax
@out2:
ret
!--------------------------------------------------------------
! unsigned int str_str(const char *dest, const char* source)
!
! reture value:
! 0: no found
! unsigned int: found & get postion
!--------------------------------------------------------------
!.global str_str
@str_str:
mov edi, [esp+4]
mov esi, [esp+8]
sub esp, 8
mov [esp+4], edi
mov [esp], esi
mov eax, 1
@loop3:
mov ebx, esi
mov edx, edi
inc esi
inc edi
mov cl, [ebx]
!-----------
! found & no found
test cl,cl
jz @result
cmp (byte)[edx], 0
jz @no
!-----------
cmp cl, [edx]
jz @loop3
@yes:
inc (dword)[esp+4]
mov edi, [esp+4]
mov esi, [esp]
inc eax
jmp @loop3
@no:
xor eax, eax
@result:
add esp, 8
ret
!----------------------------
! ungisgned get_c_sum(char *s, char c)
!
! return char c sum in string s
!
!------------------------------------
!.global get_c_sum
@get_c_sum:
mov edx, [esp+4]
mov bl, [esp+8]
xor eax, eax
test edx, edx
jz @out_get_c
@loop_get_c:
inc edx
mov cl, [edx-1]
test cl, cl
jz @out_get_c
cmp cl, bl
jnz @loop_get_c
inc eax
jmp @loop_get_c
@out_get_c:
ret
!
!--------------------------
!.global get_pc
@get_pc:
call @next
@next: pop eax
ret
!-----------------------------------------
!.global dump_banry
@dump_banry:
push ebp
mov ebp, esp
mov edx, [ebp+8]
mov al, [ebp+12]
mov ecx, 9
@loop5:
dec ecx
jz @out5
shl al, 1
jc @one
@zero:
mov (byte)[edx], 48
inc edx
jmp @loop5
@one:
mov (byte)[edx], 49
inc edx
jmp @loop5
@out5:
pop ebp
ret

复制代码

结果：用以下命令：a64 –print-encode test.s –o test

31 c0 8b 54 24 4 8a 1a 40 42 84 db 75 f8 48 c3 8b 54 24 4 8b 4c 24 8 8a 2 84 c0 74 6 42 49 85 c9 75 f4 c3 31 c0 8b 54 24 4 8b 4c 24 8 40 8a 1a 84 db 74 7 42 38 d9 75 f4 eb 2 31 c0 c3 8b 7c 24 4 8b 74 24 8 83 ec 8 89 7c 24 4 89 34 24 b8 1 0 0 0 89 f3 89 fa 46 47 8a b 84 c9 74 19 80 3a 0 74 12 3a a 74 eb ff 44 24 4 8b 7c 24 4 8b 34 24 40 eb dd 31 c0 83 c4 8 c3 8b 54 24 4 8a 5c 24 8 31 c0 85 d2 74 f 42 8a 4a ff 84 c9 74 7 38 d9 75 f4 40 eb f1 c3 e8 0 0 0 0 58 c3 55 89 e5 8b 55 8 8a 45 c b9 9 0 0 0 49 74 10 d0 e0 72 6 c6 2 30 42 eb f3 c6 2 31 42 eb ed 5d c3

复制代码

2、 gas 的结果：

string.o: file format elf32-i386
Disassembly of section .text:
00000000 <str_len>:
0: 31 c0 xor %eax,%eax
2: 8b 54 24 04 mov 0x4(%esp),%edx
00000006 <loop>:
6: 8a 1a mov (%edx),%bl
8: 40 inc %eax
9: 42 inc %edx
a: 84 db test %bl,%bl
c: 75 f8 jne 6 <loop>
e: 48 dec %eax
f: c3 ret
00000010 <get_char>:
10: 8b 54 24 04 mov 0x4(%esp),%edx
14: 8b 4c 24 08 mov 0x8(%esp),%ecx
00000018 <loop1>:
18: 8a 02 mov (%edx),%al
1a: 84 c0 test %al,%al
1c: 74 06 je 24 <out>
1e: 42 inc %edx
1f: 49 dec %ecx
20: 85 c9 test %ecx,%ecx
22: 75 f4 jne 18 <loop1>
00000024 <out>:
24: c3 ret
00000025 <str_ch>:
25: 31 c0 xor %eax,%eax
27: 8b 54 24 04 mov 0x4(%esp),%edx
2b: 8b 4c 24 08 mov 0x8(%esp),%ecx
0000002f <loop2>:
2f: 40 inc %eax
30: 8a 1a mov (%edx),%bl
32: 84 db test %bl,%bl
34: 74 07 je 3d <out1>
36: 42 inc %edx
37: 38 d9 cmp %bl,%cl
39: 75 f4 jne 2f <loop2>
3b: eb 02 jmp 3f <out2>
0000003d <out1>:
3d: 31 c0 xor %eax,%eax
0000003f <out2>:
3f: c3 ret
00000040 <str_str>:
40: 8b 7c 24 04 mov 0x4(%esp),%edi
44: 8b 74 24 08 mov 0x8(%esp),%esi
48: 83 ec 08 sub $0x8,%esp
4b: 89 7c 24 04 mov %edi,0x4(%esp)
4f: 89 34 24 mov %esi,(%esp)
52: b8 01 00 00 00 mov $0x1,%eax
00000057 <loop3>:
57: 89 f3 mov %esi,%ebx
59: 89 fa mov %edi,%edx
5b: 46 inc %esi
5c: 47 inc %edi
5d: 8a 0b mov (%ebx),%cl
5f: 84 c9 test %cl,%cl
61: 74 19 je 7c <result>
63: 80 3a 00 cmpb $0x0,(%edx)
66: 74 12 je 7a <no>
68: 3a 0a cmp (%edx),%cl
6a: 74 eb je 57 <loop3>
0000006c <yes>:
6c: ff 44 24 04 incl 0x4(%esp)
70: 8b 7c 24 04 mov 0x4(%esp),%edi
74: 8b 34 24 mov (%esp),%esi
77: 40 inc %eax
78: eb dd jmp 57 <loop3>
0000007a <no>:
7a: 31 c0 xor %eax,%eax
0000007c <result>:
7c: 83 c4 08 add $0x8,%esp
7f: c3 ret
00000080 <get_c_sum>:
80: 8b 54 24 04 mov 0x4(%esp),%edx
84: 8a 5c 24 08 mov 0x8(%esp),%bl
88: 31 c0 xor %eax,%eax
8a: 85 d2 test %edx,%edx
8c: 74 0f je 9d <out_get_c>
0000008e <loop_get_c>:
8e: 42 inc %edx
8f: 8a 4a ff mov 0xffffffff(%edx),%cl
92: 84 c9 test %cl,%cl
94: 74 07 je 9d <out_get_c>
96: 38 d9 cmp %bl,%cl
98: 75 f4 jne 8e <loop_get_c>
9a: 40 inc %eax
9b: eb f1 jmp 8e <loop_get_c>
0000009d <out_get_c>:
9d: c3 ret
0000009e <get_pc>:
9e: e8 00 00 00 00 call a3 <next>
000000a3 <next>:
a3: 58 pop %eax
a4: c3 ret
000000a5 <dump_banry>:
a5: 55 push %ebp
a6: 89 e5 mov %esp,%ebp
a8: 8b 55 08 mov 0x8(%ebp),%edx
ab: 8a 45 0c mov 0xc(%ebp),%al
ae: b9 09 00 00 00 mov $0x9,%ecx
000000b3 <loop5>:
b3: 49 dec %ecx
b4: 74 10 je c6 <out5>
b6: d0 e0 shl %al
b8: 72 06 jb c0 <one>
000000ba <zero>:
ba: c6 02 30 movb $0x30,(%edx)
bd: 42 inc %edx
be: eb f3 jmp b3 <loop5>
000000c0 <one>:
c0: c6 02 31 movb $0x31,(%edx)
c3: 42 inc %edx
c4: eb ed jmp b3 <loop5>
000000c6 <out5>:
c6: 5d pop %ebp
c7: c3 ret

复制代码

mik

荣誉版主

论坛徽章:: 0

9楼 [报告]

发表于 2006-04-10 16:33 |只看该作者

以上是我写的一些关于 a64 编译器的文档, 不完整, 因为没时间去写!!

希望,各位版友来测一测, 虽然,我自己已经发觉了不少 BUG 但因为没时间,所以都还没有改正!

各位测试后,把你们认为是错误的,都可以回复此贴, 我会尽量回复你们,

我修正这些错误是非常简单而容易的, 我只要修改一下指令语法表即可!!!

本来, 我还想定一个 dump 之类的反编译软件, 因为实现它,也并不是很难!!!!

不过,本身a64还没完善,所以就没写了.... 等有时间了,再搞掂!!!

win_hate

荣誉版主

论坛徽章:: 0

10楼 [报告]

发表于 2006-04-10 18:17 |只看该作者

呵呵，这个要支持。

12 3 / 3 页下一页

返回列表

Chinaunix › 论坛 › 程序设计 › C/C++ › 测试 a64 汇编语言汇编译器