source: dev/BasicCompiler32/op32_main.cpp@ 47

Last change on this file since 47 was 36, checked in by dai_9181, 18 years ago

Boolean型に対応。

File size: 19.7 KB
Line 
1#include "../BasicCompiler_Common/common.h"
2#include "Opcode.h"
3
4
5
6BOOL IsSafeReg(int reg){
7 if(reg==REG_EBX||reg==REG_ESI||reg==REG_EDI) return 1;
8 return 0;
9}
10
11
12
13/////////////////////////////////////////////////
14// ModR/Mバイト、SIBバイト、ディスプレースメント
15/////////////////////////////////////////////////
16
17//スケール
18#define SCALE_NON (char)0x00
19#define SCALE_2 (char)0x40
20#define SCALE_4 (char)0x80
21#define SCALE_8 (char)0xC0
22
23//インデックスなし
24#define INDEX_NON 0x04
25
26void set_mod_rm_sib_disp(char mod,int reg,int scale,int index_reg,int base_reg,int disp){
27 if(mod==MOD_DISP32){
28 //ModR/Mバイト
29 OpBuffer[obp++]=(char)( REGISTER_OPERAND(reg)<<3 | REGISTER_OPERAND(0x04));
30
31 base_reg=0x05;
32 index_reg=INDEX_NON;
33 }
34 else{
35 //ModR/Mバイト
36 OpBuffer[obp++]=(char)(mod | REGISTER_OPERAND(reg)<<3 | REGISTER_OPERAND(base_reg));
37 }
38
39
40 //レジスタモードの場合は、ここで終了
41 if(mod==MOD_REG) return;
42
43
44 if(REGISTER_OPERAND(base_reg)==0x04||mod==MOD_DISP32){
45 //////////////////////
46 // SIBバイトを使う
47 //////////////////////
48
49 OpBuffer[obp++]=(char)(scale| REGISTER_OPERAND(index_reg)<<3 | REGISTER_OPERAND(base_reg));
50 }
51
52 //ディスプレースメントを必要としない場合は、ここで終了
53 if(mod==MOD_BASE) return;
54
55
56 //////////////////////////
57 // ディスプレースメント
58 //////////////////////////
59
60 if(mod==MOD_BASE_DISP8) OpBuffer[obp++]=(char)disp;
61 else{
62 *((long *)(OpBuffer+obp))=disp;
63 obp+=sizeof(long);
64 }
65}
66
67
68
69void __op_format(char op_prefix,char opcode,int reg){
70 //命令プリフィックス
71 if(op_prefix) OpBuffer[obp++]=op_prefix;
72
73 //オペコード、レジスタ
74 OpBuffer[obp++]=(char)(opcode|REGISTER_OPERAND(reg));
75}
76void __op_format(char op_prefix,char opcode1,char opcode2,int reg,int base_reg,int offset,char mod){
77 //命令プリフィックス
78 if(op_prefix) OpBuffer[obp++]=op_prefix;
79
80 //オペコード
81 OpBuffer[obp++]=opcode1;
82 if(opcode2) OpBuffer[obp++]=opcode2;
83
84 //ModR/M, SIB, disp
85 set_mod_rm_sib_disp(mod,reg,SCALE_NON,INDEX_NON,base_reg,offset);
86}
87
88
89
90///////////////////
91// mov関連
92///////////////////
93
94void op_mov_RV(int reg,int offset){
95 //mov reg,value
96
97 //オペコード、レジスタ
98 OpBuffer[obp++]=(char)(0xB8|REGISTER_OPERAND(reg));
99
100 //DISP32
101 *((long *)(OpBuffer+obp))=offset;
102 obp+=sizeof(long);
103}
104void op_mov_RV(int op_size,int reg,int offset){
105 if(op_size==PTR_SIZE) op_mov_RV(reg,offset);
106 else SetError(300,NULL,cp);
107}
108void op_mov_RR(int reg1,int reg2){
109 //mov reg1,reg2
110
111 if(reg1==reg2) return;
112
113 //1000 1011 11xx xbbb
114 OpBuffer[obp++]=(char)0x8B;
115 OpBuffer[obp++]=(char)(0xC0| REGISTER_OPERAND(reg1)<<3 | REGISTER_OPERAND(reg2));
116}
117void op_mov_RM(int op_size,int reg,int base_reg,int offset,char mod){
118 //mov reg32,dword ptr[base_reg+offset]
119 //mov reg16,word ptr[base_reg+offset]
120 //mov reg8,byte ptr[base_reg+offset]
121
122 //16ビット演算の命令プリフィックス
123 char op_prefix=0;
124 if(op_size==sizeof(short)) op_prefix=(char)0x66;
125
126 //オペコード
127 char opcode;
128 if(op_size==sizeof(char)) opcode=(char)0x8A;
129 else opcode=(char)0x8B;
130
131 __op_format(op_prefix,opcode,0,reg,base_reg,offset,mod);
132}
133void op_mov_RM_ex(int op_size,int reg,int base_reg1,int base_reg2,int offset,BOOL bUseOffset){
134 //mov reg32,dword ptr[base_reg1+base_reg2+offset]
135 //mov reg16,word ptr[base_reg1+base_reg2+offset]
136 //mov reg8,byte ptr[base_reg1+base_reg2+offset]
137
138 if(base_reg1==REG_ESP){
139 //SIBバイトのindex部にespは指定できない
140 base_reg1=base_reg2;
141 base_reg2=REG_ESP;
142 }
143
144 //16ビット演算のプリフィックス
145 if(op_size==sizeof(short)) OpBuffer[obp++]=(char)0x66;
146
147 //オペコード
148 if(op_size==sizeof(char)) OpBuffer[obp++]=(char)0x8A;
149 else OpBuffer[obp++]=(char)0x8B;
150
151 if(bUseOffset){
152 ///////////////////////////
153 // オフセット値を使う
154 ///////////////////////////
155
156 //レジスタ
157 OpBuffer[obp++]=(char)(0x84| REGISTER_OPERAND(reg)<<3);
158
159 //ベースレジスタ
160 OpBuffer[obp++]=(char)(REGISTER_OPERAND(base_reg1)<<3 | REGISTER_OPERAND(base_reg2));
161
162 //オフセット値
163 *((long *)(OpBuffer+obp))=offset;
164 obp+=sizeof(long);
165 }
166 else{
167 ///////////////////////////
168 // オフセット値を使わない
169 ///////////////////////////
170
171 //レジスタ
172 OpBuffer[obp++]=(char)(0x04| REGISTER_OPERAND(reg)<<3);
173
174 //ベースレジスタ
175 OpBuffer[obp++]=(char)(REGISTER_OPERAND(base_reg1)<<3 | REGISTER_OPERAND(base_reg2));
176 }
177}
178void op_mov_MR(int op_size,int reg,int base_reg,int offset,char mod){
179 //mov dword ptr[base_reg+offset],reg32
180 //mov word ptr[base_reg+offset],reg16
181 //mov byte ptr[base_reg+offset],reg8
182
183 //16ビット演算の命令プリフィックス
184 char op_prefix=0;
185 if(op_size==sizeof(short)) op_prefix=(char)0x66;
186
187 //オペコード
188 char opcode;
189 if(op_size==sizeof(char)) opcode=(char)0x88;
190 else opcode=(char)0x89;
191
192 __op_format(op_prefix,opcode,0,reg,base_reg,offset,mod);
193}
194void op_mov_MR_ex(int op_size,int reg,int base_reg1,int base_reg2,int offset,BOOL bUseOffset){
195 //mov dword ptr[base_reg1+base_reg2+offset],reg32
196 //mov word ptr[base_reg1+base_reg2+offset],reg16
197 //mov byte ptr[base_reg1+base_reg2+offset],reg8
198
199 if(base_reg1==REG_ESP){
200 //SIBバイトのindex部にrspは指定できない
201 base_reg1=base_reg2;
202 base_reg2=REG_ESP;
203 }
204
205 //16ビット演算のプリフィックス
206 if(op_size==sizeof(short)) OpBuffer[obp++]=(char)0x66;
207
208 //オペコード
209 if(op_size==sizeof(char)) OpBuffer[obp++]=(char)0x88;
210 else OpBuffer[obp++]=(char)0x89;
211
212 if(bUseOffset==USE_OFFSET){
213 //////////////////////////
214 //オフセット値を使う
215 //////////////////////////
216
217 //レジスタ
218 OpBuffer[obp++]=(char)(0x84| REGISTER_OPERAND(reg)<<3);
219
220 //ベースレジスタ
221 OpBuffer[obp++]=(char)(REGISTER_OPERAND(base_reg1)<<3 | REGISTER_OPERAND(base_reg2));
222
223 //オフセット値
224 *((long *)(OpBuffer+obp))=offset;
225 obp+=sizeof(long);
226 }
227 else{
228 //////////////////////////
229 //オフセット値を使わない
230 //////////////////////////
231
232 //レジスタ
233 OpBuffer[obp++]=(char)(0x04| REGISTER_OPERAND(reg)<<3);
234
235 //ベースレジスタ
236 OpBuffer[obp++]=(char)(REGISTER_OPERAND(base_reg1)<<3 | REGISTER_OPERAND(base_reg2));
237 }
238}
239
240
241
242
243////////////////////////////////
244// movsx関連
245////////////////////////////////
246
247void op_movsx_R32R16(int reg32,int reg16){
248 //movsx reg32,reg16
249
250 //16ビット演算の命令プリフィックス
251 char op_prefix=0;
252
253 //オペコード
254 char opcode=(char)0x0F;
255 char opcode2=(char)0xBF;
256
257 __op_format(op_prefix,opcode,opcode2,reg32,reg16,0,MOD_REG);
258}
259void op_movsx_R32R8(int reg32,int reg8){
260 //movsx reg32,reg8
261
262 //16ビット演算の命令プリフィックス
263 char op_prefix=0;
264
265 //オペコード
266 char opcode=(char)0x0F;
267 char opcode2=(char)0xBE;
268
269 __op_format(op_prefix,opcode,opcode2,reg32,reg8,0,MOD_REG);
270}
271void op_movsx_R16R8(int reg16,int reg8){
272 //movsx reg16,reg8
273
274 //16ビット演算の命令プリフィックス
275 char op_prefix=(char)0x66;
276
277 //オペコード
278 char opcode=(char)0x0F;
279 char opcode2=(char)0xBE;
280
281 __op_format(op_prefix,opcode,opcode2,reg16,reg8,0,MOD_REG);
282}
283
284
285
286//////////////////////////////////
287// インクリメント・デクリメント
288//////////////////////////////////
289
290void op_inc(int reg){
291 //inc reg
292
293 //16ビット演算の命令プリフィックス
294 char op_prefix=0;
295
296 //オペコード
297 char opcode=(char)0xFF;
298
299 __op_format(op_prefix,opcode,0,0,reg,0,MOD_REG);
300}
301void op_dec(int reg){
302 op_inc(reg);
303 OpBuffer[obp-1]=OpBuffer[obp-1]|0x08;
304}
305
306
307
308/////////////////////
309// add関連
310/////////////////////
311
312void op_add_RV8(int reg,char cValue){
313 //add reg,value8
314
315 OpBuffer[obp++]=(char)0x83;
316 OpBuffer[obp++]=(char)(0xC0|REGISTER_OPERAND(reg));
317 OpBuffer[obp++]=cValue;
318}
319void op_add_RM(int op_size,int reg,int base_reg,int offset,char mod){
320 //add reg32,dword ptr[base_reg+offset]
321 //add reg16,word ptr[base_reg+offset]
322 //add reg8,byte ptr[base_reg+offset]
323
324 //16ビット演算の命令プリフィックス
325 char op_prefix=0;
326 if(op_size==sizeof(short)) op_prefix=(char)0x66;
327
328 //オペコード
329 char opcode;
330 if(op_size==sizeof(char)) opcode=(char)0x02;
331 else opcode=(char)0x03;
332
333 __op_format(op_prefix,opcode,0,reg,base_reg,offset,mod);
334}
335void op_adc_RV8(int reg,char cValue){
336 //adc reg,value8
337
338 OpBuffer[obp++]=(char)0x83;
339 OpBuffer[obp++]=(char)(0xD0|REGISTER_OPERAND(reg));
340 OpBuffer[obp++]=cValue;
341}
342
343
344/////////////////////
345// sub関連
346/////////////////////
347
348void op_sub_RV8(int reg,char cValue){
349 //sub reg,value8
350
351 OpBuffer[obp++]=(char)0x83;
352 OpBuffer[obp++]=(char)(0xE8|REGISTER_OPERAND(reg));
353 OpBuffer[obp++]=cValue;
354}
355void op_sbb_RV8(int reg,char cValue){
356 //sbb reg,value8
357
358 OpBuffer[obp++]=(char)0x83;
359 OpBuffer[obp++]=(char)(0xD8|REGISTER_OPERAND(reg));
360 OpBuffer[obp++]=cValue;
361}
362void op_sbb_RR( int reg1, int reg2 ){
363 //sbb reg1,reg2
364
365 //オペコード
366 OpBuffer[obp++]=(char)0x1B;
367
368 //レジスタ
369 OpBuffer[obp++]=(char)(0xC0| REGISTER_OPERAND(reg1)<<3 | REGISTER_OPERAND(reg2));
370}
371
372
373
374
375//////////////////////
376// and関連
377//////////////////////
378
379void op_and_RV(int reg,int value){
380 //and reg,value
381
382 if(reg==REG_RAX){
383 //eaxのみ特殊
384
385 // [8bit rex] 0010 0101 [32bit offset]
386 OpBuffer[obp++]=(char)0x25;
387 *((long *)(OpBuffer+obp))=value;
388 obp+=sizeof(long);
389 }
390 else{
391 //16ビット演算の命令プリフィックス
392 char op_prefix=0;
393
394 //オペコード
395 char opcode=(char)0x81;
396
397 __op_format(op_prefix,opcode,0,0,reg,value,MOD_REG);
398 }
399}
400
401void op_or_RR( int op_size, int reg1, int reg2 ){
402 //16ビット演算のプリフィックス
403 if(op_size==sizeof(short)) OpBuffer[obp++]=(char)0x66;
404
405 //オペコード
406 if(op_size==sizeof(char)) OpBuffer[obp++]=(char)0x0A;
407 else OpBuffer[obp++]=(char)0x0B;
408
409 //レジスタ
410 OpBuffer[obp++]=(char)(0xC0| REGISTER_OPERAND(reg1)<<3 | REGISTER_OPERAND(reg2));
411}
412
413
414
415void op_neg( int reg ){
416 //neg reg
417
418 //オペコード
419 OpBuffer[obp++]=(char)0xF7;
420
421 //レジスタ
422 OpBuffer[obp++]=(char)(0xD8| REGISTER_OPERAND(reg));
423}
424
425
426
427///////////////////////
428// 64ビット関連
429///////////////////////
430
431void op_cdq(){
432 //cdq
433 OpBuffer[obp++]=(char)0x99;
434}
435
436
437
438/////////////////////
439// ストリング関係
440/////////////////////
441
442void op_rep_movs(int op_size){
443 if(op_size==sizeof(BYTE)){
444 //rep movs byte ptr[edi],byte ptr[esi]
445 OpBuffer[obp++]=(char)0xF3;
446 OpBuffer[obp++]=(char)0xA4;
447 }
448 else if(op_size==sizeof(short)){
449 //rep movs word ptr[edi],word ptr[esi]
450 OpBuffer[obp++]=(char)0xF3;
451 OpBuffer[obp++]=(char)0x66;
452 OpBuffer[obp++]=(char)0xA5;
453 }
454 else if(op_size==sizeof(long)){
455 //rep movs dword ptr[edi],dword ptr[esi]
456 OpBuffer[obp++]=(char)0xF3;
457 OpBuffer[obp++]=(char)0xA5;
458 }
459}
460
461
462
463
464//////////////////////////
465// スタック関連
466//////////////////////////
467
468void op_push(int reg){
469 //push reg
470
471 //オペコード、レジスタ
472 __op_format(0,(char)0x50,reg);
473}
474void op_push_value(long data){
475 //スタックにリテラル値をプッシュ
476 if(-128<=data&&data<=127){
477 //push 8ビット値
478 OpBuffer[obp++]=(char)0x6A;
479 OpBuffer[obp++]=(char)data;
480 }
481 else{
482 //push 32ビット値
483 OpBuffer[obp++]=(char)0x68;
484 *((long *)(OpBuffer+obp))=data;
485 obp+=sizeof(long);
486 }
487}
488void op_pop(int reg){
489 //pop reg
490
491 //オペコード、レジスタ
492 __op_format(0,(char)0x58,reg);
493}
494void op_add_esp(int num){
495 //スタックポインタの加算(pop方向)
496
497 //add esp,num
498 if(0xFFFFFF80&num){
499 OpBuffer[obp++]=(char)0x81;
500 OpBuffer[obp++]=(char)0xC4;
501 *((long *)(OpBuffer+obp))=num;
502 obp+=sizeof(long);
503 }
504 else{
505 //「128 > num > -127」の場合
506 OpBuffer[obp++]=(char)0x83;
507 OpBuffer[obp++]=(char)0xC4;
508 OpBuffer[obp++]=(char)num;
509 }
510}
511void op_sub_esp(int num){
512 //スタックポインタの減算(push方向)
513
514 //sub esp,num
515 if(0xFFFFFF80&num){
516 OpBuffer[obp++]=(char)0x81;
517 OpBuffer[obp++]=(char)0xEC;
518 *((long *)(OpBuffer+obp))=num;
519 obp+=sizeof(long);
520 }
521 else{
522 //「128 > num > -127」の場合
523 OpBuffer[obp++]=(char)0x83;
524 OpBuffer[obp++]=(char)0xEC;
525 OpBuffer[obp++]=(char)num;
526 }
527}
528
529
530
531/////////////////////
532// cmp関連
533/////////////////////
534void op_cmp_value(int op_size,int reg,char byte_data){
535 //cmp reg,byte_data
536
537 if(op_size==sizeof(char)&&reg==REG_EAX){
538 //alレジスタの場合は特殊
539 OpBuffer[obp++]=(char)0x3C;
540
541 //8ビット値
542 OpBuffer[obp++]=byte_data;
543
544 return;
545 }
546
547 //16ビット演算のプリフィックス
548 if(op_size==sizeof(short)) OpBuffer[obp++]=(char)0x66;
549
550 //オペコード
551 if(op_size==sizeof(char)) OpBuffer[obp++]=(char)0x80;
552 else OpBuffer[obp++]=(char)0x83;
553
554 //レジスタ
555 OpBuffer[obp++]=(char)(0xF8| REGISTER_OPERAND(reg));
556
557 //8ビット値
558 OpBuffer[obp++]=byte_data;
559}
560void op_setne( int reg ){
561 //オペコード
562 OpBuffer[obp++]=(char)0x0F;
563 OpBuffer[obp++]=(char)0x95;
564
565 //レジスタ
566 OpBuffer[obp++]=(char)( 0xC0 | REGISTER_OPERAND(reg) );
567}
568
569
570
571////////////////////
572// test関連
573////////////////////
574
575void op_test(int reg1,int reg2){
576 //test reg1,reg2
577
578 //1000 0101 11rr rbbb
579 OpBuffer[obp++]=(char)0x85;
580 OpBuffer[obp++]=(char)(0xC0| REGISTER_OPERAND(reg1)<<3 | REGISTER_OPERAND(reg2));
581}
582
583
584
585//////////////////////////////
586// 浮動小数点関連
587//////////////////////////////
588
589void op_fld_ptr_esp(int type){
590 //スタックポインタが示すバッファのデータを浮動小数点レジスタへロード
591
592 if(type==DEF_DOUBLE){
593 //fld qword ptr[esp]
594 OpBuffer[obp++]=(char)0xDD;
595 OpBuffer[obp++]=(char)0x04;
596 OpBuffer[obp++]=(char)0x24;
597 }
598 else if(type==DEF_SINGLE){
599 //fld dword ptr[esp]
600 OpBuffer[obp++]=(char)0xD9;
601 OpBuffer[obp++]=(char)0x04;
602 OpBuffer[obp++]=(char)0x24;
603 }
604 else if(type==DEF_INT64){
605 //fild qword ptr[esp]
606 OpBuffer[obp++]=(char)0xDF;
607 OpBuffer[obp++]=(char)0x2C;
608 OpBuffer[obp++]=(char)0x24;
609 }
610 else if(type==DEF_LONG){
611 //fild dword ptr[esp]
612 OpBuffer[obp++]=(char)0xDB;
613 OpBuffer[obp++]=(char)0x04;
614 OpBuffer[obp++]=(char)0x24;
615 }
616}
617void op_fld_basereg(int type,int base_reg){
618 //fld ptr[reg]
619
620 //オペコード
621 if(type==DEF_DOUBLE) OpBuffer[obp++]=(char)0xDD;
622 else if(type==DEF_SINGLE) OpBuffer[obp++]=(char)0xD9;
623 else SetError(300,NULL,cp);
624
625 if(base_reg==REG_ESP){
626 OpBuffer[obp++]=(char)0x04;
627 OpBuffer[obp++]=(char)0x24;
628 }
629 else if(base_reg==REG_EBP){
630 OpBuffer[obp++]=(char)0x45;
631 OpBuffer[obp++]=(char)0x00;
632 }
633 else{
634 OpBuffer[obp++]=(char)REGISTER_OPERAND(base_reg);
635 }
636}
637void op_fld_base_offset(int type,int base_reg,int offset){
638 //fld ptr[reg+offset]
639
640 //オペコード
641 if(type==DEF_DOUBLE) OpBuffer[obp++]=(char)0xDD;
642 else if(type==DEF_SINGLE) OpBuffer[obp++]=(char)0xD9;
643 else SetError(300,NULL,cp);
644
645 //オペコード、レジスタ
646 if(base_reg==REG_ESP){
647 OpBuffer[obp++]=(char)0x84;
648 OpBuffer[obp++]=(char)0x24;
649 }
650 else{
651 OpBuffer[obp++]=(char)(0x80|REGISTER_OPERAND(base_reg));
652 }
653
654 //オフセット値
655 *((long *)(OpBuffer+obp))=offset;
656 obp+=sizeof(long);
657}
658void op_fld_base_offset_ex(int type,int base_reg1,int base_reg2,int offset,BOOL bUseOffset){
659 //fld ptr[base_reg1+base_reg2+offset]
660
661 if(base_reg1==REG_ESP){
662 //SIBバイトのindex部にespは指定できない
663 base_reg1=base_reg2;
664 base_reg2=REG_ESP;
665 }
666
667 //オペコード
668 if(type==DEF_DOUBLE) OpBuffer[obp++]=(char)0xDD;
669 else if(type==DEF_SINGLE) OpBuffer[obp++]=(char)0xD9;
670 else SetError(300,NULL,cp);
671
672 int reg=0;
673 if(bUseOffset){
674 ///////////////////////////
675 // オフセット値を使う
676 ///////////////////////////
677
678 //レジスタ
679 OpBuffer[obp++]=(char)(0x84| REGISTER_OPERAND(reg)<<3);
680
681 //ベースレジスタ
682 OpBuffer[obp++]=(char)(REGISTER_OPERAND(base_reg1)<<3 | REGISTER_OPERAND(base_reg2));
683
684 //オフセット値
685 *((long *)(OpBuffer+obp))=offset;
686 obp+=sizeof(long);
687 }
688 else{
689 ///////////////////////////
690 // オフセット値を使わない
691 ///////////////////////////
692
693 //レジスタ
694 OpBuffer[obp++]=(char)(0x04| REGISTER_OPERAND(reg)<<3);
695
696 //ベースレジスタ
697 OpBuffer[obp++]=(char)(REGISTER_OPERAND(base_reg1)<<3 | REGISTER_OPERAND(base_reg2));
698 }
699}
700void op_fstp_basereg(int type,int base_reg){
701 //fstp ptr[reg]
702
703 //オペコード
704 if(type==DEF_DOUBLE) OpBuffer[obp++]=(char)0xDD;
705 else if(type==DEF_SINGLE) OpBuffer[obp++]=(char)0xD9;
706 else SetError(300,NULL,cp);
707
708 if(base_reg==REG_ESP){
709 OpBuffer[obp++]=(char)0x1C;
710 OpBuffer[obp++]=(char)0x24;
711 }
712 else if(base_reg==REG_EBP){
713 OpBuffer[obp++]=(char)0x5D;
714 OpBuffer[obp++]=(char)0x00;
715 }
716 else{
717 OpBuffer[obp++]=(char)(0x18|REGISTER_OPERAND(base_reg));
718 }
719}
720void op_fstp_base_offset(int type,int base_reg,int offset){
721 //fstp ptr[reg+offset]
722
723 //オペコード
724 if(type==DEF_DOUBLE) OpBuffer[obp++]=(char)0xDD;
725 else if(type==DEF_SINGLE) OpBuffer[obp++]=(char)0xD9;
726 else SetError(300,NULL,cp);
727
728 //オペコード、レジスタ
729 if(base_reg==REG_ESP){
730 OpBuffer[obp++]=(char)0x9C;
731 OpBuffer[obp++]=(char)0x24;
732 }
733 else{
734 OpBuffer[obp++]=(char)(0x98|REGISTER_OPERAND(base_reg));
735 }
736
737 //オフセット値
738 *((long *)(OpBuffer+obp))=offset;
739 obp+=sizeof(long);
740}
741void op_fstp_base_offset_ex(int type,int base_reg1,int base_reg2,int offset,BOOL bUseOffset){
742 //fstp ptr[base_reg1+base_reg2+offset]
743
744 if(base_reg1==REG_ESP){
745 //SIBバイトのindex部にespは指定できない
746 base_reg1=base_reg2;
747 base_reg2=REG_ESP;
748 }
749
750 //オペコード
751 if(type==DEF_DOUBLE) OpBuffer[obp++]=(char)0xDD;
752 else if(type==DEF_SINGLE) OpBuffer[obp++]=(char)0xD9;
753 else SetError(300,NULL,cp);
754
755 int reg=0;
756 if(bUseOffset){
757 ///////////////////////////
758 // オフセット値を使う
759 ///////////////////////////
760
761 //レジスタ
762 OpBuffer[obp++]=(char)(0x9C| REGISTER_OPERAND(reg)<<3);
763
764 //ベースレジスタ
765 OpBuffer[obp++]=(char)(REGISTER_OPERAND(base_reg1)<<3 | REGISTER_OPERAND(base_reg2));
766
767 //オフセット値
768 *((long *)(OpBuffer+obp))=offset;
769 obp+=sizeof(long);
770 }
771 else{
772 ///////////////////////////
773 // オフセット値を使わない
774 ///////////////////////////
775
776 //レジスタ
777 OpBuffer[obp++]=(char)(0x1C| REGISTER_OPERAND(reg)<<3);
778
779 //ベースレジスタ
780 OpBuffer[obp++]=(char)(REGISTER_OPERAND(base_reg1)<<3 | REGISTER_OPERAND(base_reg2));
781 }
782}
783
784
785
786//////////////////////////////
787// レジスタ関連
788//////////////////////////////
789
790void op_zero_reg(int reg){
791 //レジスタに0をセット
792
793 switch(reg){
794 case REG_EAX:
795 //xor eax,eax
796 OpBuffer[obp++]=(char)0x33;
797 OpBuffer[obp++]=(char)0xC0;
798 break;
799 case REG_EBX:
800 //xor ebx,ebx
801 OpBuffer[obp++]=(char)0x33;
802 OpBuffer[obp++]=(char)0xDB;
803 break;
804 case REG_ECX:
805 //xor ecx,ecx
806 OpBuffer[obp++]=(char)0x33;
807 OpBuffer[obp++]=(char)0xC9;
808 break;
809 case REG_EDX:
810 //xor edx,edx
811 OpBuffer[obp++]=(char)0x33;
812 OpBuffer[obp++]=(char)0xD2;
813 break;
814 case REG_EBP:
815 //xor ebp,ebp
816 OpBuffer[obp++]=(char)0x33;
817 OpBuffer[obp++]=(char)0xED;
818 break;
819 }
820}
821
822void fpu_cast(){
823 ///////////////////////
824 // FPUの切り捨て設定
825 ///////////////////////
826
827 //sub esp,16
828 op_sub_esp(16);
829
830 //mov dword ptr[esp+4],eax
831 OpBuffer[obp++]=(char)0x89;
832 OpBuffer[obp++]=(char)0x44;
833 OpBuffer[obp++]=(char)0x24;
834 OpBuffer[obp++]=(char)0x04;
835
836 //fnstcw word ptr[esp]
837 OpBuffer[obp++]=(char)0xD9;
838 OpBuffer[obp++]=(char)0x3C;
839 OpBuffer[obp++]=(char)0x24;
840
841 //mov ax,word ptr[esp]
842 OpBuffer[obp++]=(char)0x66;
843 OpBuffer[obp++]=(char)0x8B;
844 OpBuffer[obp++]=(char)0x04;
845 OpBuffer[obp++]=(char)0x24;
846
847 //or ah,0Ch
848 OpBuffer[obp++]=(char)0x80;
849 OpBuffer[obp++]=(char)0xCC;
850 OpBuffer[obp++]=(char)0x0C;
851
852 //mov word ptr[esp+2],ax
853 OpBuffer[obp++]=(char)0x66;
854 OpBuffer[obp++]=(char)0x89;
855 OpBuffer[obp++]=(char)0x44;
856 OpBuffer[obp++]=(char)0x24;
857 OpBuffer[obp++]=(char)0x02;
858
859 //fldcw word ptr[esp+2]
860 OpBuffer[obp++]=(char)0xD9;
861 OpBuffer[obp++]=(char)0x6C;
862 OpBuffer[obp++]=(char)0x24;
863 OpBuffer[obp++]=(char)0x02;
864
865 //mov eax,dword ptr[esp+4]
866 OpBuffer[obp++]=(char)0x8B;
867 OpBuffer[obp++]=(char)0x44;
868 OpBuffer[obp++]=(char)0x24;
869 OpBuffer[obp++]=(char)0x04;
870
871 //add esp,16
872 op_add_esp(16);
873}
874void fpu_cast_end(){
875 //sub esp,16
876 op_sub_esp(16);
877
878 //fldcw word ptr[esp]
879 OpBuffer[obp++]=(char)0xD9;
880 OpBuffer[obp++]=(char)0x2C;
881 OpBuffer[obp++]=(char)0x24;
882
883 //add esp,16
884 op_add_esp(16);
885}
886
887
888/////////////////////////////
889// 関数呼び出し
890/////////////////////////////
891
892void op_call(SUBINFO *psi){
893 OpBuffer[obp++]=(char)0xE8;
894 pobj_SubAddrSchedule->add(psi,1);
895 psi->bUse=1;
896 obp+=sizeof(long);
897}
Note: See TracBrowser for help on using the repository browser.