Mercurial > hg > CbC > old > device
annotate mc-code-ia32.c @ 230:d60c6c31f63a
*** empty log message ***
author | kono |
---|---|
date | Wed, 28 Apr 2004 15:06:01 +0900 (2004-04-28) |
parents | 8675ea3d2c7f |
children | c575422d8b6e |
rev | line source |
---|---|
61 | 1 /* Micro-C Code Generatation Part for intel386 */ |
2 /* $Id$ */ | |
3 | |
4 #define EXTERN extern | |
5 #include "mc.h" | |
6 #include "mc-codegen.h" | |
93 | 7 #include "mc-code.h" |
61 | 8 |
173 | 9 char *l_include_path[] = { |
10 "/usr/include/", | |
182 | 11 "/usr/include/linux/", |
225 | 12 "/usr/include/diet/", |
13 "/usr/lib/gcc-lib/i386-linux/2.95.4/include/", | |
183 | 14 "/usr/lib/gcc-lib/i386-redhat-linux/2.96/include/", |
173 | 15 0 |
16 }; | |
17 | |
18 | |
94 | 19 #define SAVE_STACKS 1 |
20 | |
61 | 21 #define TEXT_EMIT_MODE 0 |
22 #define DATA_EMIT_MODE 1 | |
23 #define RODATA_EMIT_MODE 2 | |
24 | |
25 static int output_mode = TEXT_EMIT_MODE; | |
26 static int data_alignment = 0; | |
27 | |
224 | 28 static int creg; |
29 | |
119 | 30 int size_of_int = 4; |
165 | 31 int size_of_short = 2; |
119 | 32 int size_of_float = 4; |
33 int size_of_double = 8; | |
34 int size_of_longlong = 8; | |
35 int endian = 0; | |
36 int MAX_REGISTER=6; /* intel386�Υ쥸������6�ĤޤǻȤ�*/ | |
37 #define REAL_MAX_REGISTER 8 /* intel386�Υ쥸������8�ĤȤ�������*/ | |
38 int MAX_DATA_REG=4; | |
39 int MAX_POINTER=3; | |
40 int MAX_REGISTGER_VAR=2; | |
41 int MAX_FREGISTER=1; | |
42 | |
43 #define MAX_FPU_STACK 7 | |
44 | |
45 int MAX_INPUT_REGISTER_VAR = 0; | |
46 int MAX_CODE_INPUT_REGISTER_VAR = 2; | |
47 int MAX_INPUT_DREGISTER_VAR = 0; | |
138 | 48 int MAX_INPUT_FREGISTER_VAR = 0; |
119 | 49 int MAX_CODE_INPUT_DREGISTER_VAR = 0; |
61 | 50 |
138 | 51 int reg_sp; /* REGister Stack-Pointer */ |
52 int reg_stack[MAX_MAX]; /* �ºݤΥ쥸�������ΰ� */ | |
53 | |
54 /* floating point registers */ | |
55 | |
56 int freg_sp; /* floating point REGister Stack-Pointer */ | |
57 int freg_stack[MAX_MAX]; /* �ºݤΥ쥸�������ΰ� */ | |
58 | |
59 | |
61 | 60 /* |
128 | 61 -28 -8 local2 |
62 -24 -4 local1 | |
63 -20 8 arg3 | |
64 -16 4 arg2 | |
65 -12 0 arg1 | |
66 local2 -20 4 -8 (%edi) | |
67 local1 <-- -16 0 local variable -4 (%esi) | |
61 | 68 %edi -12 <- disp_offset %ebp |
69 %esi -8 | |
70 %ebx -4 | |
71 %ebp = %esp 0 | |
72 %eip 4 <- arg_offset | |
73 arg1 8 0 | |
74 arg2 12 4 | |
75 see enter/enter1/leave see code_enter | |
76 */ | |
77 int arg_offset = 8; | |
78 int disp_offset = -12; | |
79 int func_disp_offset = -12; | |
80 int code_disp_offset = 0; | |
81 int jump_offset = 0; | |
82 | |
119 | 83 static int code_disp_label; |
84 static int func_disp_label; | |
61 | 85 |
119 | 86 static int |
87 lvar(int l) | |
88 { | |
89 if (is_code(fnptr)) { | |
90 return l+code_disp_offset; | |
91 } else if (l<0) { | |
92 return l+disp_offset; | |
93 } else { | |
94 return l+arg_offset; | |
95 } | |
96 } | |
99 | 97 |
95 | 98 /* |
99 creg currrent virtual register | |
100 dreg spare virtual register | |
101 | |
102 rname[creg] currrent real register | |
103 rname[dreg] spare real register | |
104 | |
105 regs[] virtual register usage | |
106 regv[] value in virtual register flag | |
107 | |
108 reg_name[rname[creg]] | |
109 | |
110 freg current floating point register | |
111 fregv calue in floating point register | |
112 */ | |
113 | |
114 static int dreg; /* general temporal register */ | |
115 | |
205 | 116 static int ia32regs[REAL_MAX_REGISTER]; |
117 static int ia32regv[REAL_MAX_REGISTER]; | |
118 static int ia32rname[REAL_MAX_REGISTER]; | |
95 | 119 |
205 | 120 static int *regv = ia32regv; |
121 static int *regs = ia32regs; | |
95 | 122 static int *rname = ia32rname; |
123 | |
205 | 124 static int ia32fregs[1]; |
125 static int ia32fregv[1]; | |
95 | 126 |
205 | 127 static int freg; |
128 static int *fregv = ia32fregv; | |
129 static int *fregs = ia32fregs; | |
95 | 130 |
61 | 131 |
132 #define REG_EAX 0 | |
133 #define REG_EBX 1 | |
134 #define REG_ECX 2 | |
135 #define REG_EDX 3 | |
136 #define REG_ESI 4 | |
137 #define REG_EDI 5 | |
138 #define REG_EBP 6 | |
139 #define REG_ESP 7 | |
140 | |
141 | |
142 #define DATA_REG 0 | |
143 #define POINTER_REG 3 | |
144 static char *reg_name[8]; | |
145 static char *reg_name_l[4]; | |
146 static char *reg_name_w[4]; | |
147 | |
93 | 148 static void use_register(int virt, int real, int move); |
149 static int virtual(int real); | |
150 static void shift(char *op, int reg); | |
163 | 151 static void ld_indexx(int byte, int n, int xreg,int sign); |
93 | 152 static void data_mode(char *name); |
153 static int edx_setup(); | |
154 static void edx_cleanup(); | |
155 static void local_table(void); | |
195 | 156 #if FLOAT_CODE |
93 | 157 static char * fload(int d); |
158 static int code_d1(double d); | |
159 static int code_d2(double d); | |
195 | 160 static void code_save_fstacks(); |
161 #endif | |
94 | 162 static void code_save_stacks(); |
82 | 163 |
61 | 164 void |
165 code_init(void) | |
166 { | |
173 | 167 macro_define("__i386__ 1\n"); |
182 | 168 macro_define("__LITTLE_ENDIAN__ 1\n"); |
169 macro_define("__STDC__ 1\n"); | |
170 macro_define("size_t int\n"); | |
171 macro_define("__externsion__\n"); | |
172 macro_define("__flexarr\n"); | |
183 | 173 macro_define("__builtin_va_list int*\n"); |
174 macro_define("wchar_t int\n"); | |
225 | 175 macro_define("__THROW\n"); |
173 | 176 |
61 | 177 arg_offset = 8; |
178 func_disp_offset = -12; | |
179 disp_offset = -12; | |
180 size_of_int = 4; | |
181 endian = 0; | |
182 MAX_REGISTER=6; | |
183 MAX_DATA_REG=4; | |
184 MAX_POINTER=3; | |
185 MAX_REGISTER_VAR=2; | |
186 | |
187 reg_name[REG_EAX] = "%eax"; | |
188 reg_name[REG_EBX] = "%ebx"; | |
189 reg_name[REG_ECX] = "%ecx"; | |
190 reg_name[REG_EDX] = "%edx"; | |
191 reg_name[REG_ESI] = "%esi"; | |
192 reg_name[REG_EDI] = "%edi"; | |
193 reg_name[REG_EBP] = "%ebp"; | |
194 reg_name[REG_ESP] = "%esp"; | |
195 reg_name_l[REG_EAX] = "%al"; | |
196 reg_name_l[REG_EBX] = "%bl"; | |
197 reg_name_l[REG_ECX] = "%cl"; | |
198 reg_name_l[REG_EDX] = "%dl"; | |
199 reg_name_w[REG_EAX] = "%ax"; | |
200 reg_name_w[REG_EBX] = "%bx"; | |
201 reg_name_w[REG_ECX] = "%cx"; | |
202 reg_name_w[REG_EDX] = "%dx"; | |
203 | |
204 } | |
205 | |
206 char * | |
207 register_name(int i,int byte) | |
208 { | |
209 if (i<0) { | |
210 error(REG_ERR); | |
211 return "%eax"; | |
212 } | |
165 | 213 if (byte==1 && rname[i] <= REG_EDX) { |
61 | 214 return reg_name_l[rname[i]]; |
165 | 215 } else if (byte==size_of_short && rname[i] <= REG_EDX) { |
216 return reg_name_w[rname[i]]; | |
61 | 217 } else { |
168 | 218 return reg_name[rname[i]]; /* 0 or 4 means int */ |
61 | 219 } |
220 } | |
221 | |
147 | 222 int use_int(int i) { return i;} |
223 int use_float(int i) { return i;} | |
224 int use_double(int i) { return i;} | |
195 | 225 int use_longlong(int i) { return i; } |
226 | |
147 | 227 |
61 | 228 void |
229 gexpr_code_init(void){ | |
230 use_register(creg,REG_EAX,0); | |
94 | 231 regv[creg]=0; |
61 | 232 regv[dreg]=0; |
233 } | |
234 | |
147 | 235 void |
236 code_gexpr(int e){ | |
237 } | |
238 | |
89 | 239 int |
240 get_register(void) | |
241 { /* �Ȥ��Ƥ��ʤ��쥸������Ĵ�٤� */ | |
242 int i; | |
243 for(i=0;i<MAX_REGISTER;i++) { | |
244 if (! regs[i]) { /* �Ȥ��Ƥ��ʤ��ʤ� */ | |
245 regs[i]=1; /* ���Υ쥸������Ȥ����Ȥ������ */ | |
246 return i; /* ���ξ���ɽ���ֹ���֤� */ | |
247 } | |
248 } | |
249 return -1; /* �����Ƥ����꤬�ʤ��ʤ顢�����ɽ�� -1 ���֤� */ | |
250 } | |
251 | |
252 void | |
253 free_register(int i) { /* ����ʤ��ʤä��쥸�������� */ | |
254 regv[i]=regs[i]=0; | |
255 } | |
256 | |
99 | 257 int |
126 | 258 get_input_register_var(int i,NMTBL *nptr,int is_code) |
99 | 259 { |
126 | 260 if (is_code) { |
261 if (i>=MAX_CODE_INPUT_REGISTER_VAR) return 0; | |
262 i = virtual(i+REG_ESI); | |
263 regs[i]=regv[i]=1; | |
264 return list3(REGISTER,i,(int)nptr); | |
265 } else { | |
266 return 0; | |
267 } | |
99 | 268 } |
103 | 269 |
99 | 270 int |
138 | 271 get_input_dregister_var(int i,NMTBL *nptr,int is_code,int d) |
99 | 272 { |
126 | 273 return 0; |
99 | 274 } |
275 | |
276 int | |
138 | 277 get_dregister(int d) |
99 | 278 { |
279 return -1; | |
280 } | |
281 | |
195 | 282 int |
283 get_lregister_var(NMTBL *n) | |
284 { | |
204 | 285 return list2(LVAR,new_lvar(size_of_longlong)); |
195 | 286 } |
287 | |
205 | 288 int |
289 get_lregister() | |
290 { | |
291 return -1; | |
292 } | |
293 | |
294 | |
89 | 295 int |
296 register_full(void) | |
297 { | |
298 int i; | |
299 for(i=0;i<MAX_REGISTER;i++) { | |
300 if (! regs[i]) { | |
301 return 0; | |
302 } | |
303 } | |
304 return 1; | |
305 } | |
306 | |
307 int | |
137 | 308 free_register_count(int d) |
89 | 309 { |
310 int i,count; | |
311 count = 0; | |
312 for(i=0;i<MAX_REGISTER;i++) { | |
313 if (! regs[i] && ! regv[i]) count++; | |
314 } | |
137 | 315 return d?0:count; |
89 | 316 } |
317 | |
318 void | |
319 free_all_register(void) | |
320 { | |
321 int i; | |
322 for(i=0;i<MAX_REGISTER;i++) { | |
323 regs[i]=regv[i]=0; | |
324 } | |
325 creg = get_register(); | |
326 dreg = get_register(); | |
327 return; | |
328 } | |
329 | |
330 | |
331 void | |
332 register_usage(char *s) | |
333 { | |
334 int i; | |
335 if (chk) return; | |
336 printf("# %d: %s:",lineno,s); | |
337 printf(" creg=%s dreg=%s ",register_name(creg,0),register_name(dreg,0)); | |
338 for(i=0;i<MAX_REGISTER;i++) { | |
339 printf("%d",regs[i]); | |
340 } | |
341 printf(":"); | |
342 for(i=0;i<MAX_REGISTER;i++) { | |
343 printf("%d",regv[i]); | |
344 } | |
345 #if 0 | |
346 printf(" regs_stack",register_name(creg,0),register_name(dreg,0)); | |
347 for(i=reg_sp;i>=0;i--) { | |
348 if(reg_stack[i]>=0) | |
349 printf(" %s",register_name(reg_stack[i],0)); | |
350 } | |
351 #endif | |
94 | 352 printf(" f:%d",freg_sp); |
89 | 353 printf("\n"); |
354 } | |
355 | |
109 | 356 void |
137 | 357 code_arg_register(NMTBL *fnptr) |
109 | 358 { |
137 | 359 int args = fnptr->dsp; |
360 NMTBL *n; | |
361 int reg_var = 0; | |
362 int freg_var = 0; | |
363 int type; | |
364 int reg; | |
365 int is_code0 = is_code(fnptr); | |
366 | |
367 while (args) { | |
368 /* process in reverse order */ | |
369 n = (NMTBL*)caddr(args); | |
370 type = n->ty; | |
371 if (scalar(type)) { | |
372 if ((reg = get_input_register_var(reg_var,n,is_code0))) { | |
373 n->sc = REGISTER; | |
374 n->dsp = cadr(reg); | |
375 regv[n->dsp]= 1; | |
376 regs[n->dsp]= INPUT_REG; | |
377 reg_var++; | |
378 cadddr(args)=size_of_int; /* why we need this? */ | |
379 } | |
380 } else if (type==FLOAT||type==DOUBLE) { | |
138 | 381 if ((reg = get_input_dregister_var(freg_var,n,is_code0,1))) { |
137 | 382 n->sc = DREGISTER; |
383 n->dsp = cadr(reg); | |
384 fregv[n->dsp]= 1; | |
385 fregs[n->dsp]= INPUT_REG; | |
386 freg_var++; | |
387 cadddr(args)=size(type); /* why we need this? */ | |
388 } | |
389 } | |
390 args = cadr(args); | |
391 } | |
109 | 392 } |
393 | |
89 | 394 void |
395 gexpr_init(void) | |
396 { | |
397 while(reg_sp > 0) { | |
94 | 398 if (reg_stack[--reg_sp]>=0) |
399 free_register(reg_stack[reg_sp]); | |
89 | 400 } |
94 | 401 freg_sp = 0; |
89 | 402 text_mode(); |
403 gexpr_code_init(); | |
404 register_usage("gexpr_init"); | |
405 } | |
406 | |
407 | |
408 void | |
409 emit_init(void) | |
410 { | |
411 int i; | |
412 for(i=0;i<MAX_REGISTER;i++) { regs[i]=0; regv[i]=0;rname[i]=i;} | |
413 free_all_register(); | |
414 reg_sp = 0; | |
94 | 415 freg_sp = 0; |
89 | 416 text_mode(); |
417 } | |
418 | |
419 int | |
420 virtual(int real) | |
421 { | |
422 int real_v,i; | |
423 real_v = -1; | |
424 for(i=0;i<MAX_REGISTER;i++) { | |
425 if (rname[i]==real) { | |
426 real_v=i; | |
427 break; | |
428 } | |
429 } | |
430 return real_v; | |
431 } | |
432 | |
433 int | |
434 pop_register(void) | |
435 { /* �쥸���������ͤ���Ф� */ | |
436 return reg_stack[--reg_sp]; | |
437 } | |
438 | |
439 void | |
440 emit_pop_free(int xreg) | |
441 { | |
159 | 442 if (xreg==dreg||xreg==creg) { |
89 | 443 regv[dreg]=0; |
98 | 444 } else if (xreg>=0) { |
89 | 445 free_register(xreg); |
446 } | |
447 } | |
448 | |
449 | |
61 | 450 int |
105 | 451 get_register_var(NMTBL *nptr) |
61 | 452 { |
453 int i; | |
454 for(i=REG_ESI;i<REG_ESP;i++) { | |
455 if (! regs[i]) { /* �Ȥ��Ƥ��ʤ��ʤ� */ | |
456 regs[i]=1; /* ���Υ쥸������Ȥ����Ȥ������ */ | |
457 regv[i]=0; | |
105 | 458 return list3(REGISTER,i,(int)nptr); /* ���ξ���ɽ���ֹ���֤� */ |
61 | 459 } |
460 } | |
104 | 461 return list2(LVAR,new_lvar(size_of_int)); |
462 } | |
463 | |
464 int | |
138 | 465 get_dregister_var(NMTBL *nptr,int d) |
104 | 466 { |
138 | 467 return list2(LVAR,new_lvar(d?size_of_double:size_of_float)); |
137 | 468 } |
469 | |
61 | 470 void |
471 use_register(int virt, int real, int move) | |
472 { | |
473 int real_v; | |
474 char *move_op; | |
475 if (rname[virt]==real) | |
476 return; | |
477 real_v = virtual(real); | |
478 move_op = regs[real_v]?"\txchg %s,%s\n":"\tmovl %s,%s\n"; | |
479 if (move || (regv[real_v])) { | |
480 printf(move_op,reg_name[rname[virt]],reg_name[real]); | |
481 } | |
482 rname[real_v] = rname[virt]; | |
483 rname[virt] = real; | |
484 } | |
485 | |
486 void | |
487 use_pointer(int virt, int move) | |
488 { | |
489 int i; | |
490 if (rname[virt]>=POINTER_REG) | |
491 return; | |
492 for(i=POINTER_REG;i<MAX_REGISTER;i++) { | |
493 if (!regs[virtual(i)]) { | |
494 use_register(virt,i,move); | |
495 return; | |
496 } | |
497 } | |
498 /* we prefer EBX */ | |
499 use_register(virt,REG_EBX,move); | |
500 } | |
501 | |
502 void | |
503 use_data_reg(int virt, int move) | |
504 { | |
505 int i; | |
506 if (rname[virt]<MAX_DATA_REG) | |
507 return; | |
508 for(i=0;i<MAX_DATA_REG;i++) { | |
509 if (!regs[virtual(i)]) { | |
510 use_register(virt,i,move); | |
511 return; | |
512 } | |
513 } | |
514 /* we prefer EBX */ | |
515 use_register(virt,REG_EBX,move); | |
516 } | |
517 | |
518 | |
519 void | |
107 | 520 emit_push() |
61 | 521 { |
522 int new_reg; | |
523 new_reg = get_register(); | |
159 | 524 if (new_reg==creg) error(-1); |
61 | 525 if(new_reg<0) { /* �⤦�쥸�������ʤ� */ |
83 | 526 if (reg_sp>=MAX_MAX) error(-1); |
61 | 527 reg_stack[reg_sp++] = -1; |
528 printf("\tpushl %s\n",register_name(creg,0)); | |
529 /* creg is used soon, don't regv[creg]=0 */ | |
530 } else { | |
531 reg_stack[reg_sp++] = creg; /* push ���뤫���˥쥸������Ȥ� */ | |
532 creg = new_reg; | |
533 regv[creg]=1; | |
534 } | |
535 } | |
536 | |
537 int | |
538 emit_pop(int type) | |
539 { | |
540 int xreg; | |
541 if ((xreg=pop_register())==-1) { | |
542 if (type==POINTER_REG) | |
543 use_pointer(dreg,0); | |
544 else if (type==DATA_REG) | |
545 use_data_reg(dreg,0); | |
546 if (regv[dreg]) { | |
547 printf("# emit_pop dreg conflict\n"); | |
94 | 548 error(-1); |
61 | 549 } |
550 printf("\tpopl %s\n",register_name(dreg,0)); | |
94 | 551 regv[dreg]=1; |
552 return dreg; | |
553 } else if (xreg<= -REG_LVAR_OFFSET) { | |
119 | 554 code_rlvar(xreg+REG_LVAR_OFFSET,dreg); |
117 | 555 free_lvar(xreg+REG_LVAR_OFFSET); |
94 | 556 regv[dreg]=1; |
557 return dreg; | |
558 } | |
61 | 559 return xreg; |
560 } | |
561 | |
186 | 562 int |
563 stack_top(int type) | |
564 { | |
565 int xreg; | |
566 if (type==INT) { | |
567 xreg = reg_stack[reg_sp]; | |
568 if (xreg<= -REG_LVAR_OFFSET) { | |
569 return list2(LVAR,REG_LVAR_OFFSET+xreg); | |
570 } else { | |
571 return list2(REGISTER,xreg); | |
572 } | |
573 } else { | |
574 xreg = freg_stack[freg_sp]; | |
575 if (xreg<= -REG_LVAR_OFFSET) { | |
576 return list2(LVAR,REG_LVAR_OFFSET+xreg); | |
187 | 577 } else { |
186 | 578 return list2(DREGISTER,xreg); |
579 } | |
580 } | |
581 return xreg; | |
582 } | |
583 | |
584 | |
585 | |
92 | 586 void |
587 code_label(int labelno) | |
588 { | |
589 printf("_%d:\n",labelno); | |
590 } | |
61 | 591 |
592 void | |
107 | 593 code_gvar(int e1,int creg) { |
109 | 594 printf("\tmovl $%s,%s\n",((NMTBL*)cadr(e1))->nm,register_name(creg,0)); |
107 | 595 regv[creg]=1; |
61 | 596 } |
597 | |
598 | |
599 void | |
107 | 600 code_rgvar(int e1,int creg) { |
109 | 601 printf("\tmovl %s,%s\n",((NMTBL*)cadr(e1))->nm,register_name(creg,0)); |
107 | 602 regv[creg]=1; |
61 | 603 } |
166 | 604 static char *cload(int sign,int sz) { return sz==1?(sign?"movsbl":"movzbl"):sz==size_of_short?(sign?"movswl":"movzwl"):"movl"; } |
61 | 605 void |
165 | 606 code_crgvar(int e1,int creg,int sign,int sz){ |
607 printf("\t%s %s,%s\n",cload(sign,sz), | |
163 | 608 ((NMTBL*)cadr(e1))->nm,register_name(creg,0)); |
107 | 609 regv[creg]=1; |
61 | 610 } |
611 | |
612 | |
613 void | |
107 | 614 code_lvar(int e2,int creg) { |
119 | 615 printf("\tlea %d(%%ebp),%s\n",lvar(e2),register_name(creg,0)); |
107 | 616 regv[creg]=1; |
61 | 617 } |
618 | |
619 | |
620 void | |
107 | 621 code_register(int e2,int creg) { |
61 | 622 printf("\tmovl %s,%s\n",register_name(e2,0),register_name(creg,0)); |
107 | 623 regv[creg]=1; |
61 | 624 } |
625 | |
626 | |
627 void | |
94 | 628 code_rlvar(int e2,int reg) { |
119 | 629 printf("\tmovl %d(%%ebp),%s\n",lvar(e2),register_name(reg,0)); |
107 | 630 regv[creg]=1; |
61 | 631 } |
632 | |
633 | |
634 void | |
165 | 635 code_crlvar(int e2,int reg,int sign,int sz) { |
636 printf("\t%s %d(%%ebp),%s\n",cload(sign,sz),lvar(e2),register_name(reg,0)); | |
107 | 637 regv[creg]=1; |
61 | 638 } |
639 | |
640 | |
641 void | |
109 | 642 code_fname(NMTBL *n,int creg) { |
643 printf("\tmovl $%s,%s\n",n->nm,register_name(creg,0)); | |
107 | 644 regv[creg]=1; |
61 | 645 } |
646 | |
647 | |
648 void | |
107 | 649 code_const(int e2,int creg) { |
61 | 650 printf("\tmovl $%d,%s\n",e2,register_name(creg,0)); |
107 | 651 regv[creg]=1; |
61 | 652 } |
653 | |
654 | |
655 void | |
107 | 656 code_neg(int creg) { |
61 | 657 printf("\tnegl %s\n", register_name(creg,0)); |
658 } | |
659 | |
660 | |
661 void | |
107 | 662 code_not(int creg) { |
61 | 663 printf("\tnotl %s\n", register_name(creg,0)); |
664 } | |
665 | |
666 | |
667 void | |
107 | 668 code_lnot(int creg) { |
61 | 669 char *xrn; |
670 use_data_reg(creg,1); | |
671 xrn = register_name(creg,1); | |
672 printf("\tcmpl $0,%s\n", register_name(creg,0)); | |
673 printf("\tsete %s\n", xrn); | |
674 printf("\tmovzbl %s,%s\n", xrn,register_name(creg,0)); | |
675 } | |
676 | |
677 void | |
168 | 678 code_preinc(int e1,int e2,int dir,int sign,int sz,int reg) { |
61 | 679 char *xrn; |
680 if (car(e2)==REGISTER) { | |
168 | 681 printf("\taddl $%d,%s\n",dir,register_name(cadr(e2),0)); |
107 | 682 printf("\tmovl %s,%s\n",register_name(cadr(e2),0),register_name(reg,0)); |
683 regv[reg]=1; | |
61 | 684 return; |
685 } | |
686 g_expr(e2); | |
687 xrn = register_name(creg,0); | |
168 | 688 printf("\t%s $%d,(%s)\n",(sz==1)?"addb":(sz==size_of_short)?"addw":"addl",dir,xrn); |
689 printf("\t%s (%s),%s\n",cload(sign,sz),xrn,register_name(creg,0)); | |
61 | 690 } |
691 | |
692 | |
693 void | |
168 | 694 code_postinc(int e1,int e2,int dir,int sign,int sz,int reg) { |
61 | 695 char *xrn; |
696 if (car(e2)==REGISTER) { | |
107 | 697 printf("\tmovl %s,%s\n",register_name(cadr(e2),0),register_name(reg,0)); |
168 | 698 printf("\taddl $%d,%s\n",dir,register_name(cadr(e2),0)); |
107 | 699 regv[reg]=1; |
61 | 700 return; |
701 } | |
702 g_expr(e2); | |
703 emit_push(); | |
704 xrn = register_name((e2=emit_pop(0)),0); | |
165 | 705 printf("\t%s (%s),%s\n",cload(sign,sz),xrn,register_name(creg,0)); |
168 | 706 printf("\t%s $%d,(%s)\n",(sz==1)?"addb":(sz==size_of_short)?"addw":"addl",dir,xrn); |
61 | 707 emit_pop_free(e2); |
708 } | |
709 | |
710 | |
711 | |
712 void | |
107 | 713 code_return(int creg) { |
61 | 714 printf("\tleal _%d,%s\n",retcont,register_name(creg,0)); |
107 | 715 regv[creg]=1; |
61 | 716 } |
717 | |
718 | |
719 void | |
107 | 720 code_environment(int creg) { |
61 | 721 printf("\tmovl %%ebp,%s\n",register_name(creg,0)); |
107 | 722 regv[creg]=1; |
61 | 723 } |
724 | |
725 | |
726 void | |
225 | 727 code_bool(int e1,int reg) { |
61 | 728 char *xrn; |
729 int e2,e3; | |
730 b_expr(e1,1,e2=fwdlabel(),1); /* including > < ... */ | |
731 xrn = register_name(creg,0); | |
732 printf("\txorl %s,%s\n",xrn,xrn); | |
733 jmp(e3=fwdlabel()); | |
734 fwddef(e2); | |
735 printf("\tmovl $1,%s\n",xrn); | |
736 fwddef(e3); | |
107 | 737 regv[creg]=1; |
61 | 738 } |
739 | |
740 char * | |
741 code_gt(int cond) { | |
742 return (cond?"g":"le"); | |
743 } | |
744 | |
745 char * | |
746 code_ugt(int cond) { | |
747 return (cond?"a":"be"); | |
748 } | |
749 | |
750 char * | |
751 code_ge(int cond) { | |
752 return (cond?"ge":"l"); | |
753 } | |
754 | |
755 char * | |
756 code_uge(int cond) { | |
757 return (cond?"ae":"b"); | |
758 } | |
759 | |
760 char * | |
761 code_eq(int cond) { | |
762 return (cond?"e":"ne"); | |
763 } | |
764 | |
765 void | |
225 | 766 code_cmp_crgvar(int e1,int reg,int sz) { |
167 | 767 if (sz==1) |
768 printf("\tcmpb $0,%s\n",((NMTBL*)cadr(e1))->nm); | |
769 else if (sz==size_of_short) | |
770 printf("\tcmpw $0,%s\n",((NMTBL*)cadr(e1))->nm); | |
61 | 771 } |
772 | |
773 | |
774 void | |
225 | 775 code_cmp_crlvar(int e1,int reg,int sz) { |
167 | 776 if (sz==1) |
777 printf("\tcmpb $0,%d(%%ebp)\n",lvar(e1)); | |
778 else if (sz==size_of_short) | |
779 printf("\tcmpw $0,%d(%%ebp)\n",lvar(e1)); | |
61 | 780 } |
781 | |
782 | |
783 void | |
225 | 784 code_cmp_rgvar(int e1,int reg) { |
109 | 785 printf("\tcmpl $0,%s\n",((NMTBL*)cadr(e1))->nm); |
61 | 786 } |
787 | |
788 | |
789 void | |
225 | 790 code_cmp_rlvar(int e1,int reg) { |
119 | 791 printf("\tcmpl $0,%d(%%ebp)\n",lvar(e1)); |
61 | 792 } |
793 | |
794 | |
795 void | |
796 code_cmp_register(int e2) { | |
797 printf("\tcmpl $0,%s\n",register_name(e2,0)); | |
798 } | |
799 | |
800 | |
801 void | |
802 ascii(char *s) | |
803 { | |
804 printf("\t.string \""); | |
805 while(*s) { | |
806 if (*s=='\n') | |
807 printf("%cn",92); | |
808 else if (*s<' ') | |
809 printf("%c%03o",92,*s); | |
810 else if (*s==34) | |
811 printf("%c%c",92,34); | |
812 else | |
813 printf("%c",*s); | |
814 s++; | |
815 } | |
816 printf("%c\n",34); | |
817 } | |
818 | |
819 void | |
107 | 820 code_string(int e1,int creg) |
61 | 821 { |
822 char *s; | |
823 int i,lb; | |
824 | |
825 if (0) { | |
826 s=(char *)cadr(e1); | |
827 lb=fwdlabel(); | |
828 printf("\tjmp _%d\n",lb); | |
829 i=backdef(); | |
830 ascii(s); | |
831 printf("\t.align 2\n"); | |
832 fwddef(lb); | |
833 printf("\tlea _%d,%s\n",i,register_name(creg,0)); | |
834 } else { | |
835 s=(char *)cadr(e1); | |
836 printf(".section\t.rodata\n"); | |
837 lb=fwdlabel(); | |
838 printf("_%d:\n",lb); | |
839 ascii(s); | |
840 if (output_mode==TEXT_EMIT_MODE) { | |
841 printf(".text\n"); | |
842 } else { | |
843 text_mode(); | |
844 } | |
845 printf("\tlea _%d,%s\n",lb,register_name(creg,0)); | |
846 } | |
847 } | |
848 | |
849 #define MAX_COPY_LEN 20 | |
850 | |
851 void | |
852 emit_copy(int from,int to,int length,int offset,int value,int det) | |
853 { | |
854 int fix = 0; | |
855 /* length <0 means upward direction copy */ | |
856 switch (length) { | |
857 case 0: break; | |
858 case 1: case -1: | |
859 printf("\tmovb %d(%s),%s\n",offset, | |
860 register_name(from,0), reg_name_l[rname[dreg]] ); | |
861 printf("\tmovb %s,%d(%s)\n",reg_name_l[rname[dreg]] ,offset, | |
862 register_name(to,0)); | |
863 break; | |
864 case 2: case -2: | |
865 printf("\tmovw %d(%s),%s\n",offset, | |
866 register_name(from,0), reg_name_w[rname[dreg]] ); | |
867 printf("\tmovw %s,%d(%s)\n",reg_name_w[rname[dreg]] ,offset, | |
868 register_name(to,0)); | |
869 break; | |
870 case 4: case -4: | |
871 printf("\tmovl %d(%s),%s\n",offset, | |
872 register_name(from,0), register_name(dreg,0)); | |
873 printf("\tmovl %s,%d(%s)\n",register_name(dreg,0), offset, | |
874 register_name(to,0)); | |
875 break; | |
876 default: | |
877 if (-MAX_COPY_LEN<length && length <0) { | |
878 for(;length<=4;length+=4,offset-=4) | |
879 emit_copy(from,to,4,offset,0,det); | |
880 for(;length<=2;length+=2,offset-=2) | |
881 emit_copy(from,to,2,offset,0,det); | |
882 if(length>0) | |
883 emit_copy(from,to,length,offset,0,det); | |
884 break; | |
885 } else if (length <=MAX_COPY_LEN) { | |
886 for(;length>=4;length-=4,offset+=4) | |
887 emit_copy(from,to,4,offset,0,det); | |
888 for(;length>=2;length-=2,offset+=2) | |
889 emit_copy(from,to,2,offset,0,det); | |
890 if(length>0) | |
891 emit_copy(from,to,length,offset,0,det); | |
892 break; | |
893 } | |
894 if (det) { | |
895 /* | |
896 call bcopy | |
897 g_expr(list3(FUNCTION,,); | |
898 break; | |
899 */ | |
900 } | |
901 use_register(from,REG_ESI,1); | |
902 use_register(to, REG_EDI,1); | |
903 use_register(dreg,REG_ECX,0); | |
904 if (length<0) { | |
905 printf("\tmovl $%d,%%ecx\n",-length/4); | |
906 printf("\taddl $%d,%%esi\n",-length); | |
907 printf("\taddl $%d,%%edi\n",-length); | |
908 printf("\tstd\n\trep\n\tmovsl\n"); | |
909 if(length%4) { | |
910 emit_copy(from,to,length,offset+length/4,0,det); | |
911 } | |
912 } else { | |
913 printf("\tmovl $%d,%%ecx\n",length/4); | |
914 fix = (length/4)*4; | |
915 printf("\tcld\n\trep\n\tmovsl\n"); | |
916 if(length%4) { | |
917 emit_copy(from,to,length,offset+length/4,0,det); | |
918 } | |
919 } | |
920 } | |
921 if (value) { | |
922 /* creg must point top of the destination data */ | |
923 /* this code is necessary for the value of assignment or function call */ | |
924 /* otherwise we don't need this */ | |
925 if (fix) printf("\tsubl $%d,%s\n",fix,register_name(to,0)); | |
926 if(creg!=to) { | |
927 if (to==dreg) | |
928 printf("\tmovl %s,%s\n",register_name(to,0),register_name(creg,0)); | |
929 else { | |
930 free_register(creg); creg=to; | |
931 } | |
932 } | |
933 } | |
934 regv[from]=regv[to]=regv[dreg]=0; | |
935 regv[creg]=1; | |
936 } | |
937 | |
938 int | |
939 struct_push(int e4,int t) | |
940 { | |
81 | 941 int length,xreg,save,lreg,count; |
61 | 942 g_expr(e4); |
943 length=size(t); | |
944 if(length%size_of_int) { | |
945 length += size_of_int - (length%size_of_int); | |
946 } | |
81 | 947 for(count=0;length<MAX_COPY_LEN;count++,length-=size_of_int) { |
948 if (length==0) return count; | |
949 else { | |
950 printf("\tpushl %d(%s)\n", | |
951 length-size_of_int,register_name(creg,0)); | |
952 } | |
61 | 953 } |
954 printf("\tsubl $%d,%%esp\n",length); | |
955 if (register_full()) { | |
956 save = 1; | |
957 for(lreg=0;lreg==creg||lreg==dreg;lreg++); | |
958 printf("\tpushl %s\n",register_name(lreg,0)); | |
959 xreg = lreg; regv[xreg]=0; | |
960 } else { | |
961 save=0; | |
962 xreg = get_register(); | |
963 } | |
964 if (save) | |
965 printf("\tlea %d(%%esp),%s\n",size_of_int,register_name(xreg,0)); | |
966 else | |
967 printf("\tmovl %%esp,%s\n",register_name(xreg,0)); | |
968 regv[xreg]=1; | |
969 /* downward direction copy */ | |
970 emit_copy(creg,xreg,length,0,0,1); | |
971 /* we have value in creg, it may be changed */ | |
972 if (save) { | |
973 if(creg==xreg) { | |
974 creg = get_register(); /* creg is freed in emit_copy */ | |
975 } | |
976 printf("\tpopl %s\n",register_name(xreg,0)); | |
977 regv[xreg]=1; | |
978 } else | |
979 free_register(xreg); | |
980 return length/size_of_int; | |
981 } | |
982 | |
94 | 983 int |
61 | 984 function(int e1) |
985 { | |
127 | 986 int e2,e3,e4,nargs,t,ret_type; |
987 NMTBL *n=0; | |
61 | 988 int save,saved; |
136
069960078249
remove redundant funcall argument for prototyped code in PowerPC case.
kono
parents:
133
diff
changeset
|
989 ret_type = cadr(cadddr(e1)); |
069960078249
remove redundant funcall argument for prototyped code in PowerPC case.
kono
parents:
133
diff
changeset
|
990 if (ret_type==CHAR) ret_type=INT; |
069960078249
remove redundant funcall argument for prototyped code in PowerPC case.
kono
parents:
133
diff
changeset
|
991 |
94 | 992 #ifdef SAVE_STACKS |
993 code_save_stacks(); | |
994 #endif | |
137 | 995 if (free_register_count(0)<1) { |
61 | 996 for(save = 0;save==dreg||save==creg;save++); |
997 printf("\tpushl %s\n",register_name(save,0)); | |
998 saved = 1; | |
999 } else { | |
1000 save = get_register(); | |
1001 saved = 0; | |
1002 } | |
1003 regv[save]=0; | |
1004 e2 = cadr(e1); | |
1005 nargs = 0; | |
1006 for (e3 = caddr(e1); e3; e3 = cadr(e3)) { | |
1007 t=caddr(e3); | |
127 | 1008 e4 = car(e3); |
61 | 1009 if(scalar(t)) { |
1010 g_expr(e4); | |
1011 printf("\tpushl %s\n",register_name(creg,0)); | |
82 | 1012 } else if (t==DOUBLE) { |
1013 g_expr(e4); | |
1014 printf("\tleal\t-8(%%esp),%%esp\n\tfstpl\t(%%esp)\n"); | |
85 | 1015 nargs += size_of_double/size_of_int; |
83 | 1016 fregv[freg]=0; |
82 | 1017 continue; |
1018 } else if (t==FLOAT) { | |
1019 g_expr(e4); | |
1020 printf("\tleal\t-4(%%esp),%%esp\n\tfstps\t(%%esp)\n"); | |
85 | 1021 nargs += size_of_float/size_of_int; |
83 | 1022 fregv[freg]=0; |
82 | 1023 continue; |
61 | 1024 } else if (car(t)==STRUCT||car(t)==UNION) { |
1025 nargs += struct_push(e4,t); | |
1026 continue; | |
1027 } else { | |
1028 error(TYERR); | |
1029 } | |
1030 ++nargs; | |
1031 } | |
1032 if (car(e2) == FNAME) { | |
1033 n=(NMTBL *)cadr(e2); | |
78 | 1034 regv[creg]=0; |
1035 use_register(creg,REG_EAX,0); /* will be destroyed */ | |
61 | 1036 } else { |
1037 g_expr(e2); | |
78 | 1038 regv[creg]=1; |
1039 use_register(creg,REG_EAX,1); /* will be destroyed */ | |
61 | 1040 } |
1041 | |
1042 /* we don't have to save creg nor dreg */ | |
1043 regs[creg]=0; regs[dreg]=0; | |
78 | 1044 regv[dreg]= regv[save]= 0; |
61 | 1045 use_register(dreg,REG_EDX,0); /* will be destroyed */ |
1046 use_register(save,REG_ECX,0); /* will be destroyed */ | |
1047 regs[creg]=1; regs[dreg]=1; | |
1048 | |
1049 if (car(e2) == FNAME) { | |
1050 printf("\tcall\t%s\n",n->nm); | |
1051 } else { | |
1052 printf("\tcall\t*%s\n",register_name(creg,0)); | |
1053 } | |
1054 if (nargs) printf("\taddl $%d,%%esp\n",size_of_int*nargs); | |
1055 if (saved) { | |
1056 printf("\tpopl %s\n",register_name(save,0)); | |
1057 } else { | |
1058 free_register(save); | |
1059 } | |
1060 regv[save]=0; | |
105 | 1061 if (ret_type==DOUBLE||ret_type==FLOAT) { |
94 | 1062 fregv[freg]=1; regv[creg]=0; |
105 | 1063 } else if (ret_type==VOID) { |
94 | 1064 fregv[freg]=0; regv[creg]=0; |
1065 } else { | |
1066 fregv[freg]=0; regv[creg]=1; | |
1067 } | |
105 | 1068 return ret_type; |
61 | 1069 } |
1070 | |
1071 void | |
1072 code_frame_pointer(int e3) { | |
1073 printf("\tmovl %s,%%ebp\n",register_name(e3,0)); | |
1074 } | |
1075 | |
1076 | |
1077 void | |
62 | 1078 code_fix_frame_pointer(int disp_offset) { |
61 | 1079 printf("\tlea %d(%%ebp),%%ebp\n",disp_offset); |
1080 } | |
1081 | |
1082 | |
1083 void | |
1084 code_jmp(char *s) { | |
1085 printf("\tjmp %s\n",s); | |
1086 } | |
1087 | |
1088 | |
1089 void | |
1090 code_indirect_jmp(int e2) { | |
1091 printf("\tjmp *%s\n",register_name(e2,0)); | |
1092 } | |
1093 | |
94 | 1094 int |
225 | 1095 code_rindirect(int e1, int reg,int offset, int us) |
196 | 1096 { |
1097 char *crn,*op; | |
1098 int byte; | |
1099 g_expr(e1); | |
1100 byte = 0; op="movl"; | |
1101 crn = register_name(creg,0); | |
1102 printf("\t%s %d(%s),%s\n",op,offset,crn,crn); | |
1103 return us?UNSIGNED:INT; | |
1104 } | |
1105 | |
1106 int | |
225 | 1107 code_crindirect(int e1, int reg,int offset, int us) |
61 | 1108 { |
196 | 1109 char *crn,*op; |
1110 int byte; | |
1111 g_expr(e1); | |
1112 byte = 0; op=us?"movzbl":"movsbl"; | |
1113 crn = register_name(creg,0); | |
1114 printf("\t%s %d(%s),%s\n",op,offset,crn,crn); | |
1115 return us?UCHAR:CHAR; | |
1116 } | |
1117 | |
1118 int | |
225 | 1119 code_srindirect(int e1, int reg,int offset, int us) |
196 | 1120 { |
1121 char *crn,*op; | |
1122 int byte; | |
1123 g_expr(e1); | |
1124 byte = 0; op=us?"movzwl":"movswl"; | |
1125 crn = register_name(creg,0); | |
1126 printf("\t%s %d(%s),%s\n",op,offset,crn,crn); | |
1127 return us?USHORT:SHORT; | |
1128 } | |
1129 | |
195 | 1130 #if FLOAT_CODE |
196 | 1131 int |
225 | 1132 code_drindirect(int e1, int reg,int offset, int d) |
196 | 1133 { |
1134 g_expr(e1); | |
1135 printf("\t%s (%s)\n",fload(d),register_name(creg,0)); | |
1136 return DOUBLE; | |
1137 } | |
195 | 1138 #endif |
196 | 1139 |
1140 #if LONGLONG_CODE | |
1141 int | |
225 | 1142 code_lrindirect(int e1, int reg, int offset, int us) |
196 | 1143 { |
203 | 1144 return LONGLONG; |
61 | 1145 } |
196 | 1146 #endif |
61 | 1147 |
1148 char * | |
1149 move(int byte) | |
1150 { | |
165 | 1151 return byte==1?"movb":byte==size_of_short?"movw":"movl"; |
61 | 1152 } |
1153 | |
1154 void | |
103 | 1155 code_assign_gvar(int e2,int creg,int byte) { |
61 | 1156 if (byte) use_data_reg(creg,1); |
109 | 1157 printf("\t%s %s,%s\n",move(byte),register_name(creg,byte),((NMTBL*)cadr(e2))->nm); |
61 | 1158 } |
1159 | |
1160 void | |
103 | 1161 code_assign_lvar(int e2,int creg,int byte) { |
61 | 1162 if (byte) use_data_reg(creg,1); |
119 | 1163 printf("\t%s %s,%d(%%ebp)\n",move(byte),register_name(creg,byte),lvar(e2)); |
61 | 1164 } |
1165 | |
1166 void | |
111 | 1167 code_assign_register(int e2,int byte,int creg) { |
61 | 1168 printf("\tmovl %s,%s\n",register_name(creg,0),register_name(e2,0)); |
1169 } | |
1170 | |
1171 void | |
118 | 1172 code_assign(int e2,int byte,int creg) { |
95 | 1173 if (byte) use_data_reg(creg,1); |
61 | 1174 printf("\t%s %s,(%s)\n",move(byte),register_name(creg,byte),register_name(e2,0)); |
144 | 1175 regv[creg]=1; |
61 | 1176 } |
1177 | |
1178 void | |
225 | 1179 code_register_assop(int e2,int reg0,int op,int byte) { |
61 | 1180 int reg; |
1181 int xreg = creg; | |
1182 creg = reg = e2; | |
225 | 1183 tosop(op,reg,xreg); |
61 | 1184 creg = xreg; |
1185 printf("\tmovl %s,%s\n",register_name(reg,0),register_name(creg,0)); | |
159 | 1186 regs[creg]=regv[creg]=1; |
61 | 1187 } |
1188 | |
1189 | |
1190 void | |
225 | 1191 code_assop(int op,int reg,int byte,int sign) { |
61 | 1192 char *xrn; |
1193 int xreg; | |
1194 int edx = edx_setup(); | |
1195 xrn = register_name(xreg = emit_pop(0),0); /* pop e3 value */ | |
1196 regv[xreg]=regs[xreg]=1; | |
1197 printf("\tmovl %s,%s # assop \n",register_name(creg,0),register_name(edx,0)); | |
1198 regv[edx]=1; | |
163 | 1199 ld_indexx(byte,0,edx,sign); |
225 | 1200 tosop(op,reg,xreg); |
165 | 1201 printf("\t%s %s,(%s)\n",move(byte),register_name(creg,byte),register_name(edx,0)); |
61 | 1202 edx_cleanup(); |
1203 emit_pop_free(xreg); | |
144 | 1204 regv[creg]=1; |
61 | 1205 } |
1206 | |
1207 | |
1208 void | |
225 | 1209 tosop(int op,int reg,int oreg) |
61 | 1210 { |
1211 int dx; | |
1212 char *orn,*crn; | |
1213 | |
1214 switch(op) { | |
1215 case LSHIFT: | |
1216 case ULSHIFT: | |
1217 shift("sall",oreg); | |
144 | 1218 regv[creg]=1; |
61 | 1219 return; |
1220 case RSHIFT: | |
1221 shift("sarl",oreg); | |
144 | 1222 regv[creg]=1; |
61 | 1223 return; |
1224 case URSHIFT: | |
1225 shift("shrl",oreg); | |
144 | 1226 regv[creg]=1; |
61 | 1227 return; |
1228 } | |
1229 if(oreg==-1) { | |
1230 printf("\tpopl %s\n",register_name(dreg,0)); | |
1231 oreg = dreg; | |
1232 regv[dreg]=1; | |
94 | 1233 } else if (oreg<= -REG_LVAR_OFFSET) { |
119 | 1234 code_rlvar(oreg+REG_LVAR_OFFSET,dreg); |
117 | 1235 free_lvar(oreg+REG_LVAR_OFFSET); |
94 | 1236 oreg = dreg; |
1237 regv[dreg]=1; | |
61 | 1238 } |
1239 regv[oreg]=1; regs[oreg]=1; | |
1240 orn = register_name(oreg,0); | |
1241 crn = register_name(creg,0); | |
1242 switch(op) { | |
1243 case ADD: | |
1244 printf("\taddl %s,%s\n",orn,crn); | |
1245 break; | |
89 | 1246 case SUB: case CMP: |
61 | 1247 printf("\tsubl %s,%s\n",orn,crn); |
1248 break; | |
1249 case BAND: | |
1250 printf("\tandl %s,%s\n",orn,crn); | |
1251 break; | |
1252 case EOR: | |
1253 printf("\txorl %s,%s\n",orn,crn); | |
1254 break; | |
1255 case BOR: | |
1256 printf("\torl %s,%s\n",orn,crn); | |
1257 break; | |
1258 case MUL: | |
1259 case UMUL: | |
1260 printf("\t%s %s,%s\n","imull",orn,crn); | |
1261 break; | |
1262 case DIV: | |
1263 case UDIV: | |
1264 use_register(creg,REG_EAX,1); | |
1265 edx_setup(); | |
1266 orn = register_name(oreg,0); | |
1267 if (op==DIV) | |
127 | 1268 printf("\tcltd\n\tidivl %s\n",orn); |
61 | 1269 else |
127 | 1270 printf("\txor %%edx,%%edx\n\tdivl %s\n",orn); |
61 | 1271 edx_cleanup(); |
1272 break; | |
1273 case MOD: | |
1274 case UMOD: | |
1275 use_register(creg,REG_EAX,1); | |
1276 edx_setup(); | |
1277 orn = register_name(oreg,0); | |
1278 if (op==DIV) | |
127 | 1279 printf("\tcltd\n\tidivl %s\n",orn); |
61 | 1280 else |
127 | 1281 printf("\txor %%edx,%%edx\n\tdivl %s\n",orn); |
61 | 1282 dx = virtual(REG_EDX); |
1283 if (dx!=creg) { | |
1284 rname[dx]=rname[creg]; | |
1285 rname[creg]=REG_EDX; | |
1286 } | |
1287 edx_cleanup(); | |
1288 break; | |
1289 } | |
159 | 1290 if (oreg!=dreg&&oreg!=creg&&oreg>=0) |
61 | 1291 free_register(oreg); |
94 | 1292 else if (oreg==dreg) regv[dreg]=0; |
144 | 1293 regv[creg]=1; |
61 | 1294 } |
1295 | |
189 | 1296 int |
1297 code_const_op_p(int op,int v) | |
1298 { | |
190 | 1299 if (op==DIV||op==UDIV||op==MOD||op==UMOD) return 0; |
189 | 1300 else return 1; |
1301 } | |
1302 | |
1303 void | |
225 | 1304 oprtc(int op,int reg,int orn) |
189 | 1305 { |
1306 char *crn = register_name(creg,0); | |
1307 | |
1308 switch(op) { | |
1309 case LSHIFT: | |
1310 case ULSHIFT: | |
1311 printf("\tsall $%d,%s\n",orn,crn); | |
1312 return; | |
1313 case RSHIFT: | |
1314 printf("\tsarl $%d,%s\n",orn,crn); | |
1315 return; | |
1316 case URSHIFT: | |
1317 printf("\tshrl $%d,%s\n",orn,crn); | |
1318 return; | |
1319 case ADD: | |
1320 printf("\taddl $%d,%s\n",orn,crn); | |
1321 break; | |
1322 case SUB: case CMP: | |
1323 printf("\tsubl $%d,%s\n",orn,crn); | |
1324 break; | |
1325 case BAND: | |
1326 printf("\tandl $%d,%s\n",orn,crn); | |
1327 break; | |
1328 case EOR: | |
1329 printf("\txorl $%d,%s\n",orn,crn); | |
1330 break; | |
1331 case BOR: | |
1332 printf("\torl $%d,%s\n",orn,crn); | |
1333 break; | |
1334 case MUL: | |
1335 case UMUL: | |
1336 printf("\t%s $%d,%s\n","imull",orn,crn); | |
1337 break; | |
1338 default: | |
1339 error(-1); | |
1340 } | |
1341 } | |
1342 | |
1343 | |
61 | 1344 static int edx_stack=0; |
1345 | |
1346 int | |
1347 edx_setup() | |
1348 { | |
1349 int edx_save; | |
1350 /* make real EDX register empty */ | |
137 | 1351 if (free_register_count(0)<1) { |
61 | 1352 for(edx_save = 0;edx_save==dreg||edx_save==creg;edx_save++); |
1353 printf("\tpushl %s\n",register_name(edx_save,0)); | |
1354 edx_stack = list3(edx_save,edx_stack,0); | |
1355 } else { | |
1356 edx_save = get_register(); | |
1357 edx_stack = list3(edx_save,edx_stack,1); | |
1358 } | |
1359 regv[edx_save]=0; | |
1360 use_register(edx_save,REG_EDX,0); | |
1361 return edx_save; | |
1362 } | |
1363 | |
1364 | |
1365 void | |
1366 edx_cleanup() | |
1367 { | |
1368 if (caddr(edx_stack)==0) { | |
1369 printf("\tpopl %s\n",register_name(car(edx_stack),0)); | |
1370 } else | |
1371 free_register(car(edx_stack)); | |
1372 edx_stack = cadr(edx_stack); | |
1373 } | |
1374 | |
1375 void | |
1376 shift(char *op, int reg) | |
1377 { | |
1378 if (reg>=0) { | |
1379 use_register(reg,REG_ECX,1); | |
103 | 1380 } else if (reg<= -REG_LVAR_OFFSET) { |
1381 use_register(dreg,REG_ECX,0); | |
119 | 1382 code_rlvar(reg+REG_LVAR_OFFSET,dreg); |
103 | 1383 reg = dreg; |
1384 regv[dreg]=0; | |
61 | 1385 } else { |
1386 use_register(dreg,REG_ECX,0); | |
1387 printf("\tpopl %%ecx\n"); | |
103 | 1388 regv[dreg]=0; |
61 | 1389 } |
1390 printf("\t%s %%cl,%s\n",op,register_name(creg,0)); | |
1391 } | |
1392 | |
1393 void | |
163 | 1394 ld_indexx(int byte, int n, int xreg,int sign) |
61 | 1395 { |
1396 char *op; | |
1397 | |
166 | 1398 op = byte ? (sign?"movsbl":"movzbl") : "movl"; |
61 | 1399 if (n) |
95 | 1400 printf("\t%s %d(%s),%s\n",op,n, |
1401 register_name(xreg,0),register_name(creg,byte)); | |
61 | 1402 else |
95 | 1403 printf("\t%s (%s),%s\n",op, |
1404 register_name(xreg,0),register_name(creg,byte)); | |
1405 } | |
1406 | |
1407 int | |
1408 code_csvalue() | |
1409 { | |
123 | 1410 return rname[creg]; /* for switch value */ |
61 | 1411 } |
1412 | |
1413 void | |
95 | 1414 code_cmpdimm(int e, int csreg) |
61 | 1415 { |
1416 /* used in dosiwtch() */ | |
66 | 1417 if(chk) return; |
123 | 1418 use_register(creg,csreg,0); |
61 | 1419 printf("\tcmpl $%d,%s\n",e,register_name(creg,0)); |
1420 } | |
1421 | |
1422 void | |
66 | 1423 code_opening(char *filename) |
61 | 1424 { |
1425 printf("\t.file \"%s\"\n",filename); | |
1426 printf("\t.version\t\"01.01\"\n"); | |
66 | 1427 /* printf("gcc2_compiled.:\n"); */ |
61 | 1428 printf(".text\n"); |
1429 } | |
1430 | |
1431 void | |
66 | 1432 code_closing() |
61 | 1433 { |
78 | 1434 global_table(); |
61 | 1435 printf("\t.ident \"Micro-C compiled\"\n"); |
1436 } | |
1437 | |
1438 void | |
89 | 1439 rexpr(int e1, int l1, char *s,int t) |
61 | 1440 { |
89 | 1441 g_expr(list3(CMP,cadr(e1),caddr(e1))); |
61 | 1442 printf("\tj%s\t_%d\n",s,l1); |
1443 } | |
1444 | |
82 | 1445 |
1446 void | |
61 | 1447 jcond(int l, char cond) |
1448 { | |
66 | 1449 if (chk) return; |
61 | 1450 printf("\tj%s\t_%d\n",cond?"ne":"e",l); |
1451 } | |
1452 | |
1453 void | |
1454 jmp(int l) | |
1455 { | |
1456 control=0; | |
66 | 1457 if (chk) return; |
61 | 1458 printf("\tjmp\t_%d\n",l); |
1459 /* align? */ | |
1460 /* | |
1461 this is not allowed because of ? operator | |
1462 regv[creg]=regv[dreg]=0; | |
1463 use_register(creg,REG_EAX,0); | |
1464 use_register(dreg,REG_EBX,0); | |
1465 */ | |
1466 } | |
1467 | |
1468 void | |
1469 gen_comment(char *s) | |
1470 { | |
66 | 1471 if (chk) return; |
1472 printf("## %s",s); | |
61 | 1473 } |
1474 | |
1475 | |
1476 void | |
1477 code_enter(char *name) | |
1478 { | |
1479 printf("\t.align 4\n"); | |
1480 if (stmode!=STATIC) | |
1481 printf(".globl %s\n",name); | |
1482 printf("\t.type\t%s,@function\n",name); | |
1483 printf("%s:\n",name); | |
1484 } | |
1485 | |
77 | 1486 |
61 | 1487 void |
1488 code_enter1(int args) | |
1489 { | |
1490 code_disp_label=fwdlabel(); | |
1491 printf("\tlea _%d(%%ebp),%%esp\n",code_disp_label); | |
1492 | |
1493 printf("## args %d disp %d code_arg_offset=%d code_disp_offset=%d\n",args,disp,code_arg_offset,code_disp_offset); | |
1494 } | |
1495 | |
1496 void | |
1497 code_leave(char *name) | |
1498 { | |
63 | 1499 disp&= -size_of_int; |
61 | 1500 printf("\t.set _%d,%d\n",code_disp_label,disp+code_disp_offset); |
1501 printf("_%d:\n",labelno); | |
1502 printf("\t.size\t%s,_%d-%s\n",name,labelno,name); | |
1503 local_table(); | |
1504 labelno++; | |
1505 free_all_register(); | |
1506 } | |
1507 | |
1508 void | |
1509 enter(char *name) | |
1510 { | |
1511 printf("\t.align 2\n"); | |
1512 if (stmode!=STATIC) | |
1513 printf(".globl %s\n",name); | |
1514 printf("%s:\n",name); | |
1515 printf("\t.type\t%s,@function\n",name); | |
1516 printf("\tpushl %%ebp\n"); | |
1517 printf("\tmovl %%esp,%%ebp\n"); | |
1518 printf("\tpushl %%ebx\n"); | |
1519 printf("\tpushl %%esi\n"); | |
1520 printf("\tpushl %%edi\n"); | |
1521 } | |
1522 | |
1523 void | |
1524 enter1() | |
1525 { | |
182 | 1526 text_mode(); |
61 | 1527 func_disp_label=fwdlabel(); |
1528 printf("\tlea _%d(%%ebp),%%esp\n",func_disp_label); | |
1529 /* if(disp) printf("\tsubl $%d,%%esp\n",-disp); */ | |
1530 } | |
1531 | |
1532 void | |
1533 leave(int control, char *name) | |
1534 { | |
128 | 1535 int sz; |
1536 | |
1537 disp &= -size_of_int; | |
61 | 1538 if (control) |
108 | 1539 code_set_return_register(1); |
61 | 1540 if (retcont) { |
1541 if (control) | |
1542 jmp(retlabel); | |
1543 fwddef(retcont); | |
128 | 1544 if (cadr(fnptr->ty)==FLOAT||cadr(fnptr->ty)==DOUBLE) { |
1545 printf("\tfldl %d(%%ebp)\n",-size_of_double); | |
1546 } else if (cadr(fnptr->ty)>0&&( | |
1547 car(cadr(fnptr->ty))==STRUCT || | |
1548 car(cadr(fnptr->ty))==UNION)) { | |
1549 sz = size(cadr(fnptr->ty)); | |
1550 printf("\tlea %d(%%ebp),%s\n",-sz,register_name(dreg,0)); | |
1551 printf("\tmovl %d(%%ebp),%s\n",disp-size_of_int, | |
1552 register_name(creg,0)); | |
1553 emit_copy(dreg,creg,sz,0,1,1); | |
1554 } else if (cadr(fnptr->ty)!=VOID) { | |
1555 use_register(creg,REG_EAX,0); | |
1556 printf("\tmovl %s,%s\n",reg_name[REG_ESI],register_name(creg,0)); | |
1557 } | |
61 | 1558 } |
1559 fwddef(retlabel); | |
63 | 1560 |
61 | 1561 printf("\tlea %d(%%ebp),%%esp\n",disp_offset); |
1562 printf("\tpopl %%edi\n"); | |
1563 printf("\tpopl %%esi\n"); | |
1564 printf("\tpopl %%ebx\n"); | |
1565 printf("\tleave\n"); | |
1566 printf("\tret\n"); | |
1567 printf("\t.set _%d,%d\n",func_disp_label,disp+disp_offset); | |
1568 printf("_%d:\n",labelno); | |
1569 printf("\t.size\t%s,_%d-%s\n",name,labelno,name); | |
1570 local_table(); | |
1571 labelno++; | |
1572 free_all_register(); | |
1573 } | |
1574 | |
187 | 1575 int |
1576 code_get_fixed_creg(int reg,int type) { | |
1577 if (type==FLOAT||type==DOUBLE) { | |
1578 return 0; | |
1579 } else { | |
1580 return rname[reg]; | |
1581 } | |
1582 } | |
61 | 1583 |
1584 void | |
187 | 1585 code_set_fixed_creg(int reg,int mode,int type) { |
108 | 1586 if (type==FLOAT||type==DOUBLE) { |
187 | 1587 } else { |
1588 use_register(creg,reg,mode); | |
1589 } | |
61 | 1590 } |
1591 | |
1592 void | |
107 | 1593 code_set_return_register(int mode) { |
1594 if (fnptr->ty==DOUBLE||fnptr->ty==FLOAT) { | |
1595 } else { | |
1596 use_register(creg,REG_EAX,mode); | |
1597 } | |
1598 } | |
1599 | |
1600 void | |
61 | 1601 gen_gdecl(char *n, int gpc) |
1602 { | |
1603 /* | |
1604 if (stmode!=STATIC) | |
1605 printf(".globl %s\n",n); | |
1606 */ | |
1607 } | |
1608 | |
1609 void | |
1610 align(int t) | |
1611 { | |
1612 if (t!=CHAR) { | |
1613 if (data_alignment & 1) | |
1614 printf("\t.align 2\n"); | |
1615 data_alignment = 0; | |
1616 } | |
1617 } | |
1618 | |
1619 void | |
1620 emit_data(int e, int t, NMTBL *n) | |
1621 { | |
1622 int l; | |
195 | 1623 #if FLOAT_CODE |
82 | 1624 double d; |
1625 float f; | |
195 | 1626 #endif |
61 | 1627 char *name; |
1628 name = n->nm; | |
156 | 1629 if(mode!=GDECL && mode!=STADECL) { |
61 | 1630 error(-1); return; |
1631 } | |
66 | 1632 if (chk) return; |
61 | 1633 if (n->dsp != -1) { |
1634 n->dsp = -1; /* initiallized flag */ | |
1635 printf(".globl\t%s\n",name); | |
1636 data_mode(name); | |
1637 align(t); | |
1638 printf("%s:\n",name); | |
1639 } else { | |
1640 data_mode(0); | |
1641 } | |
1642 if(car(e)==CONST) { | |
168 | 1643 if (t==CHAR||t==UCHAR) { |
61 | 1644 printf("\t.byte %d\n",cadr(e)); |
1645 if (data_alignment>0) | |
1646 data_alignment++; | |
1647 gpc += 1; | |
168 | 1648 } else if (t==SHORT||t==USHORT) { |
1649 printf("\t.short %d\n",cadr(e)); | |
82 | 1650 if (data_alignment>0) data_alignment++; |
168 | 1651 gpc += size_of_short; |
61 | 1652 } else { |
1653 printf("\t.long %d\n",cadr(e)); | |
1654 gpc += size_of_int; | |
1655 } | |
195 | 1656 #if FLOAT_CODE |
82 | 1657 } else if(t==DOUBLE) { |
1658 d = dcadr(e); | |
1659 printf("\t.long\t0x%x,0x%x\n",code_d1(d),code_d2(d)); | |
1660 } else if(t==FLOAT) { | |
1661 f = dcadr(e); | |
1662 printf("\t.long\t0x%x\n",*(int *)&f); | |
195 | 1663 #endif |
61 | 1664 } else if(t!=CHAR) { |
1665 gpc += size_of_int; | |
1666 if(car(e)==ADDRESS&&car(cadr(e))==GVAR) { | |
109 | 1667 printf("\t.long %s\n",((NMTBL *)cadr(cadr(e)))->nm); |
1668 } else if(car(e)==GVAR) { | |
1669 printf("\t.long %s\n",((NMTBL *)cadr(e))->nm); | |
61 | 1670 } else if(car(e)==FNAME) { |
1671 printf("\t.long %s\n",((NMTBL *)cadr(e))->nm); | |
1672 } else if(car(e)==STRING) { | |
1673 if (car(n->ty)!=ARRAY || cadr(n->ty)!=CHAR) { | |
1674 l = fwdlabel(); | |
1675 printf("\t.long _%d\n",l); | |
1676 printf(".section\t.rodata\n"); | |
1677 printf("_%d:\n",l); | |
1678 output_mode = RODATA_EMIT_MODE; | |
1679 } | |
1680 ascii((char *)cadr(e)); | |
1681 } else error(TYERR); | |
168 | 1682 } else error(TYERR); |
61 | 1683 } |
1684 | |
1685 void | |
1686 emit_data_closing(NMTBL *n) | |
1687 { | |
1688 int lb; | |
66 | 1689 if (chk) return; |
61 | 1690 if (mode==GDECL) { |
1691 data_mode(0); | |
1692 lb=fwdlabel(); | |
1693 printf("_%d:\n",lb); | |
1694 printf("\t.size\t%s,_%d-%s\n",n->nm,lb,n->nm); | |
1695 } | |
1696 } | |
1697 | |
1698 void | |
1699 global_table(void) | |
1700 { | |
1701 NMTBL *n; | |
1702 int init; | |
1703 init=0; | |
1704 for(n=ntable;n < &ntable[GSYMS];n++) { | |
117 | 1705 if ((n->sc == GVAR||n->sc == STATIC) && n->dsp != -1) { |
61 | 1706 /* n->dsp = -1 means initialized global */ |
1707 if (init==0) { | |
1708 data_mode(0); | |
1709 init=1; | |
1710 } | |
1711 printf(".comm %s,%d\n",n->nm,size(n->ty)); | |
1712 } | |
1713 } | |
1714 } | |
1715 | |
1716 void | |
1717 local_table(void) | |
1718 { | |
1719 NMTBL *n; | |
1720 int init; | |
1721 init=0; | |
1722 /* static local variables */ | |
1723 for(n=ntable+GSYMS;n < &ntable[GSYMS+LSYMS];n++) { | |
1724 if (n->sc == GVAR) { | |
1725 if (init==0) { | |
1726 data_mode(0); | |
1727 init=1; | |
1728 } | |
156 | 1729 if (n->dsp!= -1) /* -1 means initialized global */ |
1730 printf(".lcomm %s,%d\n",n->nm,size(n->ty)); | |
61 | 1731 } |
1732 } | |
1733 } | |
1734 | |
1735 void | |
1736 text_mode(void) | |
1737 { | |
1738 if (output_mode!=TEXT_EMIT_MODE) { | |
1739 printf(".text\n"); | |
1740 printf("\t.align 2\n"); | |
1741 output_mode = TEXT_EMIT_MODE; | |
1742 } | |
1743 } | |
1744 | |
1745 void | |
1746 data_mode(char *name) | |
1747 { | |
1748 if (output_mode!=DATA_EMIT_MODE) { | |
1749 printf(".data\n"); | |
1750 output_mode = DATA_EMIT_MODE; | |
1751 } | |
1752 if (name) | |
1753 printf("\t.type\t%s,@object\n",name); | |
1754 } | |
1755 | |
195 | 1756 #if FLOAT_CODE |
1757 | |
81 | 1758 /* floating point */ |
1759 | |
1760 | |
82 | 1761 char * |
1762 fstore(int d) | |
1763 { | |
83 | 1764 return use? |
1765 (d?"fstl":"fsts"): | |
1766 (d?"fstpl":"fstps") | |
1767 ; | |
1768 } | |
1769 | |
1770 char * | |
1771 fstore_u(int d) | |
1772 { | |
82 | 1773 return d?"fstpl":"fstps"; |
1774 } | |
81 | 1775 |
82 | 1776 char * |
1777 fload(int d) | |
1778 { | |
1779 return d?"fldl":"flds"; | |
1780 } | |
81 | 1781 |
1782 | |
103 | 1783 void code_dassign_gvar(int e2,int freg,int d) |
82 | 1784 { |
109 | 1785 printf("\t%s %s\n",fstore(d),((NMTBL*)cadr(e2))->nm); |
82 | 1786 } |
1787 | |
103 | 1788 void code_dassign_lvar(int e2,int freg,int d) |
82 | 1789 { |
119 | 1790 printf("\t%s %d(%%ebp)\n",fstore(d),lvar(e2)); |
82 | 1791 } |
1792 | |
138 | 1793 void code_dassign_dregister(int e,int d,int freg) |
111 | 1794 { |
1795 error(-1); | |
1796 } | |
1797 | |
103 | 1798 void code_dassign(int e2,int freg,int d) |
82 | 1799 { |
1800 printf("\t%s (%s)\n",fstore(d),register_name(e2,0)); | |
1801 } | |
1802 | |
1803 static double d0 = 1.0; | |
81 | 1804 |
82 | 1805 int |
1806 code_d1(double d) | |
1807 { | |
1808 int *i = (int *)&d0; int *j = (int *)&d; | |
1809 return (i[1] == 0x3ff00000)?j[0]:j[1]; | |
1810 } | |
1811 | |
1812 int | |
1813 code_d2(double d) | |
1814 { | |
1815 int *i = (int *)&d0; int *j = (int *)&d; | |
1816 return (i[1] == 0x3ff00000)?j[1]:j[0]; | |
1817 } | |
1818 | |
138 | 1819 void code_dconst(int e2,int freg,int d) |
82 | 1820 { |
1821 int lb; | |
138 | 1822 double value = dcadr(e2); |
81 | 1823 |
138 | 1824 if (value==0.0) { |
82 | 1825 printf("\tfldz\n"); return; |
1826 } | |
138 | 1827 if (value==1.0) { |
82 | 1828 printf("\tfld1\n"); return; |
1829 } | |
1830 printf(" \t.section\t.rodata\n\t.align 8\n"); | |
1831 lb=fwdlabel(); | |
1832 printf("_%d:\n",lb); | |
138 | 1833 printf("\t.long\t0x%x,0x%x\n",code_d1(value),code_d2(value)); |
82 | 1834 if (output_mode==TEXT_EMIT_MODE) { |
1835 printf(".text\n"); | |
1836 } else { | |
1837 text_mode(); | |
1838 } | |
1839 printf("\tfldl _%d\n",lb); | |
1840 } | |
1841 | |
138 | 1842 void code_dneg(int freg,int d) |
82 | 1843 { |
1844 printf("\tfchs\n"); | |
1845 } | |
81 | 1846 |
147 | 1847 void code_d2i(int freg) |
82 | 1848 { |
1849 printf("\tlea -%d(%%esp),%%esp\n",size_of_int*2); | |
1850 printf("\tfnstcw (%%esp)\n"); | |
1851 printf("\tmovl (%%esp), %s\n",register_name(creg,0)); | |
1852 printf("\tmovb $12, 1(%%esp)\n"); | |
1853 printf("\tfldcw (%%esp)\n"); | |
85 | 1854 printf("\tfistpl %d(%%esp)\n",size_of_int); |
127 | 1855 printf("\tmovl %s, (%%esp)\n",register_name(creg,0)); |
85 | 1856 printf("\tfldcw (%%esp)\n"); |
82 | 1857 printf("\tpopl %s\n",register_name(creg,0)); |
1858 printf("\tpopl %s\n",register_name(creg,0)); | |
1859 } | |
81 | 1860 |
147 | 1861 void code_i2d(int creg) |
82 | 1862 { |
1863 printf("\tpushl %s\n",register_name(creg,0)); | |
1864 printf("\tfildl (%%esp)\n"); | |
1865 printf("\tlea %d(%%esp),%%esp\n",size_of_int); | |
1866 } | |
1867 | |
147 | 1868 void code_d2u(int freg) |
85 | 1869 { |
86 | 1870 printf("\tlea -%d(%%esp),%%esp\n",size_of_int*3); |
85 | 1871 printf("\tfnstcw (%%esp)\n"); |
1872 printf("\tmovl (%%esp), %s\n",register_name(creg,0)); | |
1873 printf("\tmovb $12, 1(%%esp)\n"); | |
1874 printf("\tfldcw (%%esp)\n"); | |
127 | 1875 printf("\tmovl %s, (%%esp)\n",register_name(creg,0)); |
86 | 1876 printf("\tfistpll %d(%%esp)\n",size_of_int); |
85 | 1877 printf("\tfldcw (%%esp)\n"); |
86 | 1878 printf("\tmovl %d(%%esp),%s\n",size_of_int,register_name(creg,0)); |
1879 printf("\tlea %d(%%esp),%%esp\n",size_of_int*3); | |
85 | 1880 } |
1881 | |
147 | 1882 void code_u2d(int creg) |
85 | 1883 { |
86 | 1884 printf("\tpushl %s\n",register_name(creg,0)); |
1885 printf("\tpushl %s\n",register_name(creg,0)); | |
1886 printf("\tmovl $0, %d(%%esp)\n",size_of_int); | |
1887 printf("\tfildll (%%esp)\n"); | |
1888 printf("\tlea %d(%%esp),%%esp\n",size_of_int*2); | |
85 | 1889 } |
1890 | |
133 | 1891 void code_d2f(int freg) { } |
1892 void code_f2d(int freg) { } | |
147 | 1893 void code_f2i(int freg) { code_d2i(freg); } |
1894 void code_f2u(int freg) { code_d2u(freg); } | |
1895 void code_i2f(int creg) { code_i2d(creg); } | |
1896 void code_u2f(int creg) { code_u2d(creg); } | |
133 | 1897 |
107 | 1898 void code_drgvar(int e2,int d,int freg) |
82 | 1899 { |
109 | 1900 printf("\t%s %s\n",fload(d),((NMTBL*)cadr(e2))->nm); |
82 | 1901 } |
81 | 1902 |
1903 | |
107 | 1904 void code_drlvar(int e2,int d,int freg) |
82 | 1905 { |
119 | 1906 printf("\t%s %d(%%ebp)\n",fload(d),lvar(e2)); |
82 | 1907 } |
1908 | |
225 | 1909 void code_cmp_drgvar(int e2,int reg,int d) |
82 | 1910 { |
109 | 1911 printf("\tfcomp %s\n",((NMTBL*)cadr(e2))->nm); |
82 | 1912 } |
1913 | |
225 | 1914 void code_cmp_drlvar(int e2,int reg,int d) |
82 | 1915 { |
119 | 1916 printf("\tfcomp %d(%%ebp)\n",lvar(e2)); |
82 | 1917 } |
1918 | |
225 | 1919 void dtosop(int op,int reg,int e1) |
94 | 1920 { |
82 | 1921 switch(op) { |
133 | 1922 case FADD: |
82 | 1923 case DADD: printf("\tfaddp %%st,%%st(1)\n"); break; |
133 | 1924 case FSUB: |
85 | 1925 case DSUB: printf("\tfsubp %%st,%%st(1)\n"); break; |
133 | 1926 case FDIV: |
85 | 1927 case DDIV: printf("\tfdivp %%st,%%st(1)\n"); break; |
133 | 1928 case FMUL: |
82 | 1929 case DMUL: printf("\tfmulp %%st,%%st(1)\n"); break; |
133 | 1930 case FCMP: |
89 | 1931 case DCMP: |
82 | 1932 printf("\tfucompp\n"); |
1933 printf("\tfnstsw\t%%ax\n"); | |
1934 break; | |
1935 } | |
1936 } | |
81 | 1937 |
83 | 1938 void |
225 | 1939 code_dassop(int op,int reg,int d) { |
83 | 1940 /* we have lvalue in creg, applied floating value is in %st(0) */ |
102 | 1941 emit_dpop(d); /* do nothing for 387 */ |
83 | 1942 printf("\t%s (%s)\n",fload(d),register_name(creg,0)); |
225 | 1943 dtosop(op,reg,0); |
83 | 1944 printf("\t%s (%s)\n",fstore(d),register_name(creg,0)); |
1945 } | |
1946 | |
1947 void | |
219 | 1948 code_register_dassop(int reg,int op,int d) { |
1949 error(-1); | |
1950 } | |
1951 | |
1952 void | |
107 | 1953 code_dpreinc(int e1,int e2,int d,int freg) { |
83 | 1954 g_expr(e2); |
1955 printf("\t%s (%s)\n",fload(d),register_name(creg,0)); | |
1956 printf("\tfld1\n"); | |
87 | 1957 if (caddr(e1)>0) |
83 | 1958 printf("\tfaddp %%st,%%st(1)\n"); |
1959 else | |
1960 printf("\tfsubrp %%st,%%st(1)\n"); | |
1961 printf("\t%s (%s)\n",fstore(d),register_name(creg,0)); | |
1962 } | |
1963 | |
1964 void | |
107 | 1965 code_dpostinc(int e1,int e2,int d,int freg) { |
83 | 1966 g_expr(e2); |
1967 printf("\t%s (%s)\n",fload(d),register_name(creg,0)); | |
1968 if (use) | |
86 | 1969 printf("\t%s (%s)\n",fload(d),register_name(creg,0)); |
83 | 1970 printf("\tfld1\n"); |
87 | 1971 if (caddr(e1)>0) |
83 | 1972 printf("\tfaddp %%st,%%st(1)\n"); |
1973 else | |
1974 printf("\tfsubrp %%st,%%st(1)\n"); | |
87 | 1975 printf("\t%s (%s)\n",(use?fstore_u(d):fstore(d)),register_name(creg,0)); |
83 | 1976 } |
1977 | |
84 | 1978 void |
230 | 1979 drexpr(int e1, int e2,int l1, int op,int cond) |
84 | 1980 { |
230 | 1981 if (cond) { |
1982 switch(op) { | |
1983 case DOP+GE: | |
1984 drexpr(e2,e1,l1,DOP+GT,0); break; | |
1985 case FOP+GE: | |
1986 drexpr(e2,e1,l1,FOP+GT,0); break; | |
1987 case DOP+GT: | |
1988 drexpr(e2,e1,l1,DOP+GE,0); break; | |
1989 case FOP+GT: | |
1990 drexpr(e2,e1,l1,FOP+GE,0); break; | |
1991 case DOP+EQ: | |
1992 op = DOP+NEQ; break; | |
1993 case FOP+EQ: | |
1994 op = FOP+NEQ; break; | |
1995 case DOP+NEQ: | |
1996 op = DOP+EQ; break; | |
1997 case FOP+NEQ: | |
1998 op = FOP+EQ; break; | |
1999 } | |
2000 } | |
89 | 2001 g_expr(list3(DCMP,e1,e2)); |
84 | 2002 switch(op) { |
2003 case DOP+GE: | |
133 | 2004 case FOP+GE: |
84 | 2005 printf("\ttestb\t$5,%%ah\n"); |
2006 printf("\tjne\t_%d\n",l1); | |
2007 break; | |
2008 case DOP+GT: | |
133 | 2009 case FOP+GT: |
84 | 2010 printf("\ttestb\t$69,%%ah\n"); |
2011 printf("\tjne\t_%d\n",l1); | |
2012 break; | |
2013 case DOP+EQ: | |
133 | 2014 case FOP+EQ: |
84 | 2015 printf("\tandb\t$69,%%ah\n"); |
2016 printf("\txorb\t$64,%%ah\n"); | |
2017 printf("\tjne\t_%d\n",l1); | |
2018 break; | |
2019 case DOP+NEQ: | |
133 | 2020 case FOP+NEQ: |
84 | 2021 printf("\tandb\t$69,%%ah\n"); |
2022 printf("\txorb\t$64,%%ah\n"); | |
2023 printf("\tje\t_%d\n",l1); | |
2024 break; | |
2025 } | |
2026 } | |
2027 | |
94 | 2028 void |
138 | 2029 code_dregister(int e2,int freg,int d) |
94 | 2030 { |
2031 error(-1); | |
2032 } | |
2033 | |
138 | 2034 void |
2035 code_cmp_dregister(int e2,int d) | |
94 | 2036 { |
2037 error(-1); | |
82 | 2038 } |
81 | 2039 |
97 | 2040 int pop_fregister() |
82 | 2041 { |
94 | 2042 if (freg_sp<0) { error(-1); return -1;} |
2043 printf("# fpop: %d\n",freg_sp-1); | |
2044 return freg_stack[--freg_sp]; | |
82 | 2045 } |
81 | 2046 |
94 | 2047 int |
138 | 2048 emit_dpop(int d) |
94 | 2049 { |
2050 int xreg; | |
97 | 2051 if ((xreg=pop_fregister())==-1) { |
94 | 2052 } else if (xreg<= -REG_LVAR_OFFSET) { |
119 | 2053 code_drlvar(REG_LVAR_OFFSET+xreg,1,freg); |
117 | 2054 free_lvar(xreg+REG_LVAR_OFFSET); |
94 | 2055 /* pushed order is reversed. We don't need this for comutable |
2056 operator, but it is ok to do this. */ | |
2057 printf("\tfxch\t%%st(1)\n"); | |
2058 } | |
2059 return xreg; | |
2060 } | |
2061 | |
2062 | |
138 | 2063 void emit_dpop_free(int e1,int d) |
82 | 2064 { |
2065 } | |
81 | 2066 |
133 | 2067 void emit_dpush(int type) |
82 | 2068 { |
119 | 2069 if (freg_sp>=MAX_FPU_STACK) code_save_fstacks(); |
94 | 2070 if (freg_sp>MAX_MAX) error(-1); |
107 | 2071 freg_stack[freg_sp++]=-1; |
94 | 2072 printf("# fpush:%d\n",freg_sp); |
2073 } | |
2074 | |
195 | 2075 #endif |
2076 | |
94 | 2077 void |
2078 code_save_stacks() | |
2079 { | |
2080 /* temporal registers or stacks in fpu are saved in local variable */ | |
2081 int xreg,sp,screg; | |
2082 sp=reg_sp; | |
2083 while(sp-->0) { | |
2084 if ((xreg=reg_stack[sp])>=0) { | |
2085 screg=creg; | |
2086 if(creg!=xreg) { | |
2087 if (xreg!=dreg) free_register(xreg); | |
2088 creg = xreg; | |
2089 } | |
2090 code_assign_lvar( | |
119 | 2091 (reg_stack[sp]=new_lvar(size_of_int)),creg,0); |
94 | 2092 reg_stack[sp]= reg_stack[sp]-REG_LVAR_OFFSET; |
2093 regv[xreg]=0; | |
2094 creg=screg; | |
2095 } | |
2096 } | |
195 | 2097 #if FLOAT_CODE |
107 | 2098 code_save_fstacks(); |
195 | 2099 #endif |
107 | 2100 } |
2101 | |
195 | 2102 #if FLOAT_CODE |
107 | 2103 void |
2104 code_save_fstacks() | |
2105 { | |
127 | 2106 int xreg,sp,uses; |
2107 uses = use; use = 0; | |
94 | 2108 sp=freg_sp; |
2109 while(sp-->0) { | |
2110 if ((xreg=freg_stack[sp])==-1) { | |
2111 code_dassign_lvar( | |
119 | 2112 (freg_stack[sp]=new_lvar(size_of_double)),freg,1); |
94 | 2113 freg_stack[sp]= freg_stack[sp]-REG_LVAR_OFFSET; |
2114 } | |
2115 } | |
127 | 2116 use = uses; |
82 | 2117 } |
195 | 2118 #endif |
2119 | |
2120 | |
2121 | |
2122 #if LONGLONG_CODE | |
2123 | |
2124 | |
2125 /* 64bit int part */ | |
2126 | |
230 | 2127 void lrexpr(int e1, int e2,int l1, int op,int cond) |
195 | 2128 { |
2129 } | |
2130 | |
2131 int lpop_register() | |
2132 { | |
2133 return 0; | |
2134 } | |
2135 | |
2136 int emit_lpop() | |
2137 { | |
2138 return 0; | |
2139 } | |
2140 | |
2141 void code_lregister(int e2,int reg) | |
2142 { | |
2143 | |
2144 } | |
2145 | |
2146 void code_cmp_lregister(int reg) | |
2147 { | |
2148 | |
2149 } | |
2150 | |
2151 void code_cmp_lrgvar(int e1,int e2) | |
2152 { | |
2153 | |
2154 } | |
2155 | |
2156 void code_cmp_lrlvar(int e1,int e2) | |
2157 { | |
2158 | |
2159 } | |
2160 | |
2161 void code_lassign(int e1,int e2) | |
2162 { | |
2163 | |
2164 } | |
2165 | |
2166 void code_lassign_gvar(int e1,int e2) | |
2167 { | |
2168 | |
2169 } | |
2170 | |
2171 void code_lassign_lvar(int e1,int e2) | |
2172 { | |
2173 | |
2174 } | |
2175 | |
2176 void code_lassign_lregister(int e2,int reg) | |
2177 { | |
2178 | |
2179 } | |
2180 | |
2181 void code_lconst(int e1,int e2) | |
2182 { | |
2183 | |
2184 } | |
2185 | |
212 | 2186 void code_lneg(int e1) |
195 | 2187 { |
2188 | |
2189 } | |
2190 | |
2191 void code_lrgvar(int e1,int e2) | |
2192 { | |
2193 | |
2194 } | |
2195 | |
2196 void code_lrlvar(int e1,int e2) | |
2197 { | |
2198 | |
2199 } | |
2200 | |
225 | 2201 void ltosop(int e1,int reg,int e2) |
195 | 2202 { |
2203 | |
2204 } | |
2205 | |
213 | 2206 int code_lconst_op_p(int op,int e) {return 0;} |
225 | 2207 void loprtc(int op,int reg,int e) {} |
213 | 2208 |
195 | 2209 void emit_lpop_free(int e1) |
2210 { | |
2211 | |
2212 } | |
2213 | |
2214 void emit_lpush() | |
2215 { | |
2216 | |
2217 } | |
2218 | |
225 | 2219 void code_i2ll() |
195 | 2220 { |
2221 | |
2222 } | |
2223 | |
225 | 2224 void code_i2ull() |
195 | 2225 { |
2226 | |
2227 } | |
2228 | |
225 | 2229 void code_u2ll() |
195 | 2230 { |
2231 | |
2232 } | |
2233 | |
225 | 2234 void code_u2ull() |
195 | 2235 { |
2236 | |
2237 } | |
2238 | |
225 | 2239 void code_ll2i() |
195 | 2240 { |
2241 | |
2242 } | |
2243 | |
225 | 2244 void code_ll2u() |
195 | 2245 { |
2246 | |
2247 } | |
2248 | |
225 | 2249 void code_ull2i() |
195 | 2250 { |
2251 | |
2252 } | |
2253 | |
225 | 2254 void code_ull2u() |
195 | 2255 { |
2256 | |
2257 } | |
2258 | |
2259 #if FLOAT_CODE | |
225 | 2260 void code_d2ll() |
195 | 2261 { |
2262 | |
2263 } | |
2264 | |
225 | 2265 void code_d2ull() |
195 | 2266 { |
2267 | |
2268 } | |
2269 | |
225 | 2270 void code_f2ll() |
195 | 2271 { |
2272 | |
2273 } | |
2274 | |
225 | 2275 void code_f2ull() |
195 | 2276 { |
2277 | |
2278 } | |
2279 | |
225 | 2280 void code_ll2d() |
195 | 2281 { |
2282 | |
2283 } | |
2284 | |
225 | 2285 void code_ll2f() |
195 | 2286 { |
2287 | |
2288 } | |
2289 | |
225 | 2290 void code_ull2d() |
195 | 2291 { |
2292 | |
2293 } | |
2294 | |
225 | 2295 void code_ull2f() |
195 | 2296 { |
2297 | |
2298 } | |
2299 | |
225 | 2300 void code_ull2ll() |
195 | 2301 { |
2302 | |
2303 } | |
2304 | |
225 | 2305 void code_ull2ull() |
195 | 2306 { |
2307 | |
2308 } | |
2309 | |
2310 #endif | |
2311 | |
2312 | |
2313 void code_lpreinc(int e1,int e2,int reg) | |
2314 { | |
2315 | |
2316 } | |
2317 | |
2318 void code_lpostinc(int e1,int e2,int reg) | |
2319 { | |
2320 | |
2321 } | |
2322 | |
225 | 2323 void code_lassop(int op,int reg) |
195 | 2324 { |
2325 | |
2326 } | |
2327 | |
219 | 2328 void |
2329 code_register_lassop(int reg,int op) { | |
2330 } | |
2331 | |
195 | 2332 |
2333 #endif | |
81 | 2334 |
61 | 2335 /* end */ |
195 | 2336 |