在完成了
这里和
这里的工作之后，就可以写程序生成机器码了。在生成机器码的时候有如下注意事项：
1：可执行代码所在的空间必须使用VirtualAlloc与PAGE_EXECUTE_READWRITE标记分配。
2：程序需要的常量空间、全局变量空间和指令空间需要分开在三个不同的地方。
下面的例子使用一个struct保存指令的每一个部分，并且结合之前产生的指令译码表生成二进制码。
1 #include "..\..\..\..\VL++\Library\Platform\VL_Console.h"
2 #include "..\..\..\..\VL++\Library\Script\JIT\Assembler\VL_JIT_X86Generator.h"
3 #include <windows.h>
4
5 using namespace vl;
6 using namespace vl::platform;
7 using namespace vl::jit::x86;
8 using namespace vl::jit::assembly;
9
10 extern void Main_Generator();
11
12 #define GET_LABEL(NAME,VARIABLE) \
13 { \
14 VARIABLE=Program.LabelNames.IndexOf(L#NAME); \
15 if(VARIABLE==-1) \
16 { \
17 VARIABLE=Program.LabelNames.GetCount(); \
18 Program.LabelNames.Add(L#NAME); \
19 Program.Labels.Add(-1); \
20 } \
21 }
22
23 #define INSTRUCTION(NAME) \
24 { \
25 VL_AsmIns Ins; \
26 Ins.Name=L#NAME; \
27 Ins.ParameterCount=0; \
28 Program.Instructions.Add(Ins); \
29 }
30 #define LABEL(NAME) \
31 { \
32 VInt LabelIndex=0; \
33 GET_LABEL(NAME,LabelIndex); \
34 VInt InsIndex=Program.Instructions.GetCount(); \
35 Program.Labels[LabelIndex]=InsIndex; \
36 }
37 #define PARAM_IMM_32(IMMEDIATE) \
38 { \
39 VInt Index=Program.Instructions.GetCount()-1; \
40 VL_AsmIns& Ins=Program.Instructions[Index]; \
41 VInt PRMIDX=Ins.ParameterCount++; \
42 Ins.Parameters[PRMIDX].ParameterKind=vapkSigned; \
43 Ins.Parameters[PRMIDX].ParameterType=vaptInt32; \
44 Ins.Parameters[PRMIDX].Signed=IMMEDIATE; \
45 }
46 #define PARAM_REG_32(REGISTER) \
47 { \
48 VInt Index=Program.Instructions.GetCount()-1; \
49 VL_AsmIns& Ins=Program.Instructions[Index]; \
50 VInt PRMIDX=Ins.ParameterCount++; \
51 Ins.Parameters[PRMIDX].ParameterKind=vapkRegister; \
52 Ins.Parameters[PRMIDX].ParameterType=vaptInt32; \
53 Ins.Parameters[PRMIDX].Register=var##REGISTER; \
54 }
55 #define PARAM_MI_32(INDEX,SCALE,BASE,OFFSET) \
56 { \
57 VInt Index=Program.Instructions.GetCount()-1; \
58 VL_AsmIns& Ins=Program.Instructions[Index]; \
59 VInt PRMIDX=Ins.ParameterCount++; \
60 Ins.Parameters[PRMIDX].ParameterKind=vapkPointer; \
61 Ins.Parameters[PRMIDX].ParameterType=vaptInt32; \
62 Ins.Parameters[PRMIDX].Base=var##BASE; \
63 Ins.Parameters[PRMIDX].Index=var##INDEX; \
64 Ins.Parameters[PRMIDX].Scale=vas##SCALE; \
65 Ins.Parameters[PRMIDX].Offset=OFFSET; \
66 }
67 #define PARAM_LABEL(NAME) \
68 { \
69 VInt Index=Program.Instructions.GetCount()-1; \
70 VInt Label=0; \
71 GET_LABEL(NAME,Label); \
72 VL_AsmIns& Ins=Program.Instructions[Index]; \
73 VInt PRMIDX=Ins.ParameterCount++; \
74 Ins.Parameters[PRMIDX].ParameterKind=vapkLabel; \
75 Ins.Parameters[PRMIDX].ParameterType=vaptInt32; \
76 Ins.Parameters[PRMIDX].Label=Label; \
77 }
78
79 VL_AsmCompiled* Compile()
80 {
81 VL_AsmProgram Program;
82 {
83 // XOR EAX, EAX
84 INSTRUCTION(XOR)
85 PARAM_REG_32(EAX)
86 PARAM_REG_32(EAX)
87 // MOV ECX, [EDI]
88 INSTRUCTION(MOV)
89 PARAM_REG_32(ECX)
90 PARAM_MI_32(NONE,1,EDI,0)
91 // @BEGIN:
92 LABEL(BEGIN)
93 // CMP ECX, 0
94 INSTRUCTION(CMP)
95 PARAM_REG_32(ECX)
96 PARAM_IMM_32(0)
97 // JE @END
98 INSTRUCTION(JE)
99 PARAM_LABEL(END)
100 // ADD EAX, [ECX * 4 + EDI]
101 INSTRUCTION(ADD)
102 PARAM_REG_32(EAX)
103 PARAM_MI_32(ECX,4,EDI,0)
104 // SUB ECX, 1
105 INSTRUCTION(SUB)
106 PARAM_REG_32(ECX)
107 PARAM_IMM_32(1)
108 // JMP @BEGIN
109 INSTRUCTION(JMP)
110 PARAM_LABEL(BEGIN)
111 // @END:
112 LABEL(END)
113 // RET
114 INSTRUCTION(RET)
115 }
116 VL_AsmCompiled* Compiled=Compile(&Program);
117 if(Compiled->Errors.GetCount())
118 {
119 for(VInt i=0;i<Compiled->Errors.GetCount();i++)
120 {
121 VL_AsmError& Error=Compiled->Errors[i];
122 GetConsole()->Write(L"["+VUnicodeString(Error.Index)+L"]"+Error.Message+L"\r\n");
123 }
124 delete Compiled;
125 return 0;
126 }
127 else
128 {
129 return Compiled;
130 }
131 }
132
133 void vlmain()
134 {
135 GetConsole()->SetTitle(L"Vczh Library++ 2.0 Assembler");
136 GetConsole()->SetTestMemoryLeaks(true);
137 GetConsole()->SetPauseOnExit(true);
138
139 VL_AsmCompiled* Compiled=Compile();
140 if(Compiled)
141 {
142 VInt Size=(VInt)Compiled->InstructionBuffer.Size();
143 void* Buffer=VirtualAlloc(0,Size,MEM_COMMIT,PAGE_EXECUTE_READWRITE);
144 Compiled->InstructionBuffer.SeekFromBegin(0);
145 Compiled->InstructionBuffer.Read(Buffer,Size);
146
147 VInt Params[]={10,1,2,3,4,5,6,7,8,9,10};
148 VInt* Input=Params;
149 VInt Output=0;
150 __asm
151 {
152 PUSH EAX
153 PUSH EBX
154 PUSH ECX
155 PUSH EDX
156 PUSH ESI
157 PUSH EDI
158 MOV EAX, dword ptr[Buffer]
159 MOV EDI, dword ptr[Input]
160 INT 3
161 CALL EAX
162 MOV dword ptr[Output], EAX
163 POP EDI
164 POP ESI
165 POP EDX
166 POP ECX
167 POP EBX
168 POP EAX
169 }
170 VirtualFree(Buffer,Size,MEM_RELEASE);
171 GetConsole()->Write(L"结果：EAX="+VUnicodeString(Output)+L"\r\n");
172 delete Compiled;
173 }
174 }
注意，VL_AsmCompiled* Compile()函数使用的宏用于简化汇编的编码（以后将写一个分析器将字符串的汇编转换成这些struct）。EDI指向11个32位整数（见下文对vlmain函数的说明）。程序首先将EDI[0]存放在ECX，此时ECX是10。然后执行一个循环让EAX=EDI[10]+EDI[9]+...+EDI[2]+EDI[1]，然后ECX变成0，退出。
vlmain函数中的汇编首先将存放着指令的Buffer放入EAX，然后将Params数组的指针放入EDI，然后执行函数（INT 3用于在Visual Studio中产生断点）。汇编将结果保存在了EAX中，因此将EAX的结果村放入Output变量。最后输出。
下面是两张调试的贴图。使用Visual Studio的反汇编功能可以检查汇编器是否正确：
首先，程序运行到INT 3的时候会产生调试中断，这个时候使用Visual Studio捕获：
按CTRL+ALT+D进入汇编窗口以便跟踪（代码窗口不能单步进CALL）：
执行到CALL EAX的时候按F11进入我们写程序生成的代码：
这里我们可以看到，程序产生的结果是正确的。于是CPU将顺利执行这段代码，最后将EAX变为55：
到这里就结束了。以下是汇编器的源代码的核心部分。首先是结构的声明：
1 /*******************************************************************************
2 Vczh Library++ 2.0
3 JIT::x86汇编数据结构
4 开发者：陈梓瀚
5
6 接口：
7 类：
8 函数：
9 *******************************************************************************/
10 #ifndef VL_JIT_ASSEMBLY
11 #define VL_JIT_ASSEMBLY
12
13 #include "..\..\..\Data\Data\VL_Data_Basic.h"
14 #include "..\..\..\Data\Data\VL_Data_String.h"
15 #include "..\..\..\Data\Data\VL_Data_List.h"
16 #include "..\..\..\Data\Data\VL_Data_Map.h"
17 #include "..\..\..\Data\VL_Stream.h"
18
19 namespace vl
20 {
21 namespace jit
22 {
23 namespace assembly
24 {
25 using namespace collection;
26 using namespace stream;
27
28 enum VLE_AsmParameterKind
29 {
30 vapkRegister, /*寄存器*/
31 vapkPointer, /*指针*/
32 vapkSigned, /*有符号数字*/
33 vapkUnsigned, /*无符号数字*/
34 vapkRelative, /*相对指针*/
35 vapkLabel /*Label指定的Relative指针常数*/
36 };
37
38 enum VLE_AsmParameterType
39 {
40 vaptInt8,
41 vaptInt16,
42 vaptInt32,
43 vaptFp32,
44 vaptFp64,
45 vaptFpReg
46 };
47
48 /*分段保持顺序*/
49 enum VLE_AsmRegister
50 {
51 varAL,
52 varAH,
53 varBL,
54 varBH,
55 varCL,
56 varCH,
57 varDL,
58 varDH,
59
60 varAX,
61 varBX,
62 varCX,
63 varDX,
64 varSP,
65 varBP,
66 varSI,
67 varDI,
68
69 varEAX,
70 varEBX,
71 varECX,
72 varEDX,
73 varESP,
74 varEBP,
75 varESI,
76 varEDI,
77
78 varST0,
79 varST1,
80 varST2,
81 varST3,
82 varST4,
83 varST5,
84 varST6,
85 varST7,
86
87 varNONE
88 };
89
90 /*保持顺序*/
91 enum VLE_AsmScale
92 {
93 vas1,
94 vas2,
95 vas4,
96 vas8
97 };
98
99 enum VLE_AsmErrorCode
100 {
101 vaecUnrecognizedName, /*不能识别的指令名称*/
102 vaecWrongParameterCount, /*错误的参数数量*/
103 vaecUnrecognizedKind, /*不能识别的参数样式*/
104 vaecUnrecognizedType, /*不能识别的参数类型*/
105
106 vaecLostRegister, /*寄存器为NONE*/
107 vaecWrongRegisterType, /*寄存器与参数值类型不匹配*/
108 vaecUnrecognizedRegister, /*无法识别的寄存器值*/
109
110 vaecLabelMustBeInt32, /*Label的类型必须是32位整数*/
111 vaecUnrecognizedLabel, /*无法识别的Label值*/
112
113 vaecIndexRegisterMustBe32Bits, /*Index寄存器必须是32位*/
114 vaecBaseRegisterMustBe32Bits, /*Base寄存器必须是32位*/
115 vaecUnrecognizedScale, /*无法识别的Scale值*/
116
117 vaecSignedMustBeInteger, /*有符号整数的类型必须是整数*/
118 vaecUnsignedMustBeInteger, /*无符号整数的类型必须是整数*/
119 vaecRelativeMustBeInteger, /*相对地址必须是整数类型*/
120 vaecSignedOutOfRange, /*有符号整数超过类型描述的范围*/
121 vaecUnsignedOutOfRange, /*无符号整数超过类型描述的范围*/
122
123 vaecUnrecognizedLinkingID, /*【】无法识别的链接ID*/
124 vaecParameterNotMatched, /*参数无法匹配指令的要求*/
125 vaecDoNotKnowHowToCompile /*不知道如何编译*/
126 };
127
128 struct VL_AsmError
129 {
130 VLE_AsmErrorCode ErrorCode;
131 VInt Index;
132 VUnicodeString Message;
133 };
134
135 struct VL_AsmParameter
136 {
137 VLE_AsmParameterKind ParameterKind; /*参数样式，决定Union哪些可用*/
138 VLE_AsmParameterType ParameterType; /*参数数值类型*/
139 struct
140 {
141 VInt LinkingID; /*链接数值ID*/
142 VInt LinkingOffset; /*链接数值偏移*/
143 VBool Enabled; /*是否允许链接，参数类型不接受链接则忽略*/
144 } Linking;
145 union
146 {
147 VInt32s Signed; /*vapkSigned、vapkRelative有效，Linking.Enable为true则使用Linking*/
148 VInt32u Unsigned; /*vapkUnsigned有效，Linking.Enable为true则使用Linking*/
149 VInt Label; /*vapkLabel有效*/
150 VLE_AsmRegister Register; /*寄存器*/
151 struct
152 {
153 VLE_AsmRegister Index; /*底数寄存器，为varNONE则忽略Index*Scale*/
154 VLE_AsmScale Scale; /*指数*/
155 VLE_AsmRegister Base; /*偏移寄存器，为varNONE则忽略Base*/
156 VInt Offset; /*常数偏移，Linking.Enable为true则使用Linking*/
157 };
158 };
159
160 VL_AsmParameter();
161 };
162
163 struct VL_AsmIns
164 {
165 VUnicodeString Name; /*指令名字*/
166 VInt ParameterCount; /*有效参数数量*/
167 VL_AsmParameter Parameters[4]; /*参数*/
168 };
169
170 struct VL_AsmProgram
171 {
172 typedef VL_List<VInt , true> _LabelMap;
173 typedef VL_List<VL_AsmIns , false> _InsList;
174 typedef VL_List<VUnicodeString , false> _LabelList;
175
176 static const VInt CONSTANT_BUFFER_POINTER=0; /*LinkingID：常数缓冲区指针*/
177
178 VL_MemoryStream ConstantBuffer; /*常数缓冲区*/
179 _LabelMap Labels; /*ID -> Instruction*/
180 _InsList Instructions; /*指令表*/
181 _LabelList LabelNames; /*ID -> Name*/
182
183 VL_AsmProgram();
184 };
185
186 struct VL_AsmCompiled
187 {
188 typedef VL_List<VL_AsmError , false> _ErrorList;
189
190 _ErrorList Errors;
191 VL_MemoryStream ConstantBuffer;
192 VL_MemoryStream InstructionBuffer;
193 VL_MemoryStream LinkingBuffer;
194
195 VL_AsmCompiled();
196 };
197 }
198 }
199 }
200
201 #endif
其次是产生二进制码的程序：
1 #include "VL_JIT_X86Generator.h"
2 #include "VL_JIT_X86.h"
3
4 namespace vl
5 {
6 namespace jit
7 {
8 namespace x86
9 {
10 void CopyStream(IVL_Stream* In , IVL_Stream* Out)
11 {
12 VByte Buffer[65536];
13 VInt Count=0;
14 In->SeekFromBegin(0);
15 Out->SeekFromBegin(0);
16 while(Count=In->Read(Buffer,sizeof(Buffer)))
17 {
18 Out->Write(Buffer,Count);
19 }
20 In->SeekFromBegin(0);
21 Out->SeekFromBegin(0);
22 }
23
24 VBool CheckParameter(VLE_InsParam Template , VL_AsmParameter& Assembly)
25 {
26 switch(Template)
27 {
28 case vipREL_8: return Assembly.ParameterKind==vapkRelative && Assembly.ParameterType==vaptInt8;
29 case vipREL_16: return Assembly.ParameterKind==vapkRelative && Assembly.ParameterType==vaptInt16;
30 case vipREL_32: return (Assembly.ParameterKind==vapkRelative && Assembly.ParameterType==vaptInt32) || Assembly.ParameterKind==vapkLabel;
31 case vipPTR_16_16: return Assembly.ParameterKind==vapkUnsigned && Assembly.ParameterType==vaptInt32;
32 case vipPTR_16_32: return false;
33 case vipREG_8: return Assembly.ParameterKind==vapkRegister && Assembly.ParameterType==vaptInt8;
34 case vipREG_16: return Assembly.ParameterKind==vapkRegister && Assembly.ParameterType==vaptInt16;
35 case vipREG_32: return Assembly.ParameterKind==vapkRegister && Assembly.ParameterType==vaptInt32;
36 case vipIMM_8: return (Assembly.ParameterKind==vapkSigned || Assembly.ParameterKind==vapkUnsigned) && Assembly.ParameterType==vaptInt8;
37 case vipIMM_16: return (Assembly.ParameterKind==vapkSigned || Assembly.ParameterKind==vapkUnsigned) && Assembly.ParameterType==vaptInt16;
38 case vipIMM_32: return (Assembly.ParameterKind==vapkSigned || Assembly.ParameterKind==vapkUnsigned) && Assembly.ParameterType==vaptInt32;
39 case vipRM_8: return (Assembly.ParameterKind==vapkRegister || Assembly.ParameterKind==vapkPointer) && Assembly.ParameterType==vaptInt8;
40 case vipRM_16: return (Assembly.ParameterKind==vapkRegister || Assembly.ParameterKind==vapkPointer) && Assembly.ParameterType==vaptInt16;
41 case vipRM_32: return (Assembly.ParameterKind==vapkRegister || Assembly.ParameterKind==vapkPointer) && Assembly.ParameterType==vaptInt32;
42 case vipM_16_16: return false;
43 case vipM_16_32: return false;
44 case vipM_16_AND_16: return false;
45 case vipM_16_AND_32: return false;
46 case vipM_32_AND_32: return false;
47 case vipMI_16: return Assembly.ParameterKind==vapkPointer && Assembly.ParameterType==vaptInt16;
48 case vipMI_32: return Assembly.ParameterKind==vapkPointer && Assembly.ParameterType==vaptInt32;
49 case vipMI_64: return false;
50 case vipMF_32: return Assembly.ParameterKind==vapkPointer && Assembly.ParameterType==vaptFp32;
51 case vipMF_64: return Assembly.ParameterKind==vapkPointer && Assembly.ParameterType==vaptFp64;
52 case vipMF_80: return false;
53 case vipSREG: return false;
54 case vipST_0: return Assembly.ParameterKind==vapkRegister && Assembly.Register==varST0;
55 case vipST_I: return Assembly.ParameterKind==vapkRegister && (Assembly.Register>=varST0 && Assembly.Register<=varST7);
56 case vipAL: return Assembly.ParameterKind==vapkRegister && Assembly.Register==varAL;
57 case vipAX: return Assembly.ParameterKind==vapkRegister && Assembly.Register==varAX;
58 case vipEAX: return Assembly.ParameterKind==vapkRegister && Assembly.Register==varEAX;
59 case vipCL: return Assembly.ParameterKind==vapkRegister && Assembly.Register==varCL;
60 case vipCX: return Assembly.ParameterKind==vapkRegister && Assembly.Register==varCX;
61 case vipECX: return Assembly.ParameterKind==vapkRegister && Assembly.Register==varECX;
62 case vipCS: return false;
63 case vipDS: return false;
64 case vipES: return false;
65 case vipFS: return false;
66 case vipGS: return false;
67 case vipSS: return false;
68 case vipCONST_1: return Assembly.ParameterKind==vapkUnsigned && Assembly.Linking.Enabled==false && Assembly.Unsigned==1;
69 case vipCONST_3: return Assembly.ParameterKind==vapkUnsigned && Assembly.Linking.Enabled==false && Assembly.Unsigned==3;
70 default: return false;
71 }
72 }
73 /*
74 VInt Selected=-1;
75 for(VInt i=0;i<4;i++)
76 {
77 switch(Format.Params[i])
78 {
79 case vipREL_8:
80 case vipREL_16:
81 case vipREL_32:
82 case vipPTR_16_16:
83 case vipPTR_16_32:
84 case vipREG_8:
85 case vipREG_16:
86 case vipREG_32:
87 case vipIMM_8:
88 case vipIMM_16:
89 case vipIMM_32:
90 case vipRM_8:
91 case vipRM_16:
92 case vipRM_32:
93 case vipM_16_16:
94 case vipM_16_32:
95 case vipM_16_AND_16:
96 case vipM_16_AND_32:
97 case vipM_32_AND_32:
98 case vipMI_16:
99 case vipMI_32:
100 case vipMI_64:
101 case vipMF_32:
102 case vipMF_64:
103 case vipMF_80:
104 case vipSREG:
105 case vipST_0:
106 case vipST_I:
107 case vipAL:
108 case vipAX:
109 case vipEAX:
110 case vipCL:
111 case vipCX:
112 case vipECX:
113 case vipCS:
114 case vipDS:
115 case vipES:
116 case vipFS:
117 case vipGS:
118 case vipSS:
119 case vipCONST_1:
120 case vipCONST_3:
121 if(!Used[i])
122 {
123 Selected=i;
124 Used[i]=true;
125 }
126 }
127 }
128 return Selected;
129 */
130
131 VInt FindRI(VLS_InsFormat& Format , VBool* Used)
132 {
133 VInt Selected=-1;
134 for(VInt i=0;i<4;i++)
135 {
136 switch(Format.Params[i])
137 {
138 case vipREG_8:
139 case vipREG_16:
140 case vipREG_32:
141 case vipAL:
142 case vipAX:
143 case vipEAX:
144 case vipCL:
145 case vipCX:
146 case vipECX:
147 if(!Used[i])
148 {
149 Selected=i;
150 Used[i]=true;
151 }
152 }
153 }
154 return Selected;
155 }
156
157 VInt FindRM(VLS_InsFormat& Format , VBool* Used)
158 {
159 VInt Selected=-1;
160 for(VInt i=0;i<4;i++)
161 {
162 switch(Format.Params[i])
163 {
164 case vipPTR_16_16:
165 case vipPTR_16_32:
166 case vipRM_8:
167 case vipRM_16:
168 case vipRM_32:
169 case vipM_16_16:
170 case vipM_16_32:
171 case vipM_16_AND_16:
172 case vipM_16_AND_32:
173 case vipM_32_AND_32:
174 case vipMI_16:
175 case vipMI_32:
176 case vipMI_64:
177 case vipMF_32:
178 case vipMF_64:
179 case vipMF_80:
180 if(!Used[i])
181 {
182 Selected=i;
183 Used[i]=true;
184 }
185 }
186 }
187 return Selected;
188 }
189
190 VInt FindRF(VLS_InsFormat& Format , VBool* Used)
191 {
192 VInt Selected=-1;
193 for(VInt i=0;i<4;i++)
194 {
195 switch(Format.Params[i])
196 {
197 case vipST_I:
198 if(!Used[i])
199 {
200 Selected=i;
201 Used[i]=true;
202 }
203 }
204 }
205 return Selected;
206 }
207
208 VInt FindIMM(VLS_InsFormat& Format , VBool* Used)
209 {
210 VInt Selected=-1;
211 for(VInt i=0;i<4;i++)
212 {
213 switch(Format.Params[i])
214 {
215 case vipREL_8:
216 case vipREL_16:
217 case vipREL_32:
218 case vipPTR_16_16:
219 case vipPTR_16_32:
220 case vipIMM_8:
221 case vipIMM_16:
222 case vipIMM_32:
223 if(!Used[i])
224 {
225 Selected=i;
226 Used[i]=true;
227 }
228 }
229 }
230 return Selected;
231 }
232
233 VInt RegisterToExt(VLE_AsmRegister Register)
234 {
235 switch(Register)
236 {
237 case varAL:case varAX:case varEAX:case varST0:
238 return 0;
239 case varCL:case varCX:case varECX:case varST1:
240 return 1;
241 case varDL:case varDX:case varEDX:case varST2:
242 return 2;
243 case varBL:case varBX:case varEBX:case varST3:
244 return 3;
245 case varAH:case varSP:case varESP:case varST4:
246 return 4;
247 case varCH:case varBP:case varEBP:case varST5:
248 return 5;
249 case varDH:case varSI:case varESI:case varST6:
250 return 6;
251 case varBH:case varDI:case varEDI:case varST7:
252 return 7;
253 default:
254 return -1;
255 }
256 }
257
258 VByte RegisterToID(VLE_AsmRegister Register)
259 {
260 return (VByte)RegisterToExt(Register);
261 }
262
263 const VByte SIB_Scales[]={0,1,2,3};
264 VByte ScaleToSIB(VLE_AsmScale Scale)
265 {
266 return SIB_Scales[Scale]<<6;
267 }
268
269 VByte IndexToSIB(VLE_AsmRegister Register)
270 {
271 return (VByte)RegisterToExt(Register)<<3;
272 }
273
274 VByte BaseToSIB(VLE_AsmRegister Register)
275 {
276 return (VByte)RegisterToExt(Register);
277 }
278
279 //[Mod][Ext][R/M] [Scale][Index][Base]
280 VBool MakeModRMWithoutExt(VL_AsmParameter& Parameter , VByte& ModRM , VByte& SIB , VBool& EnableSIB , VBool& Displayment)
281 {
282 if(Parameter.ParameterKind==vapkRegister)
283 {
284 ModRM=0xC0 | RegisterToID(Parameter.Register);//11000XXX
285 SIB=0;
286 EnableSIB=false;
287 Displayment=false;
288 return true;
289 }
290 else
291 {
292 VBool DispZero=Parameter.Offset==0 && !Parameter.Linking.Enabled;
293 VLE_AsmRegister Index=Parameter.Index;
294 VLE_AsmRegister Base=Parameter.Base;
295 VLE_AsmScale Scale=Parameter.Scale;
296 if(Base==varNONE && Scale==vas1)
297 {
298 Base=Index;
299 Index=varNONE;
300 }
301
302 if(Base==varNONE && Index==varNONE)//disp32
303 {
304 ModRM=0x05;//00000101
305 SIB=0;
306 EnableSIB=false;
307 Displayment=false;
308 return true;
309 }
310 if(Base!=varNONE && Index==varNONE && DispZero)//[REG]
311 {
312 VByte ID=RegisterToID(Base);
313 if(ID==4)//[ESP]
314 {
315 ModRM=0x04;//00000100
316 SIB=0x24;//00100100
317 EnableSIB=true;
318 Displayment=true;
319 return true;
320 }
321 else if(ID==5)//[EBP]
322 {
323 ModRM=0x85;//10000101
324 SIB=0;
325 EnableSIB=false;
326 Displayment=true;
327 return true;
328 }
329 else
330 {
331 ModRM=0x00 | ID;//00000XXX
332 SIB=0;
333 EnableSIB=false;
334 Displayment=false;
335 return true;
336 }
337 }
338 if(Base!=varNONE && Index==varNONE && !DispZero)//[REG + disp32]
339 {
340 VByte ID=RegisterToID(Base);
341 if(ID==4)//[ESP + disp32]
342 {
343 ModRM=0x84;//10000100
344 SIB=0x24;//00100100
345 EnableSIB=true;
346 Displayment=true;
347 return true;
348 }
349 else
350 {
351 ModRM=0x80 | ID;//10000XXX
352 SIB=0;
353 EnableSIB=false;
354 Displayment=false;
355 return true;
356 }
357 }
358 if(Base==varNONE && Index!=varNONE && DispZero)//[REG * s]
359 {
360 ModRM=0x04;//00000100
361 SIB=ScaleToSIB(Scale) | IndexToSIB(Index) | BaseToSIB(varEBP);
362 EnableSIB=true;
363 Displayment=true;
364 return true;
365 }
366 if(Base!=varNONE && Index!=varNONE && DispZero)//[REG * s + REG]
367 {
368 if(Index==varESP)
369 return false;
370 if(Base==varEBP)
371 {
372 ModRM=0x84;//10000100
373 SIB=ScaleToSIB(Scale) | IndexToSIB(Index) | BaseToSIB(Base);
374 EnableSIB=true;
375 Displayment=true;
376 return true;
377 }
378 else
379 {
380 ModRM=0x04;//00000100
381 SIB=ScaleToSIB(Scale) | IndexToSIB(Index) | BaseToSIB(Base);
382 EnableSIB=true;
383 Displayment=false;
384 return true;
385 }
386 }
387 if(Base==varNONE && Index!=varNONE && !DispZero)//[REG * s + disp32]
388 {
389 if(Index==varESP)
390 return false;
391 ModRM=0x04;//00000100
392 SIB=ScaleToSIB(Scale) | IndexToSIB(Index) | BaseToSIB(Base);
393 EnableSIB=true;
394 Displayment=true;
395 return true;
396 }
397 if(Base!=varNONE && Index!=varNONE && !DispZero)//[REG * s + REG + disp32]
398 {
399 if(Index==varESP)
400 return false;
401 ModRM=0x84;//10000100
402 SIB=ScaleToSIB(Scale) | IndexToSIB(Index) | BaseToSIB(Base);
403 EnableSIB=true;
404 Displayment=true;
405 return true;
406 }
407 return false;
408 }
409 }
410
411 #define APPEND_ERROR(ERRORCODE,MESSAGE) \
412 { \
413 VL_AsmError Error; \
414 Error.ErrorCode=ERRORCODE; \
415 Error.Index=i; \
416 Error.Message=MESSAGE; \
417 Compiled->Errors.Add(Error); \
418 /*throw Error;*/ \
419 CompileToBinaryCode=false; \
420 goto EXIT_SINGLE_INSTRUCTION_COMPILATION; \
421 }
422
423 struct LabelRef
424 {
425 VSize Position; //填补的位置
426 VSize InsBegin; //包含该位置的指令的起始地址
427 VSize InsEnd; //包含该位置的指令的结束地址
428 VInt LabelID; //标号
429 };
430
431 struct LinkingRef
432 {
433 VInt ID;
434 VInt Offset;
435 VSize Position;
436 VByte Bits; //0->8, 1->16, 2->32
437 };
438
439 VL_AsmCompiled* Compile(VL_AsmProgram* Program)
440 {
441 VL_AsmCompiled* Compiled=new VL_AsmCompiled; // 保存二进制代码的Compiled对象
442 VL_ListedMap<VInt , VSize> LabelOffsets; // LabelID -> InstructionAddress
443 VL_List<LabelRef , true> LabelReferences; // 空缺的需要填补的Label相对地址
444 VL_MultiMap<VInt , VInt , true> LabelLookups; // InstructionIndex -> LabelID
445 VBool CompileToBinaryCode=true; // 是否将二进制代码写进Compiled对象
446
447 CopyStream(&Program->ConstantBuffer,&Compiled->ConstantBuffer);
448 for(VInt i=0;i<Program->Labels.GetCount();i++)
449 {
450 LabelLookups.Add(Program->Labels[i],i);
451 }
452
453 for(VInt i=0;i<Program->Instructions.GetCount();i++)
454 {
455 VL_AsmIns& Instruction=Program->Instructions[i];
456 VL_List<VInt , true>* AssociatedLabels=0;
457 {
458 VInt Index=LabelLookups.IndexOfKey(i);
459 if(Index>-1)
460 {
461 AssociatedLabels=&LabelLookups.ValueOfIndex(Index);
462 }
463 }
464
465 VLE_InsName Name=NameToIns(Instruction.Name.Buffer());
466 if(Name==vinUNKNOWN)
467 APPEND_ERROR(vaecUnrecognizedName,L"指令名\""+Instruction.Name+L"\"无法识别。");
468 if(Instruction.ParameterCount<0||Instruction.ParameterCount>4)
469 APPEND_ERROR(vaecWrongParameterCount,L"指令的参数数量只能是0、1、2、3、4。");
470 for(VInt j=0;j<Instruction.ParameterCount;j++)
471 {
472 VL_AsmParameter& Parameter=Instruction.Parameters[j];
473 switch(Parameter.ParameterKind)
474 {
475 case vapkRegister:
476 if(Parameter.Register==varNONE)
477 {
478 APPEND_ERROR(vaecLostRegister,L"类型为寄存器的参数不可为varNONE。");
479 }
480 else if(Parameter.Register>=varAL && Parameter.Register<=varDH)
481 {
482 if(Parameter.ParameterType!=vaptInt8)
483 APPEND_ERROR(vaecWrongRegisterType,L"AL、AH、BL、BH、CL、CH、DL、DH的参数值类型必须是8位整数。");
484 }
485 else if(Parameter.Register>=varAX && Parameter.Register<=varDI)
486 {
487 if(Parameter.ParameterType!=vaptInt16)
488 APPEND_ERROR(vaecWrongRegisterType,L"AX、BX、CX、DS、SP、BP、SI、DI的参数值类型必须是16位整数。");
489 }
490 else if(Parameter.Register>=varEAX && Parameter.Register<=varEDI)
491 {
492 if(Parameter.ParameterType!=vaptInt32)
493 APPEND_ERROR(vaecWrongRegisterType,L"EAX、EBX、ECX、EDS、ESP、EBP、ESI、EDI的参数值类型必须是32位整数。");
494 }
495 else if(Parameter.Register>=varST0 && Parameter.Register<=varST7)
496 {
497 if(Parameter.ParameterType!=vaptFpReg)
498 APPEND_ERROR(vaecWrongRegisterType,L"浮点寄存器ST(i)的参数值类型必须是与位数无关的浮点数。");
499 }
500 else
501 {
502 APPEND_ERROR(vaecUnrecognizedRegister,L"未知寄存器。");
503 }
504 break;
505 case vapkPointer:
506 if(Parameter.Index!=varNONE && (Parameter.Index<varEAX || Parameter.Index>varEDI))
507 APPEND_ERROR(vaecIndexRegisterMustBe32Bits,L"Index寄存器只能是EAX、EBX、ECX、EDS、ESP、EBP、ESI、EDI。");
508 if(Parameter.Base!=varNONE && (Parameter.Base<varEAX || Parameter.Base>varEDI))
509 APPEND_ERROR(vaecBaseRegisterMustBe32Bits,L"Base寄存器只能是EAX、EBX、ECX、EDS、ESP、EBP、ESI、EDI。");
510 if(Parameter.Scale<vas1 || Parameter.Scale>vas4)
511 APPEND_ERROR(vaecUnrecognizedScale,L"Scale只能是1、2、4、8。");
512 switch(Parameter.ParameterType)
513 {
514 case vaptInt8:
515 case vaptInt16:
516 case vaptInt32:
517 case vaptFp32:
518 case vaptFp64:
519 break;
520 default:
521 APPEND_ERROR(vaecUnrecognizedType,L"指针的参数值类型只能是8位、16位、32位整数或32位、64位浮点数。");
522 }
523 break;
524 case vapkSigned:
525 switch(Parameter.ParameterType)
526 {
527 case vaptInt8:
528 if(Parameter.Linking.Enabled==false && (Parameter.Signed<-128 || Parameter.Signed>127))
529 APPEND_ERROR(vaecSignedOutOfRange,L"有符号整数\""+VUnicodeString(Parameter.Signed)+L"\"超出了8位有符号整数的描述范围。");
530 break;
531 case vaptInt16:
532 if(Parameter.Linking.Enabled==false && (Parameter.Signed<-32768 || Parameter.Signed>32767))
533 APPEND_ERROR(vaecSignedOutOfRange,L"有符号整数\""+VUnicodeString(Parameter.Signed)+L"\"超出了16位有符号整数的描述范围。");
534 break;
535 case vaptInt32:
536 break;
537 default:
538 APPEND_ERROR(vaecSignedMustBeInteger,L"有符号整数的参数值类型只能是8位、16位、32位的有符号整数。");
539 }
540 break;
541 case vapkUnsigned:
542 switch(Parameter.ParameterType)
543 {
544 case vaptInt8:
545 if(Parameter.Linking.Enabled==false && Parameter.Unsigned>255)
546 {
547 VWChar Buffer[64]={0};
548 _ui64tow(Parameter.Unsigned,Buffer,10);
549 APPEND_ERROR(vaecUnsignedOutOfRange,L"无符号整数\""+VUnicodeString(Buffer)+L"\"超出了8位无符号整数的描述范围。");
550 }
551 break;
552 case vaptInt16:
553 if(Parameter.Linking.Enabled==false && Parameter.Unsigned>65535)
554 {
555 VWChar Buffer[64]={0};
556 _ui64tow(Parameter.Unsigned,Buffer,10);
557 APPEND_ERROR(vaecUnsignedOutOfRange,L"无符号整数\""+VUnicodeString(Buffer)+L"\"超出了16位无符号整数的描述范围。");
558 }
559 break;
560 case vaptInt32:
561 break;
562 default:
563 APPEND_ERROR(vaecUnsignedMustBeInteger,L"无符号整数的参数值类型只能是8位、16位、32位的无符号整数。");
564 }
565 break;
566 case vapkRelative:
567 switch(Parameter.ParameterType)
568 {
569 case vaptInt8:
570 if(Parameter.Linking.Enabled==false && (Parameter.Signed<-128 || Parameter.Signed>127))
571 APPEND_ERROR(vaecSignedOutOfRange,L"相对地址\""+VUnicodeString(Parameter.Signed)+L"\"超出了8位有符号整数的描述范围。");
572 break;
573 case vaptInt16:
574 if(Parameter.Linking.Enabled==false && (Parameter.Signed<-32768 || Parameter.Signed>32767))
575 APPEND_ERROR(vaecSignedOutOfRange,L"相对地址\""+VUnicodeString(Parameter.Signed)+L"\"超出了16位有符号整数的描述范围。");
576 break;
577 case vaptInt32:
578 break;
579 default:
580 APPEND_ERROR(vaecRelativeMustBeInteger,L"相对地址的参数值类型只能是8位、16位、32位的有符号整数。");
581 }
582 break;
583 case vapkLabel:
584 if(Parameter.ParameterType!=vaptInt32)
585 APPEND_ERROR(vaecLabelMustBeInt32,L"标号的参数值类型必须是32位整数。");
586 if(Parameter.Label<0 || Parameter.Label>=Program->Labels.GetCount())
587 APPEND_ERROR(vaecUnrecognizedLabel,L"标号不存在。");
588 break;
589 default:
590 APPEND_ERROR(vaecUnrecognizedKind,L"参数类型只能是寄存器、指针、有符号整数、无符号整数、相对地址偏移或标号");
591 }
592 }
593
594 VInt InsMin=InsOffset[Name];
595 VInt InsMax=InsMin+InsCount[Name]-1;
596 VInt SelectedIns=-1;
597 for(VInt j=InsMin;j<=InsMax;j++)
598 {
599 VLS_InsFormat& Format=InsFormat[j];
600 VBool Failed=false;
601 for(VInt k=0;k<Instruction.ParameterCount;k++)
602 {
603 if(!CheckParameter(Format.Params[k],Instruction.Parameters[k]))
604 {
605 Failed=true;
606 break;
607 }
608 }
609 for(VInt k=Instruction.ParameterCount;k<4;k++)
610 {
611 if(Format.Params[k]!=vipNoParam)
612 {
613 Failed=true;
614 break;
615 }
616 }
617 if(!Failed)
618 {
619 SelectedIns=j;
620 break;
621 }
622 }
623 if(SelectedIns==-1)
624 APPEND_ERROR(vaecParameterNotMatched,L"没有可以用于此参数类型组合的指令。");
625
626 {
627 VBool UseModRM=false;
628 VInt ModRMIndex=-1;
629 VInt ExtRegIndex=-1;
630 VInt Ext=-1;
631 VInt PlusIndex=-1;
632 VInt ImmIndex=-1;
633 VBool Used[4]={false,false,false,false};
634 VLS_InsFormat& Format=InsFormat[SelectedIns];
635
636 if(Format.Plus==vipRegister)
637 {
638 PlusIndex=FindRI(Format,Used);
639 if(PlusIndex==-1)
640 APPEND_ERROR(vaecDoNotKnowHowToCompile,L"找不到Plus的对应参数。");
641 }
642 else if(Format.Plus==vipFloat)
643 {
644 PlusIndex=FindRF(Format,Used);
645 if(PlusIndex==-1)
646 APPEND_ERROR(vaecDoNotKnowHowToCompile,L"找不到Plus的对应参数。");
647 }
648
649 if(Format.Imm==viiNoImm)
650 {
651 ImmIndex=FindIMM(Format,Used);
652 if(ImmIndex!=-1)
653 {
654 if(Format.Params[ImmIndex]==vipCONST_1 || Format.Params[ImmIndex]==vipCONST_3)
655 {
656 ImmIndex=-1;
657 }
658 }
659 }
660 else
661 {
662 ImmIndex=FindIMM(Format,Used);
663 if(ImmIndex==-1)
664 APPEND_ERROR(vaecDoNotKnowHowToCompile,L"找不到Immediate的对应参数。");
665 }
666
667 if(Format.Ext>=vie0 && Format.Ext<=vie7)
668 {
669 UseModRM=true;
670 Ext=Format.Ext;
671 }
672 else if(Format.Ext==vieRegister)
673 {
674 UseModRM=true;
675 ExtRegIndex=FindRI(Format,Used);
676 if(ExtRegIndex==-1)
677 APPEND_ERROR(vaecDoNotKnowHowToCompile,L"找不到/r的对应参数。");
678 Ext=RegisterToExt(Instruction.Parameters[ExtRegIndex].Register);
679 }
680
681 ModRMIndex=FindRM(Format,Used);
682 if(ModRMIndex!=-1)
683 {
684 if(Format.Params[ModRMIndex]>=vipAL && Format.Params[ModRMIndex]<=vipSS)
685 {
686 ModRMIndex=-1;
687 }
688 else
689 {
690 if(!UseModRM)
691 {
692 UseModRM=true;
693 }
694 if(Ext==-1)
695 {
696 ExtRegIndex=FindRI(Format,Used);
697 if(ExtRegIndex!=-1)
698 {
699 if(Format.Params[ExtRegIndex]>=vipAL && Format.Params[ExtRegIndex]<=vipSS)
700 {
701 ExtRegIndex=-1;
702 }
703 else
704 {
705 Ext=RegisterToExt(Instruction.Parameters[ExtRegIndex].Register);
706 }
707 }
708 }
709 }
710 }
711
712 for(VInt j=0;j<Instruction.ParameterCount;j++)
713 {
714 if(!Used[j])
715 APPEND_ERROR(vaecDoNotKnowHowToCompile,L"找不到第\""+VUnicodeString(j+1)+L"\"个参数的二进制码贡献方法");
716 }
717 if(CompileToBinaryCode)
718 {
719 VSize InstructionBeginPosition=Compiled->InstructionBuffer.Position();
720 if(AssociatedLabels)
721 {
722 for(VInt j=0;j<AssociatedLabels->GetCount();j++)
723 {
724 LabelOffsets.Add((*AssociatedLabels)[j],InstructionBeginPosition);
725 }
726 }
727 if(Format.Prefix16)
728 {
729 VByte Prefix=0x66;
730 Compiled->InstructionBuffer.Write(&Prefix,sizeof(Prefix));
731 }
732 if(PlusIndex==-1)
733 {
734 Compiled->InstructionBuffer.Write((VPointer)Format.Opcode,Format.OpcodeLength);
735 }
736 else
737 {
738 Compiled->InstructionBuffer.Write((VPointer)Format.Opcode,Format.OpcodeLength-1);
739 VByte OpCode=Format.Opcode[Format.OpcodeLength-1];
740 OpCode+=(VByte)RegisterToExt(Instruction.Parameters[PlusIndex].Register);
741 Compiled->InstructionBuffer.Write(&OpCode,sizeof(OpCode));
742 }
743 if(UseModRM)
744 {
745 VByte ModRM=0;
746 VByte SIB=0;
747 VBool EnableSIB=false;
748 VBool Displayment=false;
749 VL_AsmParameter& Parameter=Instruction.Parameters[ModRMIndex];
750
751 if(MakeModRMWithoutExt(Parameter,ModRM,SIB,EnableSIB,Displayment))
752 {
753 ModRM|=(VByte)(Ext<<3);
754 Compiled->InstructionBuffer.Write(&ModRM,sizeof(ModRM));
755 if(EnableSIB)
756 {
757 Compiled->InstructionBuffer.Write(&SIB,sizeof(SIB));
758 }
759 if(Displayment)
760 {
761 VInt32s Disp32=Parameter.Offset;
762 if(Parameter.Linking.Enabled)
763 {
764 LinkingRef Ref;
765 Ref.Position=Compiled->InstructionBuffer.Position();
766 Ref.ID=Parameter.Linking.LinkingID;
767 Ref.Offset=Parameter.Linking.LinkingOffset;
768 Ref.Bits=2;
769 Compiled->LinkingBuffer.Write(&Ref,sizeof(Ref));
770 }
771 Compiled->InstructionBuffer.Write(&Disp32,sizeof(Disp32));
772 }
773 }
774 else
775 {
776 APPEND_ERROR(vaecDoNotKnowHowToCompile,L"无法将参数中的寄存器表达的指针转换成ModR/M+SIB字节。");
777 }
778 }
779 if(ImmIndex!=-1)
780 {
781 VL_AsmParameter& Parameter=Instruction.Parameters[ImmIndex];
782 VLE_AsmParameterKind Kind=Parameter.ParameterKind;
783 if(Parameter.Linking.Enabled)
784 {
785 LinkingRef Ref;
786 Ref.Position=Compiled->InstructionBuffer.Position();
787 Ref.ID=Parameter.Linking.LinkingID;
788 Ref.Offset=Parameter.Linking.LinkingOffset;
789 switch(Parameter.ParameterType)
790 {
791 case vaptInt8:
792 Ref.Bits=0;
793 break;
794 case vaptInt16:
795 Ref.Bits=1;
796 break;
797 case vaptInt32:
798 default:
799 Ref.Bits=2;
800 break;
801 }
802 Compiled->LinkingBuffer.Write(&Ref,sizeof(Ref));
803 }
804 else if(Kind==vapkLabel)
805 {
806 LabelRef Ref;
807 Ref.Position=Compiled->InstructionBuffer.Position();
808 Ref.InsBegin=InstructionBeginPosition;
809 Ref.InsEnd=Compiled->InstructionBuffer.Position()+sizeof(VInt32u);
810 Ref.LabelID=Parameter.Label;
811 LabelReferences.Add(Ref);
812 }
813 switch(Parameter.ParameterType)
814 {
815 case vaptInt8:
816 {
817 VInt8s Data=Kind==vapkSigned?(VInt8s)Parameter.Signed:(VInt8s)Parameter.Unsigned;
818 Compiled->InstructionBuffer.Write(&Data,sizeof(Data));
819 }
820 break;
821 case vaptInt16:
822 {
823 VInt16s Data=Kind==vapkSigned?(VInt16s)Parameter.Signed:(VInt16s)Parameter.Unsigned;
824 Compiled->InstructionBuffer.Write(&Data,sizeof(Data));
825 }
826 break;
827 case vaptInt32:
828 default:
829 {
830 VInt32s Data=Kind==vapkSigned?(VInt32s)Parameter.Signed:(VInt32s)Parameter.Unsigned;
831 Compiled->InstructionBuffer.Write(&Data,sizeof(Data));
832 }
833 break;
834 }
835 }
836 }
837 }
838 EXIT_SINGLE_INSTRUCTION_COMPILATION:
839 ;
840 }
841
842 if(!Compiled->Errors.GetCount())
843 {
844 for(VInt i=0;i<LabelReferences.GetCount();i++)
845 {
846 LabelRef& Ref=LabelReferences[i];
847 VSize Address=LabelOffsets[Ref.LabelID];
848 if(Address<=Ref.InsBegin)
849 {
850 Address=Address-Ref.InsEnd;
851 }
852 else if(Address>=Ref.InsEnd)
853 {
854 Address=Address-Ref.InsEnd;
855 }
856 else
857 {
858 throw "Label地址位于本指令中间，有BUG。";
859 }
860 Compiled->InstructionBuffer.SeekFromBegin(Ref.Position);
861 VInt32s Address32=(VInt32s)Address;
862 Compiled->InstructionBuffer.Write(&Address32,sizeof(Address32));
863 }
864 }
865
866 Compiled->ConstantBuffer.SeekFromBegin(0);
867 Compiled->InstructionBuffer.SeekFromBegin(0);
868 Compiled->LinkingBuffer.SeekFromBegin(0);
869 return Compiled;
870 }
871
872 #undef APPEND_ERROR
873
874 }
875 }
876 }
在if(SelectedIns==-1) APPEND_ERROR(vaecParameterNotMatched,L"没有可以用于此参数类型组合的指令。");这句下面的APPEND_ERROR大部分是为了调试写的，基本上如果促触发了DoNotKnowHowToCompile错误的话，9成都是这个汇编器有BUG。
汇编器的核心部分顺利完成。接下来的工作是写一个汇编语言的编译器，以便手写大量test case进行自动测试。
posted on 2009-02-22 07:08
陈梓瀚(vczh) 阅读(4931)
评论(11) 编辑 收藏 引用 所属分类:
JIT