source: dev/trunk/abdev/BasicCompiler32/NumOpe_Logical.cpp@ 209

Last change on this file since 209 was 206, checked in by dai_9181, 17 years ago

コード全体のリファクタリングを実施
File size: 9.3 KB
RevLine 
[206]1#include "stdafx.h"
2
[3]3#include "../BasicCompiler_Common/common.h"
4#include "Opcode.h"
5
6BOOL Calc_Xor(int *type,LONG_PTR *index_stack,int *pStackPointer){
7 //value[sp-2] xor= value[sp-1]
8 //xor演算
9
10 int sp;
11 sp=*pStackPointer;
12
13 if(IsRealNumberType(type[sp-2])||IsRealNumberType(type[sp-1])){
14 //いずれかの項が実数のとき
15 SetError(45,"xor",cp);
16 return 0;
17 }
18
19 if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD||
20 type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
21 ////////////////////
22 // 64ビット整数演算
23 ////////////////////
24
25 //第2項を64ビットに対応させる
26 if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
27 //第2項が64ビット整数値のとき
28
29 //pop ebx
30 op_pop(REG_EBX);
31
32 //pop ecx
33 op_pop(REG_ECX);
34 }
35 else{
36 //第2項がその他整数値のとき
37
38 //pop eax
39 op_pop(REG_EAX);
40
41 if(IsSignedType(type[sp-1])){
42 //符号拡張
43 //edx:eax ← eax
44
45 //cdq
46 op_cdq();
47 }
48 else{
49 //ビット拡張
50 //edx:eax ← eax
51
52 //xor edx,edx
53 op_zero_reg(REG_EDX);
54 }
55
56 //mov ebx,eax
57 OpBuffer[obp++]=(char)0x8B;
58 OpBuffer[obp++]=(char)0xD8;
59
60 //mov ecx,edx
61 OpBuffer[obp++]=(char)0x8B;
62 OpBuffer[obp++]=(char)0xCA;
63 }
64
65 if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD){
66 //第1項が64ビット整数値のとき
67
68 //xor dword ptr[esp],ebx
69 OpBuffer[obp++]=(char)0x31;
70 OpBuffer[obp++]=(char)0x1C;
71 OpBuffer[obp++]=(char)0x24;
72
73 //xor dword ptr[esp+sizeof(long)],ecx
74 OpBuffer[obp++]=(char)0x31;
75 OpBuffer[obp++]=(char)0x4C;
76 OpBuffer[obp++]=(char)0x24;
77 OpBuffer[obp++]=(char)0x04;
78 }
79 else{
80 //第1項がその他整数値のとき
81 if(IsSignedType(type[sp-2])){
82 //pop eax
83 op_pop(REG_EAX);
84
85 //符号拡張
86 //edx:eax ← eax
87
88 //cdq
89 op_cdq();
90 }
91 else{
92 //pop eax
93 op_pop(REG_EAX);
94
95 //ビット拡張
96 //edx:eax ← eax
97
98 //xor edx,edx
99 op_zero_reg(REG_EDX);
100 }
101
102 //xor ebx,eax
103 OpBuffer[obp++]=(char)0x33;
104 OpBuffer[obp++]=(char)0xD8;
105
106 //xor ecx,edx
107 OpBuffer[obp++]=(char)0x33;
108 OpBuffer[obp++]=(char)0xCA;
109
110 //push ecx
111 op_push(REG_ECX);
112
113 //push ebx
114 op_push(REG_EBX);
115 }
116
117 sp--;
118 if(type[sp-1]==DEF_QWORD&&type[sp]==DEF_QWORD) type[sp-1]=DEF_QWORD;
119 else type[sp-1]=DEF_INT64;
120 }
121 else{
122 ////////////////////
123 // 整数演算
124 ////////////////////
125
126 //pop ebx
127 op_pop(REG_EBX);
128
129 //pop eax
130 op_pop(REG_EAX);
131
132 //sub esp,4
133 op_sub_esp(4);
134
135 //xor eax,ebx
136 OpBuffer[obp++]=(char)0x33;
137 OpBuffer[obp++]=(char)0xC3;
138
139 //mov dword ptr[esp],eax
140 OpBuffer[obp++]=(char)0x89;
141 OpBuffer[obp++]=(char)0x04;
142 OpBuffer[obp++]=(char)0x24;
143
144 sp--;
145 type[sp-1]=NeutralizationType(type[sp-1],index_stack[sp-1],type[sp],index_stack[sp]);
146 }
147
148 *pStackPointer=sp;
149 return 1;
150}
151
152BOOL Calc_Or(int *type,LONG_PTR *index_stack,int *pStackPointer){
153 //value[sp-2] or= value[sp-1]
154 //or演算
155
156 int sp;
157 sp=*pStackPointer;
158
159 if(IsRealNumberType(type[sp-2])||IsRealNumberType(type[sp-1])){
160 //いずれかの項が実数のとき
161 SetError(45,"or",cp);
162 return 0;
163 }
164
165 if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD||
166 type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
167 ////////////////////
168 // 64ビット整数演算
169 ////////////////////
170
171 //第2項を64ビットに対応させる
172 if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
173 //第2項が64ビット整数値のとき
174
175 //pop ebx
176 op_pop(REG_EBX);
177
178 //pop ecx
179 op_pop(REG_ECX);
180 }
181 else{
182 //第2項が32ビット整数値のとき
183
184 //pop eax
185 op_pop(REG_EAX);
186
187 if(IsSignedType(type[sp-1])){
188 //符号拡張
189 //edx:eax ← eax
190
191 //cdq
192 op_cdq();
193 }
194 else{
195 //ビット拡張
196 //edx:eax ← eax
197
198 //xor edx,edx
199 op_zero_reg(REG_EDX);
200 }
201
202 //mov ebx,eax
203 OpBuffer[obp++]=(char)0x8B;
204 OpBuffer[obp++]=(char)0xD8;
205
206 //mov ecx,edx
207 OpBuffer[obp++]=(char)0x8B;
208 OpBuffer[obp++]=(char)0xCA;
209 }
210
211 if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD){
212 //第1項が64ビット整数値のとき
213
214 //or dword ptr[esp],ebx
215 OpBuffer[obp++]=(char)0x09;
216 OpBuffer[obp++]=(char)0x1C;
217 OpBuffer[obp++]=(char)0x24;
218
219 //or dword ptr[esp+sizeof(long)],ecx
220 OpBuffer[obp++]=(char)0x09;
221 OpBuffer[obp++]=(char)0x4C;
222 OpBuffer[obp++]=(char)0x24;
223 OpBuffer[obp++]=(char)0x04;
224 }
225 else{
226 //第1項が32ビット整数値のとき
227 if(IsSignedType(type[sp-2])){
228 //pop eax
229 op_pop(REG_EAX);
230
231 //符号拡張
232 //edx:eax ← eax
233
234 //cdq
235 op_cdq();
236 }
237 else{
238 //pop eax
239 op_pop(REG_EAX);
240
241 //ビット拡張
242 //edx:eax ← eax
243
244 //xor edx,edx
245 op_zero_reg(REG_EDX);
246 }
247
248 //or ebx,eax
249 OpBuffer[obp++]=(char)0x0B;
250 OpBuffer[obp++]=(char)0xD8;
251
252 //or ecx,edx
253 OpBuffer[obp++]=(char)0x0B;
254 OpBuffer[obp++]=(char)0xCA;
255
256 //push ecx
257 op_push(REG_ECX);
258
259 //push ebx
260 op_push(REG_EBX);
261 }
262
263 sp--;
264 if(type[sp-1]==DEF_QWORD&&type[sp]==DEF_QWORD) type[sp-1]=DEF_QWORD;
265 else type[sp-1]=DEF_INT64;
266 }
267 else{
268 ////////////////////
269 // 32ビット整数演算
270 ////////////////////
271
272 //pop ebx
273 op_pop(REG_EBX);
274
275 //pop eax
276 op_pop(REG_EAX);
277
278 //sub esp,4
279 op_sub_esp(4);
280
281 //or eax,ebx
282 OpBuffer[obp++]=(char)0x0B;
283 OpBuffer[obp++]=(char)0xC3;
284
285 //mov dword ptr[esp],eax
286 OpBuffer[obp++]=(char)0x89;
287 OpBuffer[obp++]=(char)0x04;
288 OpBuffer[obp++]=(char)0x24;
289
290 sp--;
291 type[sp-1]=NeutralizationType(type[sp-1],index_stack[sp-1],type[sp],index_stack[sp]);
292 }
293
294 *pStackPointer=sp;
295 return 1;
296}
297
298BOOL Calc_And(int *type,LONG_PTR *index_stack,int *pStackPointer){
299 //value[sp-2] and= value[sp-1]
300 //and演算
301
302 int sp;
303 sp=*pStackPointer;
304
305 if(IsRealNumberType(type[sp-2])||IsRealNumberType(type[sp-1])){
306 //いずれかの項が実数のとき
307 SetError(45,"and",cp);
308 return 0;
309 }
310
311 if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD||
312 type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
313 ////////////////////
314 // 64ビット整数演算
315 ////////////////////
316
317 //第2項を64ビットに対応させる
318 if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
319 //第2項が64ビット整数値のとき
320
321 //pop ebx
322 op_pop(REG_EBX);
323
324 //pop ecx
325 op_pop(REG_ECX);
326 }
327 else{
328 //第2項が32ビット整数値のとき
329
330 //pop eax
331 op_pop(REG_EAX);
332
333 if(IsSignedType(type[sp-1])){
334 //符号拡張
335 //edx:eax ← eax
336
337 //cdq
338 op_cdq();
339 }
340 else{
341 //ビット拡張
342 //edx:eax ← eax
343
344 //xor edx,edx
345 op_zero_reg(REG_EDX);
346 }
347
348 //mov ebx,eax
349 OpBuffer[obp++]=(char)0x8B;
350 OpBuffer[obp++]=(char)0xD8;
351
352 //mov ecx,edx
353 OpBuffer[obp++]=(char)0x8B;
354 OpBuffer[obp++]=(char)0xCA;
355 }
356
357 if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD){
358 //第1項が64ビット整数値のとき
359
360 //and dword ptr[esp],ebx
361 OpBuffer[obp++]=(char)0x21;
362 OpBuffer[obp++]=(char)0x1C;
363 OpBuffer[obp++]=(char)0x24;
364
365 //and dword ptr[esp+sizeof(long)],ecx
366 OpBuffer[obp++]=(char)0x21;
367 OpBuffer[obp++]=(char)0x4C;
368 OpBuffer[obp++]=(char)0x24;
369 OpBuffer[obp++]=(char)0x04;
370 }
371 else{
372 //第1項が32ビット整数値のとき
373 if(IsSignedType(type[sp-2])){
374 //pop eax
375 op_pop(REG_EAX);
376
377 //符号拡張
378 //edx:eax ← eax
379
380 //cdq
381 op_cdq();
382 }
383 else{
384 //pop eax
385 op_pop(REG_EAX);
386
387 //ビット拡張
388 //edx:eax ← eax
389
390 //xor edx,edx
391 op_zero_reg(REG_EDX);
392 }
393
394 //and ebx,eax
395 OpBuffer[obp++]=(char)0x23;
396 OpBuffer[obp++]=(char)0xD8;
397
398 //and ecx,edx
399 OpBuffer[obp++]=(char)0x23;
400 OpBuffer[obp++]=(char)0xCA;
401
402 //push ecx
403 op_push(REG_ECX);
404
405 //push ebx
406 op_push(REG_EBX);
407 }
408
409 sp--;
410 if(type[sp-1]==DEF_QWORD&&type[sp]==DEF_QWORD) type[sp-1]=DEF_QWORD;
411 else type[sp-1]=DEF_INT64;
412 }
413 else{
414 ////////////////////
415 // 32ビット整数演算
416 ////////////////////
417
418 //pop ebx
419 op_pop(REG_EBX);
420
421 //pop eax
422 op_pop(REG_EAX);
423
424 //sub esp,4
425 op_sub_esp(4);
426
427 //and eax,ebx
428 OpBuffer[obp++]=(char)0x23;
429 OpBuffer[obp++]=(char)0xC3;
430
431 //mov dword ptr[esp],eax
432 OpBuffer[obp++]=(char)0x89;
433 OpBuffer[obp++]=(char)0x04;
434 OpBuffer[obp++]=(char)0x24;
435
436 sp--;
437 type[sp-1]=NeutralizationType(type[sp-1],index_stack[sp-1],type[sp],index_stack[sp]);
438 }
439
440 *pStackPointer=sp;
441 return 1;
442}
443
444BOOL Calc_Not(int *type,int sp){
445 //value[sp-1]=Not value[sp-1]
446 //NOT演算子
447
448 if(IsRealNumberType(type[sp-1])){
449 //実数のとき
450 SetError(45,"Not",cp);
451 return 0;
452 }
453
[36]454 if( type[sp - 1] == DEF_BOOLEAN ){
455 //pop eax
456 op_pop( REG_EAX );
457
458 //cmp eax,0
459 op_cmp_value(GetTypeSize(type[sp-1],-1),REG_EAX,0);
460
461 //setne al
462 op_setne( REG_EAX );
463
464 //and eax,000000FFh
465 op_and_RV(REG_EAX,(int)0xFF);
466
467 //neg
468 op_neg( REG_EAX );
469
470 //sbb eax, eax
471 op_sbb_RR( REG_EAX, REG_EAX );
472
473 //add eax, 1
474 op_add_RV8( REG_EAX, 1 );
475
476 //push eax
477 op_push( REG_EAX );
478 }
479 else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
[3]480 ////////////////////
481 // 64ビット整数演算
482 ////////////////////
483
484 //not dword ptr[esp]
485 OpBuffer[obp++]=(char)0xF7;
486 OpBuffer[obp++]=(char)0x14;
487 OpBuffer[obp++]=(char)0x24;
488
489 //not dword ptr[esp+4]
490 OpBuffer[obp++]=(char)0xF7;
491 OpBuffer[obp++]=(char)0x54;
492 OpBuffer[obp++]=(char)0x24;
493 OpBuffer[obp++]=(char)0x04;
494 }
495 else{
496 ////////////////////
497 // 32ビット整数演算
498 ////////////////////
499
500 //not dword ptr[esp]
501 OpBuffer[obp++]=(char)0xF7;
502 OpBuffer[obp++]=(char)0x14;
503 OpBuffer[obp++]=(char)0x24;
504 }
505
506 return 1;
507}
Note: See TracBrowser for help on using the repository browser.