Mercurial > hg > CbC > old > device
annotate mc-code-powerpc.c @ 255:8cd8d72286ae
PowerPC long long complex function call fix.
MIPS entry frame calc.
author | kono |
---|---|
date | Fri, 14 May 2004 20:57:52 +0900 (2004-05-14) |
parents | 1452eb0eab20 |
children | d80e6387c539 |
rev | line source |
---|---|
89 | 1 /* Micro-C Code Generatation Part for Power PC (Mac OS X) */ |
2 /* $Id$ */ | |
3 | |
4 #define EXTERN extern | |
5 #include "mc.h" | |
93 | 6 #include "mc-code.h" |
89 | 7 #include "mc-codegen.h" |
8 | |
173 | 9 char *l_include_path[] = { |
10 "/usr/include/", | |
11 0 | |
12 }; | |
13 | |
89 | 14 #define TEXT_EMIT_MODE 0 |
15 #define DATA_EMIT_MODE 1 | |
16 #define RODATA_EMIT_MODE 2 | |
17 | |
93 | 18 static void data_mode(char *name); |
19 static void init_ptr_cache(); | |
221 | 20 static void ld_indexx(int byte, int n, int xreg,int reg,int sign); |
93 | 21 static void local_table(void); |
221 | 22 static void shift(char *op, int creg,int reg); |
119 | 23 static int struct_push(int e4,int t,int arg); |
93 | 24 |
221 | 25 static int creg; |
26 | |
89 | 27 static int output_mode = TEXT_EMIT_MODE; |
28 static int data_alignment = 0; | |
29 | |
30 static int code_disp_label; | |
111 | 31 static int code_setup; |
116 | 32 static int r1_offset_label; |
33 static int lvar_offset_label; | |
34 | |
35 static int reg_save; | |
36 static int freg_save; | |
37 | |
205 | 38 static int freg,ireg,lreg; |
147 | 39 |
238 | 40 int code_lassop_p = 1; |
41 | |
245 | 42 #define SIZE_OF_INT 4 |
43 #define SIZE_OF_SHORT 2 | |
44 #define SIZE_OF_FLOAT 4 | |
45 #define SIZE_OF_DOUBLE 8 | |
46 #define SIZE_OF_LONGLONG 8 | |
47 #define ENDIAN 1 | |
48 | |
49 int size_of_int = SIZE_OF_INT; | |
50 int size_of_short = SIZE_OF_SHORT; | |
51 int size_of_float = SIZE_OF_FLOAT; | |
52 int size_of_double = SIZE_OF_DOUBLE; | |
53 int size_of_longlong = SIZE_OF_LONGLONG; | |
54 int endian = ENDIAN; | |
111 | 55 |
205 | 56 static int reg_sp; /* REGister Stack-Pointer */ |
57 static int reg_stack[MAX_MAX]; /* �ºݤΥ쥸�������ΰ� */ | |
138 | 58 |
59 /* floating point registers */ | |
60 | |
205 | 61 static int freg_sp; /* floating point REGister Stack-Pointer */ |
62 static int freg_stack[MAX_MAX]; /* �ºݤΥ쥸�������ΰ� */ | |
89 | 63 |
206 | 64 static int lreg_sp; /* longlong REGister Stack-Pointer */ |
65 static int lreg_stack[MAX_MAX]; /* �ºݤΥ쥸�������ΰ� */ | |
66 | |
119 | 67 #define REG_fp 1 |
68 #define REG_sp 30 | |
69 #define REG_VAR_BASE 29 | |
130 | 70 #define REG_VAR_MIN 18 |
119 | 71 #define MIN_TMP_REG 3 |
130 | 72 #define MAX_TMP_REG 11 |
119 | 73 |
74 #define PTRC_REG 3 | |
75 | |
76 #define FREG_VAR_BASE 31 | |
130 | 77 #define FREG_VAR_MIN 20 |
119 | 78 #define MIN_TMP_FREG 1 |
130 | 79 #define MAX_TMP_FREG 14 |
119 | 80 |
81 int MAX_REGISTER=30; /* PowerPC�Υ쥸������10�ĤޤǻȤ�*/ | |
122 | 82 int MAX_FREGISTER=31; |
119 | 83 #define REAL_MAX_REGISTER 32 /* PowerPC�Υ쥸������32�Ȥ�������*/ |
84 #define REAL_MAX_FREGISTER 32 /* PowerPC�Υ쥸������32�Ȥ�������*/ | |
207 | 85 #define REAL_MAX_LREGISTER 16 |
119 | 86 |
145 | 87 #define FREG_OFFSET REAL_MAX_REGISTER |
207 | 88 #define LREG_OFFSET (REAL_MAX_REGISTER+REAL_MAX_FREGISTER) |
89 | |
90 #define RET_REGISTER 3 | |
91 #define RET_FREGISTER (1+FREG_OFFSET) | |
222 | 92 #define RET_LREGISTER_H 3 /* high word */ |
207 | 93 #define RET_LREGISTER_L 4 /* low word */ |
94 #define RET_LREGISTER LREG_OFFSET | |
145 | 95 |
122 | 96 int MAX_INPUT_REGISTER_VAR = 11-MIN_TMP_REG; |
97 int MAX_CODE_INPUT_REGISTER_VAR = 11-MIN_TMP_REG; | |
98 int MAX_INPUT_DREGISTER_VAR = 14-MIN_TMP_FREG; | |
138 | 99 int MAX_INPUT_FREGISTER_VAR = 14-MIN_TMP_FREG; |
122 | 100 int MAX_CODE_INPUT_DREGISTER_VAR = 14-MIN_TMP_FREG; |
138 | 101 int MAX_CODE_INPUT_FREGISTER_VAR = 14-MIN_TMP_FREG; |
119 | 102 |
207 | 103 static int powerpc_regs[REAL_MAX_REGISTER+REAL_MAX_FREGISTER+ |
104 REAL_MAX_LREGISTER]; | |
105 static int regv_h0[REAL_MAX_LREGISTER]; | |
106 static int regv_l0[REAL_MAX_LREGISTER]; | |
211 | 107 #define regv_h(i) regv_h0[(i)-LREG_OFFSET] |
108 #define regv_l(i) regv_l0[(i)-LREG_OFFSET] | |
205 | 109 |
110 static int *regs = powerpc_regs; | |
119 | 111 |
207 | 112 #define CREG_REGISTER (MAX_TMP_REG) |
113 #define FREG_FREGISTER (MAX_TMP_FREG+FREG_OFFSET) | |
114 #define LREG_LREGISTER (MAX_TMP_REG+LREG_OFFSET) | |
206 | 115 |
116 | |
119 | 117 static int max_reg_var, max_freg_var; |
118 | |
119 static char *reg_name[] = { | |
120 "r0","r1","r2","r3","r4","r5","r6","r7","r8","r9", | |
121 "r10","r11","r12","r13","r14","r15","r16","r17","r18","r19", | |
122 "r20","r21","r22","r23","r24","r25","r26","r27","r28","r29", | |
145 | 123 "r30","r31", |
119 | 124 "f0","f1","f2","f3","f4","f5","f6","f7","f8","f9", |
125 "f10","f11","f12","f13","f14","f15","f16","f17","f18","f19", | |
126 "f20","f21","f22","f23","f24","f25","f26","f27","f28","f29", | |
127 "f30","f31" | |
128 }; | |
129 | |
207 | 130 #define register_name(i) reg_name[i] |
131 #define fregister_name(i) reg_name[i] | |
132 #define lregister_name_low(i) reg_name[regv_l(i)] | |
210 | 133 #define lregister_name_high(i) reg_name[regv_h(i)] |
207 | 134 |
221 | 135 char *r(i) { return register_name(i); } |
136 char *f(i) { return fregister_name(i); } | |
137 char *ll(i) { return lregister_name_low(i); } | |
138 char *lh(i) { return lregister_name_high(i); } | |
139 | |
207 | 140 #define is_int_reg(i) (0<=i&&i<REAL_MAX_REGISTER) |
141 #define is_float_reg(i) (REAL_MAX_REGISTER<=i&&i<REAL_MAX_FREGISTER+REAL_MAX_REGISTER) | |
142 #define is_longlong_reg(i) (LREG_OFFSET<=i&&i<LREG_OFFSET+REAL_MAX_LREGISTER) | |
147 | 143 |
221 | 144 #define use_int(reg) if (reg==USE_CREG) reg=use_int0() |
145 static | |
146 int use_int0() { | |
147 int i = creg; | |
233 | 148 if (!i||!ireg||!is_int_reg(i)) { |
222 | 149 if (lreg) { free_register(lreg); lreg = 0; } |
205 | 150 if (!ireg) ireg = get_register(); |
222 | 151 // else if (ireg!=i) free_register(i); |
206 | 152 i = ireg; |
205 | 153 } |
207 | 154 if (!regs[i]) regs[i]=USING_REG; |
221 | 155 creg = i; |
147 | 156 return i; |
157 } | |
158 | |
222 | 159 #if LONGLONG_CODE |
160 #define use_longlong(reg) if (reg==USE_CREG) reg=use_longlong0() | |
161 | |
162 static | |
163 int use_longlong0() { | |
164 int i = creg; | |
165 if (!is_longlong_reg(i)) { | |
166 if (ireg) { free_register(ireg); ireg=0; } | |
226 | 167 if (!lreg||!regs[lreg]) lreg = get_lregister(); |
222 | 168 // else if (lreg!=i) free_register(i); |
169 i = lreg; | |
170 } | |
171 if (!regv_l(i)) regv_l(i) = get_register(); | |
172 if (!regv_h(i)) regv_h(i) = get_register(); | |
173 if (!regs[i]) regs[i]=USING_REG; | |
174 if (!regs[regv_l(i)]) regs[regv_l(i)]=USING_REG; | |
175 if (!regs[regv_h(i)]) regs[regv_h(i)]=USING_REG; | |
176 creg = i; | |
177 return i; | |
178 } | |
179 #endif | |
180 | |
181 | |
221 | 182 #if FLOAT_CODE |
183 #define use_float(d,reg) if (reg==USE_CREG) reg=d?use_double0():use_float0() | |
184 static | |
185 int use_float0() { | |
186 int i = creg; | |
207 | 187 if (!is_float_reg(i)) { |
188 if (lreg) { free_register(lreg); lreg = 0; } | |
189 if (!freg) freg = get_dregister(0); | |
208 | 190 else if (freg!=i) free_register(i); |
207 | 191 i = freg; |
192 } | |
193 if (!regs[i]) regs[i]=USING_REG; | |
221 | 194 creg = i; |
147 | 195 return i; |
196 } | |
221 | 197 static |
198 int use_double0() { | |
199 int i = creg; | |
207 | 200 if (!is_float_reg(i)) { |
201 if (lreg) { free_register(lreg); lreg = 0; } | |
202 if (!freg) freg = get_dregister(1); | |
208 | 203 else if (freg!=i) free_register(i); |
207 | 204 i = freg; |
205 } | |
206 if (!regs[i]) regs[i]=USING_REG; | |
221 | 207 creg = i; |
147 | 208 return i; |
209 } | |
221 | 210 #endif |
211 | |
195 | 212 |
213 #if FLOAT_CODE | |
119 | 214 static |
215 NMTBL float_zero = {"_float_zero",STATIC,FLOAT,0}; | |
216 static | |
217 NMTBL float_one = {"_float_one",STATIC,FLOAT,0}; | |
218 | |
219 | |
220 static char * fload(int d); | |
221 static int code_d1(double d); | |
222 static int code_d2(double d); | |
195 | 223 #endif |
206 | 224 #if LONGLONG_CODE |
225 static int code_l1(long long ll); | |
226 static int code_l2(long long ll); | |
227 #endif | |
195 | 228 |
119 | 229 static void code_save_stacks(); |
230 static void code_save_input_registers(); | |
231 static void clear_ptr_cache_reg(int r); | |
207 | 232 static void set_ireg(int,int); |
119 | 233 static void set_freg(int,int); |
195 | 234 static void set_lreg(int,int); |
119 | 235 |
153 | 236 static int max_func_args; |
237 static int my_func_args; | |
119 | 238 #define ARG_LVAR_OFFSET 0x10000000 |
239 | |
126 | 240 /* |
89 | 241 |
97 | 242 r0 return value etc. |
243 r3-r10 input register | |
126 | 244 r22-r29 saved register variable (input register for code segement) |
89 | 245 r30 stack pointer |
246 r31 0 | |
247 r1 frame pointer | |
97 | 248 |
249 f0 return value etc. | |
250 f1-r8 input register | |
251 f24-f31 saved register variable | |
116 | 252 |
202 | 253 function call stack frame |
116 | 254 <------r1_offset------------------------------> |
255 <------------lvar_offset-------> | |
256 r+ +------------+---+---------------+----------+--------------+----+ - | |
122 | 257 callee arg xx register save local caller arg xx |
245 | 258 reg_save disp max_func_args*SIZE_OF_INT |
119 | 259 lvar>0 lvar<0 lvar>0x1000 0000 |
127 | 260 |
261 code segment stack frame | |
262 | |
263 * goto��ƤӽФ����ؿ���r1 ! r1(goto����r1) | |
128 | 264 # * r30 <---r1_offset---------> r1 |
127 | 265 r+ +----------+--+----------+----------------+-----------+----------+----+ |
266 cousin arg xx reg save !callee arg !code local caller arg xx | |
267 r20-r29 lvar>0 lvar<0 lvar>0x1000 000 | |
268 f20-f31 <-my_func_args--><--disp-----><-max_func_arg-> | |
245 | 269 *SIZE_OF_INT *SIZE_OF_INT |
127 | 270 |
89 | 271 */ |
122 | 272 int arg_offset = 24; int arg_offset1 = 24; int disp_offset = -12; |
230 | 273 // #define func_disp_offset 60 |
274 #define func_disp_offset 68 | |
122 | 275 #define r1_offset func_disp_offset+12 |
121 | 276 int code_disp_offset = 0; int jump_offset = 0; |
277 #define CODE_LVAR l+code_disp_offset | |
129 | 278 #define CODE_CALLER_ARG (l-ARG_LVAR_OFFSET)+arg_offset1 |
121 | 279 #define FUNC_LVAR l+disp_offset |
280 #define CALLER_ARG (l-ARG_LVAR_OFFSET)+arg_offset1 | |
281 #define CALLEE_ARG l+arg_offset | |
89 | 282 |
116 | 283 void |
284 code_offset_set() | |
285 { | |
126 | 286 #if 0 |
121 | 287 int l; |
126 | 288 #endif |
245 | 289 int lvar_offsetv = -disp+max_func_args*SIZE_OF_INT+func_disp_offset; |
290 int r1_offsetv = -disp+max_func_args*SIZE_OF_INT-reg_save+r1_offset; | |
121 | 291 printf(".set L_%d,%d\n",lvar_offset_label,lvar_offsetv); |
292 printf(".set L_%d,%d\n",r1_offset_label,r1_offsetv); | |
126 | 293 #if 0 |
121 | 294 printf("# function %s\n",fnptr->nm); |
295 l = ARG_LVAR_OFFSET; | |
296 printf("# offset call0\t%d\n",CALLER_ARG); | |
245 | 297 l = ARG_LVAR_OFFSET+max_func_args*SIZE_OF_INT; |
298 printf("# offset calln\t%d %d\n",CALLER_ARG,max_func_args*SIZE_OF_INT); | |
121 | 299 l = disp; |
122 | 300 printf("# offset lvarn\t%d %d\n",FUNC_LVAR+lvar_offsetv,disp); |
121 | 301 l = 0; |
302 printf("# offset lvar0\t%d\n",FUNC_LVAR+lvar_offsetv); | |
303 l = -reg_save; | |
304 printf("# offset regs\t%d\n",FUNC_LVAR+lvar_offsetv); | |
305 printf("# offset r1off\t%d\n",r1_offsetv); | |
306 l = 0; | |
307 printf("# offset carg0\t%d\n",CALLEE_ARG+r1_offsetv); | |
308 l = my_func_args; | |
122 | 309 printf("# offset cargn\t%d %d\n",CALLEE_ARG+r1_offsetv,my_func_args); |
126 | 310 #endif |
116 | 311 } |
111 | 312 |
119 | 313 |
314 static void | |
315 lvar8(int l) | |
116 | 316 { |
317 if (fnptr->sc==CODE) { | |
129 | 318 if (l>=ARG_LVAR_OFFSET) { /* caller's arguments */ |
319 printf("lo16(%d)(r1)\n",CODE_CALLER_ARG); | |
320 } else | |
321 printf("lo16(%d)(r30)\n",CODE_LVAR); | |
119 | 322 } else if (l<0) { /* local variable */ |
323 printf("lo16(%d+L_%d)(r30)\n",FUNC_LVAR,lvar_offset_label); | |
125 | 324 } else if (l>=ARG_LVAR_OFFSET) { /* caller's arguments */ |
119 | 325 printf("lo16(%d)(r30)\n",CALLER_ARG); |
326 } else { /* callee's arguments */ | |
121 | 327 printf("lo16(%d+L_%d)(r30)\n",CALLEE_ARG,r1_offset_label); |
116 | 328 } |
329 } | |
111 | 330 |
119 | 331 /* if size of local variables / input variables is more then 64k, |
332 lo16 does not work. We have to use ha16 also. But we can't know | |
333 the exact size in one path compile. We may safely use lvar16ha | |
334 if disp or max_func_args > 32k. Of course this is reduantant for | |
335 smaller offset. But who cares who use very large local variables? | |
336 */ | |
96 | 337 |
119 | 338 #define LARGE_LVAR (disp<-32765||max_func_args>32765) |
100
a9e6f2a2946f
Wrote all code for PowerPC and no compile error. Let's fix all bugs...
kono
parents:
99
diff
changeset
|
339 |
119 | 340 static void |
341 lvar16ha(int l) | |
342 { | |
343 if (fnptr->sc==CODE) { | |
129 | 344 if (l>=ARG_LVAR_OFFSET) { /* caller's arguments */ |
345 printf("la r0,ha16(%d)(r1)\n",CODE_CALLER_ARG); | |
346 } else | |
347 printf("la r0,ha16(%d)(r30)\n",CODE_LVAR); | |
119 | 348 } else if (l<0) { /* local variable */ |
349 printf("la r0,ha16(%d+L_%d)(r30)\n",FUNC_LVAR,lvar_offset_label); | |
125 | 350 } else if (l>=ARG_LVAR_OFFSET) { /* caller's arguments */ |
119 | 351 if (CALLER_ARG>32765) |
352 printf("la r0,ha16(%d)(r30)\n",CALLER_ARG); | |
353 } else { /* callee's arguments */ | |
121 | 354 printf("la r0,ha16(%d+L_%d)(r30)\n",CALLEE_ARG,r1_offset_label); |
119 | 355 } |
356 } | |
95 | 357 |
119 | 358 static void |
359 lvar16lo(int l) | |
360 { | |
361 if (fnptr->sc==CODE) { | |
129 | 362 if (l>=ARG_LVAR_OFFSET) { /* caller's arguments */ |
363 printf("lo16(%d)(r0)\n",CODE_CALLER_ARG); | |
364 } else | |
365 printf("lo16(%d)(r0)\n",CODE_LVAR); | |
119 | 366 } else if (l<0) { /* local variable */ |
367 printf("lo16(%d+L_%d)(r0)\n",FUNC_LVAR,lvar_offset_label); | |
125 | 368 } else if (l>=ARG_LVAR_OFFSET) { /* caller's arguments */ |
119 | 369 if (CALLER_ARG>32765) |
370 printf("lo16(%d)(r0)\n",CALLER_ARG); | |
371 else | |
372 printf("lo16(%d)(r30)\n",CALLER_ARG); | |
373 } else { /* callee's arguments */ | |
121 | 374 printf("lo16(%d+L_%d)(r0)\n",CALLEE_ARG,r1_offset_label); |
119 | 375 } |
376 } | |
89 | 377 |
119 | 378 #define lvar_intro(i) if (LARGE_LVAR) lvar16ha(i) |
379 | |
380 #define lvar(i) if (LARGE_LVAR) lvar16lo(i); else lvar8(i) | |
89 | 381 |
119 | 382 void |
221 | 383 code_lvar(int e2,int reg) { |
384 use_int(reg); | |
119 | 385 lvar_intro(e2); |
221 | 386 printf("\tla %s,",register_name(reg)); |
119 | 387 lvar(e2); |
388 } | |
95 | 389 |
89 | 390 void |
391 code_init(void) | |
392 { | |
173 | 393 macro_define("__ppc__ 1\n"); |
177 | 394 macro_define("__BIG_ENDIAN__ 1\n"); |
182 | 395 // macro_define("_BSD_CT_RUNE_T_ int\n"); |
185 | 396 macro_define("__STDC__ 1\n"); |
102 | 397 init_ptr_cache(); |
207 | 398 regv_l(RET_LREGISTER) = RET_LREGISTER_L; |
399 regv_h(RET_LREGISTER) = RET_LREGISTER_H; | |
89 | 400 } |
401 | |
402 void | |
403 gexpr_code_init(void){ | |
172 | 404 #if 0 |
405 int new_reg,old_reg,dm; | |
406 /* register shuffling */ | |
407 if (is_int_reg(creg)) { | |
408 dm = get_register(); | |
409 new_reg = get_register(); | |
410 old_reg = creg; | |
411 ireg = creg = new_reg; | |
205 | 412 free_register(old_reg); |
413 free_register(dm); | |
172 | 414 } else if (is_float_reg(creg)) { |
415 dm = get_dregister(1); | |
416 new_reg = get_dregister(1); | |
417 old_reg = creg; | |
418 freg = creg = new_reg; | |
205 | 419 free_register(old_reg); |
420 free_register(dm); | |
172 | 421 } |
422 #endif | |
96 | 423 } |
424 | |
147 | 425 void |
426 code_gexpr(int e){ | |
207 | 427 // if (is_int_reg(creg) && creg!=ireg) error(-1); |
147 | 428 } |
429 | |
89 | 430 |
109 | 431 void |
137 | 432 code_arg_register(NMTBL *fnptr) |
109 | 433 { |
137 | 434 int args = fnptr->dsp; |
435 NMTBL *n; | |
436 int reg_var = 0; | |
437 int freg_var = 0; | |
438 int type; | |
439 int reg; | |
207 | 440 int i; |
137 | 441 int is_code0 = is_code(fnptr); |
442 | |
443 while (args) { | |
444 /* process in reverse order */ | |
445 n = (NMTBL*)caddr(args); | |
446 type = n->ty; | |
447 if (scalar(type)) { | |
448 if ((reg = get_input_register_var(reg_var,n,is_code0))) { | |
449 n->sc = REGISTER; | |
207 | 450 n->dsp = cadr(reg); |
451 regs[n->dsp]= INPUT_REG; | |
137 | 452 reg_var++; |
245 | 453 cadddr(args)=SIZE_OF_INT; |
137 | 454 } |
138 | 455 } else if (type==FLOAT) { |
456 if ((reg = get_input_dregister_var(freg_var,n,is_code0,0))) { | |
457 n->sc = DREGISTER; | |
207 | 458 n->dsp = cadr(reg); |
459 regs[n->dsp]= INPUT_REG; | |
138 | 460 freg_var++; |
205 | 461 cadddr(args)=size(type); |
138 | 462 } |
463 } else if (type==DOUBLE) { | |
464 if ((reg = get_input_dregister_var(freg_var,n,is_code0,1))) { | |
137 | 465 n->sc = DREGISTER; |
207 | 466 n->dsp = cadr(reg); |
467 regs[n->dsp]= INPUT_REG; | |
137 | 468 freg_var++; |
205 | 469 cadddr(args)=size(type); |
470 } | |
471 } else if (type==LONGLONG||type==ULONGLONG) { | |
472 if ((reg = get_input_lregister_var(reg_var,n,is_code0))) { | |
473 n->sc = LREGISTER; | |
207 | 474 n->dsp = cadr(reg); |
475 regs[i=n->dsp]= INPUT_REG; | |
476 regs[regv_l(i)]= INPUT_REG; | |
477 regs[regv_h(i)]= INPUT_REG; | |
205 | 478 reg_var+=2; |
479 cadddr(args)=size(type); | |
137 | 480 } |
481 } | |
482 args = cadr(args); | |
483 } | |
126 | 484 if (is_function(fnptr)) |
485 code_save_input_registers(); | |
109 | 486 } |
487 | |
208 | 488 |
89 | 489 int |
210 | 490 get_register(void) |
89 | 491 { /* �Ȥ��Ƥ��ʤ��쥸������Ĵ�٤� */ |
219 | 492 int i,j,reg; |
96 | 493 for(i=MAX_TMP_REG;i>MIN_TMP_REG;i--) { |
102 | 494 if (regs[i]) continue; /* �Ȥ��Ƥ��� */ |
495 regs[i]=USING_REG; /* ���Υ쥸������Ȥ����Ȥ������ */ | |
207 | 496 return i; /* ���ξ���ɽ���ֹ���֤� */ |
102 | 497 } |
135 | 498 /* PTR_CACHE ��Ĥ֤� */ |
102 | 499 for(i=MAX_TMP_REG;i>MIN_TMP_REG;i--) { |
119 | 500 if (regs[i]==PTRC_REG) { |
98 | 501 clear_ptr_cache_reg(i); |
96 | 502 } else |
503 continue; | |
504 regs[i]=USING_REG; /* ���Υ쥸������Ȥ����Ȥ������ */ | |
207 | 505 return i; /* ���ξ���ɽ���ֹ���֤� */ |
96 | 506 } |
507 /* search register stack */ | |
508 for(i=0;i<reg_sp;i++) { | |
120 | 509 if ((reg=reg_stack[i])>=0) { |
96 | 510 code_assign_lvar( |
245 | 511 (j=new_lvar(SIZE_OF_INT)),reg,0); |
219 | 512 reg_stack[i]= j-REG_LVAR_OFFSET; |
120 | 513 return reg; |
89 | 514 } |
515 } | |
206 | 516 #if LONGLONG_CODE |
517 /* search register stack */ | |
518 for(i=0;i<lreg_sp;i++) { | |
519 if ((reg=lreg_stack[i])>=0) { | |
219 | 520 code_lassign_lvar( |
245 | 521 (j=new_lvar(SIZE_OF_LONGLONG)),reg); |
219 | 522 lreg_stack[i]= j-REG_LVAR_OFFSET; |
206 | 523 free_register(reg); |
524 return get_register(); | |
525 } | |
526 } | |
527 #endif | |
130 | 528 for(i=0;i<REG_VAR_BASE-REG_VAR_MIN;i++) { |
529 reg =REG_VAR_BASE-i; | |
530 if (! regs[reg]) { /* �Ȥ��Ƥ��ʤ��ʤ� */ | |
531 regs[reg]=USING_REG; /* ���Υ쥸������Ȥ����Ȥ������ */ | |
532 if (i>max_reg_var) max_reg_var=i; | |
207 | 533 return reg; /* ���ξ���ɽ���ֹ���֤� */ |
130 | 534 } |
535 } | |
96 | 536 /* �����Ƥ����꤬�ʤ��ʤ顢���顼 (���ä���ï���ȤäƤ��?) */ |
136
069960078249
remove redundant funcall argument for prototyped code in PowerPC case.
kono
parents:
135
diff
changeset
|
537 error(HPERR); return creg; |
89 | 538 } |
539 | |
210 | 540 #if 0 |
208 | 541 int |
542 get_register(void) | |
543 { | |
544 int i = get_register0(); | |
545 printf("# get_register %d\n",i); | |
546 return i; | |
547 } | |
210 | 548 #endif |
208 | 549 |
93 | 550 int |
551 pop_register(void) | |
552 { /* �쥸���������ͤ���Ф� */ | |
553 return reg_stack[--reg_sp]; | |
554 } | |
555 | |
195 | 556 #if FLOAT_CODE |
96 | 557 int |
210 | 558 get_dregister(int d) |
96 | 559 { /* �Ȥ��Ƥ��ʤ��쥸������Ĵ�٤� */ |
103 | 560 int i,reg; |
145 | 561 for(i=MAX_TMP_FREG+FREG_OFFSET;i>MIN_TMP_FREG+FREG_OFFSET;i--) { |
562 if (regs[i]) continue; /* �Ȥ��Ƥ��� */ | |
563 regs[i]=USING_REG; /* ���Υ쥸������Ȥ����Ȥ������ */ | |
207 | 564 return i; /* ���ξ���ɽ���ֹ���֤� */ |
102 | 565 } |
96 | 566 /* search register stack */ |
567 for(i=0;i<freg_sp;i++) { | |
103 | 568 if ((reg=freg_stack[i])>=0) { |
96 | 569 code_dassign_lvar( |
245 | 570 (freg_stack[i]=new_lvar(SIZE_OF_DOUBLE)),reg,1); |
96 | 571 freg_stack[i]= freg_stack[i]-REG_LVAR_OFFSET; |
120 | 572 return reg; |
96 | 573 } |
574 } | |
130 | 575 for(i=0;i<FREG_VAR_BASE-REG_VAR_MIN;i++) { |
145 | 576 reg =FREG_VAR_BASE-i+FREG_OFFSET; |
577 if (! regs[reg]) { /* �Ȥ��Ƥ��ʤ��ʤ� */ | |
578 regs[reg]=USING_REG; /* ���Υ쥸������Ȥ����Ȥ������ */ | |
130 | 579 if (i>max_freg_var) max_freg_var=i; |
207 | 580 return reg; /* ���ξ���ɽ���ֹ���֤� */ |
130 | 581 } |
582 } | |
96 | 583 /* �����Ƥ����꤬�ʤ��ʤ顢���顼 (���ä���ï���ȤäƤ��?) */ |
98 | 584 error(REG_ERR); return freg; |
96 | 585 } |
586 | |
210 | 587 #if 0 |
208 | 588 int |
589 get_dregister(int d) | |
590 { | |
591 int i = get_dregister0(d); | |
592 printf("# get_dregister %d\n",i); | |
593 return i; | |
594 } | |
210 | 595 #endif |
208 | 596 |
96 | 597 int |
97 | 598 pop_fregister(void) |
96 | 599 { /* �쥸���������ͤ���Ф� */ |
600 return freg_stack[--freg_sp]; | |
601 } | |
195 | 602 #endif |
603 | |
604 int | |
207 | 605 get_lregister0() |
606 { | |
607 int i; | |
608 for(i=LREG_OFFSET+1;i<REAL_MAX_LREGISTER+LREG_OFFSET;i++) { | |
609 if (regs[i]==0) { | |
210 | 610 // printf("# get_lregister %d\n",i); |
207 | 611 return i; |
612 } | |
613 } | |
614 return -1; | |
615 } | |
616 | |
617 int | |
205 | 618 get_lregister() |
619 { | |
207 | 620 int h,l,i; |
621 i = get_lregister0(); | |
622 if (i==-1) return -1; | |
220 | 623 h = get_register(); |
624 if (h==-1) return -1; | |
625 regv_h(i) = h; | |
626 l = get_register(); | |
627 if (l==-1) { free_register(h); return -1; } | |
628 regv_l(i) = l; | |
629 regs[i]=USING_REG; | |
630 return i; | |
205 | 631 } |
632 | |
633 int | |
195 | 634 get_lregister_var(NMTBL *n) |
635 { | |
207 | 636 int i,j,ll; |
206 | 637 int max_reg_var_save=max_reg_var; |
207 | 638 ll = get_lregister0(); |
255 | 639 if (ll==-1) goto not_found; |
207 | 640 if (regs[ll]==0) { |
641 for(i=0;i<REG_VAR_BASE-REG_VAR_MIN;i++) { | |
642 if (! regs[REG_VAR_BASE-i]) { /* �Ȥ��Ƥ��ʤ��ʤ� */ | |
643 /* ���Υ쥸������Ȥ����Ȥ������ */ | |
644 regs[REG_VAR_BASE-i]=USING_REG; | |
645 if (i>max_reg_var) max_reg_var=i; | |
646 for(j=0;j<REG_VAR_BASE-REG_VAR_MIN;j++) { | |
647 if (! regs[REG_VAR_BASE-j]) { | |
648 /* �Ȥ��Ƥ��ʤ��ʤ� */ | |
649 /* ���Υ쥸������Ȥ����Ȥ������ */ | |
650 regs[REG_VAR_BASE-j]=USING_REG; | |
651 if (j>max_reg_var) max_reg_var=j; | |
652 /* ���ξ���ɽ���ֹ���֤� */ | |
228 | 653 regs[ll]=USING_REG; |
207 | 654 regv_l(ll) = REG_VAR_BASE-j; |
655 regv_h(ll) = REG_VAR_BASE-i; | |
656 return list3(LREGISTER,ll,(int)n); | |
657 } | |
206 | 658 } |
207 | 659 /* �ҤȤĤ����ʤ��ä� */ |
660 regs[REG_VAR_BASE-i]=0; | |
661 max_reg_var=max_reg_var_save; | |
662 goto not_found; | |
206 | 663 } |
664 } | |
665 } | |
207 | 666 not_found: |
245 | 667 return list2(LVAR,new_lvar(SIZE_OF_LONGLONG)); |
195 | 668 } |
96 | 669 |
93 | 670 void |
671 emit_pop_free(int xreg) | |
672 { | |
103 | 673 if (xreg>=0) |
674 free_register(xreg); | |
93 | 675 } |
676 | |
211 | 677 void |
678 | |
89 | 679 free_register(int i) { /* ����ʤ��ʤä��쥸�������� */ |
210 | 680 // printf("# free_register %d\n",i); |
207 | 681 regs[i]=0; |
682 if (is_longlong_reg(i)) { | |
683 regs[regv_l(i)]=0; | |
684 regs[regv_h(i)]=0; | |
226 | 685 //regv_l(i)=0; |
686 //regv_h(i)=0; | |
206 | 687 } |
96 | 688 } |
689 | |
89 | 690 int |
138 | 691 get_input_dregister_var(int i,NMTBL *n,int is_code,int d) |
99 | 692 { |
126 | 693 if (is_code) { |
148 | 694 if(!(i<FREG_VAR_BASE-FREG_VAR_MIN)) return 0; |
695 i = FREG_VAR_BASE-i+FREG_OFFSET; | |
126 | 696 } else { |
135 | 697 if (i<0||i>=MAX_INPUT_DREGISTER_VAR) return 0; |
145 | 698 i = i+MIN_TMP_FREG+FREG_OFFSET; |
126 | 699 } |
207 | 700 return list3(DREGISTER,i,(int)n); |
205 | 701 } |
702 | |
703 int | |
704 get_input_lregister_var(int i,NMTBL *n,int is_code) | |
705 { | |
207 | 706 int ll; |
707 ll = get_lregister0(); | |
708 if (i!=-1) { | |
709 if (is_code) { | |
227 | 710 if(!(i<REG_VAR_BASE-REG_VAR_MIN)) return 0; |
207 | 711 i = REG_VAR_BASE-i; |
712 } else { | |
227 | 713 if (i<0||i>=MAX_INPUT_REGISTER_VAR) return 0; |
207 | 714 i = i+MIN_TMP_REG; |
715 } | |
222 | 716 regv_h(ll)=i; |
717 regv_l(ll)=i+1; | |
207 | 718 } else { error(-1); ll=LREG_OFFSET+2; } |
719 return list3(LREGISTER,ll,(int)n); | |
99 | 720 } |
721 | |
722 int | |
126 | 723 get_input_register_var(int i,NMTBL *n,int is_code) |
99 | 724 { |
126 | 725 if (is_code) { |
131 | 726 if(!(i<REG_VAR_BASE-REG_VAR_MIN)) return 0; |
126 | 727 i = REG_VAR_BASE-i; |
728 } else { | |
135 | 729 if (i<0||i>=MAX_INPUT_REGISTER_VAR) return 0; |
730 i = i+MIN_TMP_REG; | |
731 } | |
207 | 732 return list3(REGISTER,i,(int)n); |
135 | 733 } |
734 | |
145 | 735 /* double register case? */ |
736 | |
135 | 737 int |
738 get_input_register_var_1(int i,NMTBL *n,int is_code) | |
739 { | |
740 if (is_code) { | |
741 if(!(i<REG_VAR_BASE-REG_VAR_MIN)) return 0; | |
742 i = REG_VAR_BASE-i; | |
743 } else { | |
744 if (i<0||i>=MAX_INPUT_REGISTER_VAR+1) return 0; | |
126 | 745 i = i+MIN_TMP_REG; |
746 } | |
207 | 747 return list3(REGISTER,i,(int)n); |
99 | 748 } |
749 | |
750 int | |
137 | 751 free_register_count(int d) |
103 | 752 { |
753 int i,count,fcount; | |
754 fcount = count = 0; | |
755 for(i=0;i<MAX_REGISTER;i++) { | |
205 | 756 if (! regs[i]) count++; |
103 | 757 } |
758 for(i=0;i<MAX_FREGISTER;i++) { | |
205 | 759 if (! regs[i+FREG_OFFSET]) fcount++; |
103 | 760 } |
137 | 761 printf("# free reg %d freg %d\n",count,fcount); |
762 return d?fcount:count; | |
103 | 763 } |
764 | |
205 | 765 #if 0 |
766 static int | |
89 | 767 register_full(void) |
768 { | |
769 int i; | |
770 for(i=0;i<MAX_REGISTER;i++) { | |
771 if (! regs[i]) { | |
772 return 0; | |
773 } | |
774 } | |
775 return 1; | |
776 } | |
205 | 777 #endif |
89 | 778 |
779 void | |
780 free_all_register(void) | |
781 { | |
782 int i; | |
210 | 783 // printf("# free_all register\n"); |
206 | 784 #if LONGLONG_CODE |
226 | 785 for(i=0;i<REAL_MAX_LREGISTER;i++) { |
786 regs[i+LREG_OFFSET]=0; | |
787 regv_l(i+LREG_OFFSET) = 0; | |
788 regv_h(i+LREG_OFFSET) = 0; | |
789 } | |
206 | 790 lreg = 0; |
222 | 791 // set_lreg(LREG_LREGISTER,0); |
206 | 792 #endif |
205 | 793 for(i=0;i<MAX_REGISTER;i++) { regs[i]=0; } |
794 for(i=0;i<MAX_FREGISTER;i++) { regs[i+FREG_OFFSET]=0; } | |
195 | 795 #if FLOAT_CODE |
138 | 796 freg = get_dregister(1); |
195 | 797 set_freg(FREG_FREGISTER,0); |
798 #endif | |
799 ireg = creg = get_register(); | |
207 | 800 set_ireg(CREG_REGISTER,0); |
89 | 801 return; |
802 } | |
803 | |
804 void | |
805 register_usage(char *s) | |
806 { | |
207 | 807 #if 1 |
89 | 808 int i; |
126 | 809 #endif |
89 | 810 if (chk) return; |
109 | 811 if (!lsrc) return; |
89 | 812 printf("# %d: %s:",lineno,s); |
206 | 813 if (ireg) printf(" creg=%s",register_name(ireg)); |
814 if (freg) printf(" freg=%s",fregister_name(freg)); | |
815 if (lreg) printf(" lreg=%s,%s",lregister_name_high(lreg), | |
816 lregister_name_low(lreg)); | |
207 | 817 #if 1 |
126 | 818 printf("\n# regs:"); |
210 | 819 for(i=0;i<MAX_REGISTER;i++) { printf("%d",regs[i]); } |
207 | 820 printf(" stack "); |
821 for(i=reg_sp;i>0;i--) { | |
822 if(reg_stack[i-1]>=0) | |
823 printf(" %s",register_name(reg_stack[i])); | |
824 } | |
101 | 825 printf("\n# freg:"); |
210 | 826 for(i=0;i<MAX_FREGISTER;i++) { printf("%d",regs[i+FREG_OFFSET]); } |
207 | 827 printf(" stack "); |
828 for(i=freg_sp;i>0;i--) { | |
829 if(freg_stack[i-1]>=0) | |
830 printf(" %s",fregister_name(freg_stack[i])); | |
831 } | |
832 printf("\n# lreg:"); | |
210 | 833 for(i=0;i<REAL_MAX_LREGISTER;i++) { printf("%d",regs[i+LREG_OFFSET]); } |
207 | 834 printf(" stack "); |
835 for(i=lreg_sp;i>0;i--) { | |
836 if(lreg_stack[i-1]>=0) | |
837 printf(" %s",lregister_name_high(lreg_stack[i])); | |
838 printf(",%s",lregister_name_low(lreg_stack[i])); | |
89 | 839 } |
840 #endif | |
841 printf("\n"); | |
842 } | |
843 | |
211 | 844 void |
845 | |
89 | 846 gexpr_init(void) |
847 { | |
848 while(reg_sp > 0) { | |
849 free_register(reg_stack[--reg_sp]); | |
850 } | |
148 | 851 while(freg_sp > 0) { |
852 free_register(freg_stack[--freg_sp]); | |
853 } | |
206 | 854 while(lreg_sp > 0) { |
855 free_register(lreg_stack[--lreg_sp]); | |
856 } | |
221 | 857 use_int0(); |
89 | 858 text_mode(); |
859 gexpr_code_init(); | |
860 register_usage("gexpr_init"); | |
861 } | |
862 | |
863 | |
211 | 864 void |
865 | |
89 | 866 emit_init(void) |
867 { | |
868 free_all_register(); | |
110 | 869 max_reg_var=-1; max_freg_var=-1; |
89 | 870 reg_sp = 0; |
123 | 871 freg_sp = 0; |
89 | 872 text_mode(); |
873 } | |
874 | |
97 | 875 |
89 | 876 int |
105 | 877 get_register_var(NMTBL *n) |
89 | 878 { |
879 int i; | |
99 | 880 for(i=0;i<REG_VAR_BASE-REG_VAR_MIN;i++) { |
137 | 881 if (! regs[REG_VAR_BASE-i]) { /* �Ȥ��Ƥ��ʤ��ʤ� */ |
882 /* ���Υ쥸������Ȥ����Ȥ������ */ | |
883 regs[REG_VAR_BASE-i]=USING_REG; | |
97 | 884 if (i>max_reg_var) max_reg_var=i; |
122 | 885 /* ���ξ���ɽ���ֹ���֤� */ |
207 | 886 return list3(REGISTER,REG_VAR_BASE-i,(int)n); |
137 | 887 } |
96 | 888 } |
245 | 889 return list2(LVAR,new_lvar(SIZE_OF_INT)); |
96 | 890 } |
891 | |
892 int | |
138 | 893 get_dregister_var(NMTBL *n,int d) |
96 | 894 { |
895 int i; | |
148 | 896 for(i=0;i<FREG_VAR_BASE-FREG_VAR_MIN;i++) { |
145 | 897 if (! regs[FREG_VAR_BASE-i+FREG_OFFSET]) { /* �Ȥ��Ƥ��ʤ��ʤ� */ |
898 regs[FREG_VAR_BASE-i+FREG_OFFSET]=USING_REG; /*���Υ쥸������Ȥ����Ȥ������*/ | |
97 | 899 if (i>max_freg_var) max_freg_var=i; |
122 | 900 /* ���ξ���ɽ���ֹ���֤� */ |
206 | 901 return list3(DREGISTER, |
207 | 902 FREG_VAR_BASE-i+FREG_OFFSET,(int)n); |
89 | 903 } |
904 } | |
245 | 905 return list2(LVAR,new_lvar(SIZE_OF_DOUBLE)); |
89 | 906 } |
907 | |
211 | 908 void |
909 | |
107 | 910 emit_push() |
89 | 911 { |
912 int new_reg; | |
221 | 913 if (!is_int_reg(creg)) error(-1); |
102 | 914 if (reg_sp>MAX_MAX) error(-1); |
221 | 915 new_reg = get_register(); /* ���Ф˼��� */ |
97 | 916 reg_stack[reg_sp++] = creg; /* push ���뤫���˥쥸������Ȥ� */ |
147 | 917 ireg = creg = new_reg; |
89 | 918 } |
919 | |
920 int | |
93 | 921 emit_pop(int type) |
89 | 922 { |
112 | 923 int xreg,reg; |
97 | 924 xreg=pop_register(); |
925 if (xreg<= -REG_LVAR_OFFSET) { | |
112 | 926 reg = get_register(); |
119 | 927 code_rlvar(REG_LVAR_OFFSET+xreg,reg); |
117 | 928 free_lvar(REG_LVAR_OFFSET+xreg); |
112 | 929 xreg = reg; |
97 | 930 } |
89 | 931 return xreg; |
932 } | |
933 | |
100
a9e6f2a2946f
Wrote all code for PowerPC and no compile error. Let's fix all bugs...
kono
parents:
99
diff
changeset
|
934 static int code_base; |
89 | 935 |
936 #define MAX_PTR_CACHE 10 | |
937 | |
938 int ptr_cache=0; | |
939 | |
93 | 940 void |
90 | 941 init_ptr_cache() |
942 { | |
943 int i; | |
944 for(i=0;i<MAX_PTR_CACHE;i++) { | |
945 ptr_cache=glist3(0,ptr_cache,0); | |
946 } | |
947 } | |
948 | |
95 | 949 void |
96 | 950 clear_ptr_cache_reg(int r) |
951 { | |
952 int ptcptr=ptr_cache; | |
953 while(ptcptr) { | |
954 if(car(ptcptr)&&caddr(ptcptr)==r) { | |
955 car(ptcptr)=0; | |
956 caddr(ptcptr)=0; | |
102 | 957 free_register(r); |
98 | 958 return; |
96 | 959 } |
960 ptcptr=cadr(ptcptr); | |
961 } | |
962 } | |
963 | |
964 void | |
89 | 965 clear_ptr_cache() |
966 { | |
967 int ptcptr=ptr_cache; | |
968 while(ptcptr) { | |
969 if(car(ptcptr)) | |
970 free_register(caddr(ptcptr)); | |
971 car(ptcptr)=0; | |
972 caddr(ptcptr)=0; | |
973 ptcptr=cadr(ptcptr); | |
974 } | |
975 } | |
976 | |
977 | |
978 int | |
109 | 979 get_ptr_cache(NMTBL *nptr) |
89 | 980 { |
981 int r; | |
982 int ptcptr=ptr_cache; | |
109 | 983 int g = (int)nptr; |
89 | 984 int p,p1; |
95 | 985 char *rrn; |
89 | 986 |
127 | 987 p1 = ptcptr; p = cadr(p1); /* unnecesary, if ptcptr is initialized */ |
89 | 988 while(ptcptr) { |
989 if(car(ptcptr)==g) return caddr(ptcptr); | |
990 p1=p; p=ptcptr; | |
991 ptcptr=cadr(ptcptr); | |
992 } | |
993 cadr(p1)=0; /* remove the last one */ | |
994 cadr(p) = ptr_cache; /* connect current queue to the last one */ | |
995 ptr_cache = p; /* now the last one is the top */ | |
996 if (!caddr(p)) { | |
96 | 997 if((r=get_register())) { |
207 | 998 caddr(p)=r; regs[r]=PTRC_REG; |
127 | 999 } else { |
1000 error(-1); | |
96 | 1001 r=creg; /* this can't happen */ |
127 | 1002 } |
102 | 1003 car(p)=g; |
127 | 1004 } else { |
1005 r = caddr(p); | |
89 | 1006 } |
1007 rrn = register_name(r); | |
109 | 1008 if (nptr->sc==STATIC) { |
1009 printf("\taddis %s,r31,ha16(_%s-L_%d)\n", | |
1010 rrn,nptr->nm,code_base); | |
1011 printf("\tla %s,lo16(_%s-L_%d)(%s)\n", | |
1012 rrn,nptr->nm,code_base,rrn); | |
1013 } else { | |
1014 printf("\taddis %s,r31,ha16(L_%s$non_lazy_ptr-L_%d)\n", | |
1015 rrn,nptr->nm,code_base); | |
1016 printf("\tlwz %s,lo16(L_%s$non_lazy_ptr-L_%d)(%s)\n", | |
1017 rrn,nptr->nm,code_base,rrn); | |
1018 } | |
89 | 1019 return r; |
1020 } | |
1021 | |
245 | 1022 static char *cload(int sz) { return sz==1?"lbz":sz==SIZE_OF_SHORT?"lhz":"lwz"; } |
1023 static char *cstore(int sz) { return sz==1?"stb":sz==SIZE_OF_SHORT?"sth":"stw"; } | |
230 | 1024 |
1025 static void | |
1026 cext(int sign,int sz,int reg) | |
1027 { | |
1028 char *crn = register_name(reg); | |
1029 if (sign) { | |
1030 if (sz==1) | |
1031 printf("\textsb %s,%s\n",crn,crn); | |
245 | 1032 else if (sz==SIZE_OF_SHORT) |
230 | 1033 printf("\textsh %s,%s\n",crn,crn); |
1034 } else { | |
1035 if (sz==1) | |
1036 printf("\trlwinm %s,%s,0,0xff\n",crn,crn); | |
245 | 1037 else if (sz==SIZE_OF_SHORT) |
230 | 1038 printf("\trlwinm %s,%s,0,0xffff\n",crn,crn); |
1039 } | |
1040 } | |
1041 | |
168 | 1042 |
89 | 1043 void |
92 | 1044 code_label(int labelno) |
1045 { | |
1046 clear_ptr_cache(); | |
102 | 1047 printf("L_%d:\n",labelno); |
92 | 1048 } |
1049 | |
1050 void | |
221 | 1051 code_gvar(int e1,int reg) { |
89 | 1052 int r; |
221 | 1053 use_int(reg); |
109 | 1054 r = get_ptr_cache((NMTBL*)cadr(e1)); |
221 | 1055 if(r!=reg) |
1056 printf("\tmr %s,%s\n",register_name(reg),register_name(r)); | |
89 | 1057 return; |
1058 } | |
1059 | |
1060 void | |
221 | 1061 code_rgvar(int e1,int reg) { |
1062 use_int(reg); | |
1063 printf("\tlwz %s,0(%s)\n",register_name(reg), | |
109 | 1064 register_name(get_ptr_cache((NMTBL*)cadr(e1)))); |
89 | 1065 } |
1066 | |
1067 void | |
221 | 1068 code_crgvar(int e1,int reg,int sign,int sz){ |
1069 char *crn; | |
1070 use_int(reg); | |
1071 crn = register_name(reg); | |
168 | 1072 printf("\t%s %s,0(%s)\n",cload(sz),crn, |
109 | 1073 register_name(get_ptr_cache((NMTBL*)cadr(e1)))); |
230 | 1074 cext(sign,sz,reg); |
89 | 1075 } |
1076 | |
165 | 1077 |
1078 | |
89 | 1079 void |
221 | 1080 code_register(int e2,int reg) { |
1081 use_int(reg); | |
1082 if (reg!=e2) | |
1083 printf("\tmr %s,%s\n",register_name(reg),register_name(e2)); | |
89 | 1084 } |
1085 | |
1086 | |
1087 void | |
95 | 1088 code_rlvar(int e2,int reg) { |
221 | 1089 use_int(reg); |
119 | 1090 lvar_intro(e2); |
1091 printf("\tlwz %s,",register_name(reg)); | |
1092 lvar(e2); | |
89 | 1093 } |
1094 | |
1095 void | |
165 | 1096 code_crlvar(int e2,int reg,int sign,int sz) { |
221 | 1097 use_int(reg); |
119 | 1098 lvar_intro(e2); |
165 | 1099 printf("\t%s %s,",cload(sz),register_name(reg)); |
119 | 1100 lvar(e2); |
230 | 1101 cext(sign,sz,reg); |
89 | 1102 } |
1103 | |
1104 void | |
221 | 1105 code_fname(NMTBL *n,int reg) { |
89 | 1106 int r; |
221 | 1107 use_int(reg); |
109 | 1108 r = get_ptr_cache(n); |
221 | 1109 if(r!=reg) |
1110 printf("\tmr %s,%s\n",register_name(reg),register_name(r)); | |
89 | 1111 return; |
1112 } | |
1113 | |
1114 | |
1115 void | |
221 | 1116 code_const(int e2,int reg) { |
1117 char *crn; | |
1118 use_int(reg); | |
1119 crn = register_name(reg); | |
89 | 1120 if (-32768<e2&&e2<32768) |
1121 printf("\tli %s,%d\n",crn,e2); | |
1122 else { | |
1123 printf("\tlis %s,ha16(%d)\n",crn,e2); | |
1124 printf("\taddi %s,%s,lo16(%d)\n",crn,crn,e2); | |
1125 } | |
1126 } | |
1127 | |
1128 | |
1129 void | |
107 | 1130 code_neg(int creg) { |
221 | 1131 use_int(creg); |
93 | 1132 printf("\tneg %s,%s\n", register_name(creg), register_name(creg)); |
89 | 1133 } |
1134 | |
1135 | |
1136 void | |
107 | 1137 code_not(int creg) { |
221 | 1138 use_int(creg); |
89 | 1139 printf("\tnor %s,%s,%s\n", |
1140 register_name(creg), register_name(creg),register_name(creg)); | |
1141 } | |
1142 | |
1143 | |
1144 void | |
107 | 1145 code_lnot(int creg) { |
221 | 1146 use_int(creg); |
89 | 1147 printf("\tsubfic r0,%s,0\n", register_name(creg)); |
1148 printf("\tadde %s,r0,%s\n", register_name(creg),register_name(creg)); | |
1149 } | |
1150 | |
1151 void | |
168 | 1152 code_preinc(int e1,int e2,int dir,int sign,int sz,int reg) { |
89 | 1153 char *xrn,*drn; |
1154 if (car(e2)==REGISTER) { | |
221 | 1155 use_int(reg); |
95 | 1156 printf("\taddi %s,%s,%d\n", |
168 | 1157 register_name(cadr(e2)),register_name(cadr(e2)), dir); |
118 | 1158 if (cadr(reg)!=e2) |
1159 printf("\tmr %s,%s\n",register_name(cadr(reg)),register_name(e2)); | |
89 | 1160 return; |
1161 } | |
1162 g_expr(e2); | |
221 | 1163 if (!is_int_reg(creg)) error(-1); |
89 | 1164 xrn = register_name(creg); |
221 | 1165 if (reg==USE_CREG) { |
231 | 1166 reg=get_register(); if (!reg) error(-1); |
1167 drn = register_name(reg); | |
1168 set_ireg(reg,0); | |
221 | 1169 } else { |
1170 drn = register_name(reg); | |
1171 } | |
168 | 1172 printf("\t%s %s,0(%s)\n",cload(sz),drn,xrn); |
231 | 1173 if (use) cext(sign,sz,reg); |
168 | 1174 printf("\taddi %s,%s,%d\n",drn,drn,dir); |
1175 printf("\t%s %s,0(%s)\n",cstore(sz),drn,xrn); | |
89 | 1176 } |
1177 | |
1178 | |
1179 void | |
168 | 1180 code_postinc(int e1,int e2,int dir,int sign,int sz,int reg) { |
89 | 1181 char *xrn,*crn,*nrn; |
231 | 1182 int nreg; |
89 | 1183 if (car(e2)==REGISTER) { |
221 | 1184 use_int(reg); |
107 | 1185 printf("\tmr %s,%s\n",register_name(reg),register_name(cadr(e2))); |
89 | 1186 printf("\taddi %s,%s,%d\n", |
168 | 1187 register_name(cadr(e2)),register_name(cadr(e2)),dir); |
89 | 1188 return; |
1189 } | |
1190 g_expr(e2); | |
221 | 1191 if (!is_int_reg(creg)) error(-1); |
89 | 1192 crn = register_name(creg); |
1193 nreg=get_register(); if (!nreg) error(-1); | |
1194 nrn = register_name(nreg); | |
221 | 1195 if (reg==USE_CREG) { |
231 | 1196 reg=get_register(); if (!reg) error(-1); |
1197 xrn = register_name(reg); | |
1198 set_ireg(reg,0); | |
221 | 1199 } else { |
1200 xrn = register_name(reg); | |
1201 } | |
168 | 1202 printf("\t%s %s,0(%s)\n",cload(sz),xrn,crn); |
230 | 1203 if (use) cext(sign,sz,reg); |
168 | 1204 printf("\taddi %s,%s,%d\n",nrn,xrn,dir); |
1205 printf("\t%s %s,0(%s)\n",cstore(sz),nrn,crn); | |
89 | 1206 free_register(nreg); |
1207 } | |
1208 | |
1209 | |
1210 void | |
107 | 1211 code_return(int creg) { |
221 | 1212 char *crn; |
1213 use_int(creg); | |
1214 crn = register_name(creg); | |
102 | 1215 printf("\taddis %s,r31,ha16(L_%d-L_%d)\n",crn,retcont,code_base); |
1216 printf("\tla %s,lo16(L_%d-L_%d)(%s)\n",crn,retcont,code_base,crn); | |
89 | 1217 } |
1218 | |
128 | 1219 #define R1SAVE 1 |
89 | 1220 |
1221 void | |
107 | 1222 code_environment(int creg) { |
126 | 1223 /* save frame pointer */ |
221 | 1224 use_int(creg); |
128 | 1225 #if R1SAVE |
1226 printf("\tlwz %s,0(r1)\n",register_name(creg)); | |
1227 #else | |
1228 int l = 0; | |
1229 printf("\tla %s,",register_name(creg)); | |
1230 printf("lo16(%d+L_%d)(r30)\n",FUNC_LVAR,lvar_offset_label); | |
1231 #endif | |
89 | 1232 } |
1233 | |
1234 void | |
221 | 1235 code_bool(int e1,int reg) { |
89 | 1236 char *xrn; |
1237 int e2,e3; | |
1238 b_expr(e1,1,e2=fwdlabel(),1); /* including > < ... */ | |
221 | 1239 use_int(reg); |
1240 xrn = register_name(reg); | |
89 | 1241 printf("\tli %s,0\n",xrn); |
1242 jmp(e3=fwdlabel()); | |
1243 fwddef(e2); | |
1244 printf("\tli %s,1\n",xrn); | |
1245 fwddef(e3); | |
1246 } | |
1247 | |
1248 char * | |
1249 code_gt(int cond) { | |
113 | 1250 return (cond?"gt":"le"); |
89 | 1251 } |
1252 | |
1253 char * | |
1254 code_ugt(int cond) { | |
113 | 1255 return (cond?"gt":"le"); |
89 | 1256 } |
1257 | |
1258 char * | |
1259 code_ge(int cond) { | |
113 | 1260 return (cond?"ge":"lt"); |
89 | 1261 } |
1262 | |
1263 char * | |
1264 code_uge(int cond) { | |
113 | 1265 return (cond?"ge":"lt"); |
89 | 1266 } |
1267 | |
1268 char * | |
1269 code_eq(int cond) { | |
113 | 1270 return (cond?"eq":"ne"); |
89 | 1271 } |
1272 | |
1273 void | |
221 | 1274 code_cmp_crgvar(int e1,int reg,int sz) { |
89 | 1275 int r; |
221 | 1276 char *crn; |
1277 use_int(reg); | |
1278 crn = register_name(reg); | |
109 | 1279 r = get_ptr_cache((NMTBL*)cadr(e1)); |
167 | 1280 printf("\t%s %s,0(%s)\n",cload(sz),crn,register_name(r)); |
230 | 1281 cext(0,sz,r); |
89 | 1282 printf("\tcmpwi cr0,%s,0\n",crn); |
1283 } | |
1284 | |
1285 | |
1286 void | |
221 | 1287 code_cmp_crlvar(int e2,int reg, int sz) { |
1288 char *crn; | |
1289 use_int(reg); | |
1290 crn = register_name(reg); | |
119 | 1291 lvar_intro(e2); |
167 | 1292 printf("\t%s %s,",cload(sz),crn); |
160 | 1293 lvar(e2); |
230 | 1294 cext(0,sz,reg); |
221 | 1295 code_cmp_register(reg); |
160 | 1296 } |
1297 | |
89 | 1298 |
1299 void | |
221 | 1300 code_cmp_rgvar(int e1,int reg) { |
89 | 1301 int r; |
221 | 1302 char *crn; |
1303 use_int(reg); | |
1304 crn = register_name(reg); | |
109 | 1305 r = get_ptr_cache((NMTBL*)cadr(e1)); |
108 | 1306 printf("\tlwz %s,0(%s)\n",crn,register_name(r)); |
221 | 1307 code_cmp_register(reg); |
89 | 1308 } |
1309 | |
1310 | |
1311 void | |
221 | 1312 code_cmp_rlvar(int e2,int reg) { |
1313 char *crn; | |
1314 use_int(reg); | |
1315 crn = register_name(reg); | |
119 | 1316 lvar_intro(e2); |
1317 printf("\tlwz %s,",crn); | |
1318 lvar(e2); | |
221 | 1319 code_cmp_register(reg); |
89 | 1320 } |
1321 | |
1322 | |
1323 void | |
1324 code_cmp_register(int e2) { | |
221 | 1325 use_int(e2); |
89 | 1326 printf("\tcmpwi cr0,%s,0\n",register_name(e2)); |
1327 } | |
1328 | |
1329 | |
1330 void | |
1331 ascii(char *s) | |
1332 { | |
1333 printf("\t.ascii \""); | |
1334 while(*s) { | |
1335 if (*s=='\n') | |
1336 printf("%cn",92); | |
1337 else if (*s<' ') | |
1338 printf("%c%03o",92,*s); | |
116 | 1339 else if (*s=='\\') |
1340 printf("\\\\"); | |
89 | 1341 else if (*s==34) |
1342 printf("%c%c",92,34); | |
1343 else | |
1344 printf("%c",*s); | |
1345 s++; | |
1346 } | |
108 | 1347 printf("\\0%c\n\t.align 2\n",34); |
89 | 1348 } |
1349 | |
1350 void | |
107 | 1351 code_string(int e1,int creg) |
89 | 1352 { |
95 | 1353 char *s,*crn; |
1354 int lb; | |
221 | 1355 |
1356 use_int(creg); | |
1357 crn = register_name(creg); | |
89 | 1358 |
1359 s=(char *)cadr(e1); | |
109 | 1360 printf(".data\t\n.cstring\n\t.align 2\n"); |
89 | 1361 lb=fwdlabel(); |
102 | 1362 printf("L_%d:\n",lb); |
89 | 1363 ascii(s); |
1364 if (output_mode==TEXT_EMIT_MODE) { | |
1365 printf(".text\n"); | |
1366 } else { | |
1367 text_mode(); | |
1368 } | |
102 | 1369 printf("\taddis %s,r31,ha16(L_%d-L_%d)\n",crn,lb,code_base); |
1370 printf("\tla %s,lo16(L_%d-L_%d)(%s)\n",crn,lb,code_base,crn); | |
89 | 1371 } |
1372 | |
1373 #define MAX_COPY_LEN 20 | |
1374 | |
211 | 1375 void |
1376 | |
89 | 1377 emit_copy(int from,int to,int length,int offset,int value,int det) |
1378 { | |
221 | 1379 char *frn; |
1380 char *trn; | |
89 | 1381 char *drn; |
1382 int fix = 0; | |
125 | 1383 char *memmove = "memmove"; |
95 | 1384 int dreg = get_register(); if (!dreg) error(-1); |
221 | 1385 |
89 | 1386 drn = register_name(dreg); |
221 | 1387 use_int(from); |
1388 use_int(to); | |
1389 frn = register_name(from); | |
1390 trn = register_name(to); | |
89 | 1391 |
1392 /* length <0 means upward direction copy */ | |
1393 switch (length) { | |
1394 case 0: break; | |
1395 case 1: case -1: | |
1396 printf("\tlbz %s,%d(%s)\n",drn,offset,frn); | |
1397 printf("\tstb %s,%d(%s)\n",drn,offset,trn); | |
1398 break; | |
1399 case 2: case -2: | |
1400 printf("\tlhz %s,%d(%s)\n",drn,offset,frn); | |
1401 printf("\tsth %s,%d(%s)\n",drn,offset,trn); | |
1402 break; | |
1403 case 4: case -4: | |
1404 printf("\tlwz %s,%d(%s)\n",drn,offset,frn); | |
1405 printf("\tstw %s,%d(%s)\n",drn,offset,trn); | |
1406 break; | |
1407 default: | |
1408 if (-MAX_COPY_LEN<length && length <0) { | |
1409 for(;length<=4;length+=4,offset-=4) | |
1410 emit_copy(from,to,4,offset,0,det); | |
1411 for(;length<=2;length+=2,offset-=2) | |
1412 emit_copy(from,to,2,offset,0,det); | |
1413 if(length>0) | |
1414 emit_copy(from,to,length,offset,0,det); | |
1415 break; | |
1416 } else if (length <=MAX_COPY_LEN) { | |
1417 for(;length>=4;length-=4,offset+=4) | |
1418 emit_copy(from,to,4,offset,0,det); | |
1419 for(;length>=2;length-=2,offset+=2) | |
1420 emit_copy(from,to,2,offset,0,det); | |
1421 if(length>0) | |
1422 emit_copy(from,to,length,offset,0,det); | |
1423 break; | |
1424 } | |
125 | 1425 clear_ptr_cache(); |
1426 code_save_stacks(); | |
1427 printf("\tli r5,%d\n",length); | |
1428 printf("\tmr r4,%s\n",frn); | |
1429 printf("\tmr r3,%s\n",trn); | |
1430 /* overrap must be allowed */ | |
1431 printf("\tbl L_%s$stub\n",memmove); | |
1432 extern_define(memmove,0,FUNCTION,1); | |
1433 fix=0; | |
207 | 1434 set_ireg(RET_REGISTER,0); |
125 | 1435 if (creg!=to) { |
1436 free_register(to); to = creg; | |
89 | 1437 } |
125 | 1438 break; |
89 | 1439 } |
1440 if (value) { | |
1441 /* creg must point top of the destination data */ | |
1442 /* this code is necessary for the value of assignment or function call */ | |
1443 /* otherwise we don't need this */ | |
1444 if (fix) printf("\taddi %s,%s,%d\n",trn,trn,fix); | |
1445 if(creg!=to) { | |
221 | 1446 free_register(creg); creg=to; ireg=to; |
89 | 1447 } |
1448 } | |
1449 free_register(dreg); | |
1450 } | |
1451 | |
1452 int | |
119 | 1453 struct_push(int e4,int t,int arg) |
89 | 1454 { |
95 | 1455 int length,count; |
119 | 1456 int dreg,sreg; char *drn,*crn,*srn; |
89 | 1457 g_expr(e4); |
221 | 1458 if (!is_int_reg(creg)) error(-1); |
89 | 1459 length=size(t); |
245 | 1460 if(length%SIZE_OF_INT) { |
1461 length += SIZE_OF_INT - (length%SIZE_OF_INT); | |
89 | 1462 } |
95 | 1463 dreg = get_register(); if (!dreg) error(-1); |
89 | 1464 drn = register_name(dreg); |
119 | 1465 crn = register_name(creg); |
125 | 1466 if (length<MAX_COPY_LEN) { |
1467 sreg = get_register(); if (!sreg) error(-1); | |
1468 srn = register_name(sreg); | |
1469 code_lvar(cadr(arg),sreg); | |
245 | 1470 for(count=0;length<MAX_COPY_LEN;count++,length-=SIZE_OF_INT) { |
125 | 1471 if (length==0) { |
1472 free_register(sreg); | |
1473 free_register(dreg); | |
1474 return count; | |
1475 } else { | |
245 | 1476 printf("\tlwz %s,%d(%s)\n",drn,length-SIZE_OF_INT,crn); |
1477 printf("\tstwu %s,%d(%s)\n",drn,-SIZE_OF_INT,srn); | |
125 | 1478 } |
89 | 1479 } |
1480 } | |
125 | 1481 code_lvar(cadr(arg),dreg); |
89 | 1482 /* downward direction copy */ |
1483 emit_copy(creg,dreg,length,0,0,1); | |
119 | 1484 if (dreg) free_register(dreg); |
245 | 1485 return length/SIZE_OF_INT; |
89 | 1486 } |
1487 | |
104 | 1488 void |
207 | 1489 set_ireg(int reg,int mode) |
104 | 1490 { |
207 | 1491 if (!is_int_reg(reg)) error(-1); |
104 | 1492 if (reg!=creg) { |
111 | 1493 clear_ptr_cache_reg(reg); |
208 | 1494 if (ireg && reg!=ireg ) { |
1495 free_register(ireg); | |
1496 if (mode) { | |
1497 printf("\tmr %s,%s\n",register_name(reg),register_name(ireg)); | |
1498 } | |
206 | 1499 } |
104 | 1500 free_register(creg); |
208 | 1501 regs[reg]=USING_REG; |
104 | 1502 } |
206 | 1503 creg = ireg = reg; |
104 | 1504 } |
1505 | |
1506 void | |
1507 set_freg(int reg,int mode) | |
1508 { | |
207 | 1509 if (!is_float_reg(reg)) error(-1); |
147 | 1510 if (reg!=creg) { |
222 | 1511 if (freg && reg!=freg) { |
208 | 1512 free_register(freg); |
1513 if (mode) { | |
1514 printf("\tfmr %s,%s\n",fregister_name(reg),fregister_name(freg)); | |
1515 } | |
147 | 1516 } |
222 | 1517 // if (creg!=ireg) free_register(creg); |
208 | 1518 regs[reg]=USING_REG; |
104 | 1519 } |
206 | 1520 creg = freg = reg; |
195 | 1521 } |
1522 | |
1523 void | |
1524 set_lreg(int reg,int mode) | |
1525 { | |
222 | 1526 if (reg==RET_LREGISTER) { |
1527 regv_l(reg) = RET_LREGISTER_L; | |
1528 regv_h(reg) = RET_LREGISTER_H; | |
1529 } | |
207 | 1530 if (!is_longlong_reg(reg)) error(-1); |
206 | 1531 if (reg!=creg) { |
222 | 1532 if (lreg && reg!=lreg) { |
208 | 1533 if (mode) { |
1534 printf("\tmr %s,%s\n", | |
1535 lregister_name_low(reg),lregister_name_low(lreg)); | |
1536 printf("\tmr %s,%s\n", | |
1537 lregister_name_high(reg),lregister_name_high(lreg)); | |
1538 } | |
226 | 1539 free_register(lreg); |
206 | 1540 } |
226 | 1541 free_register(creg); |
207 | 1542 regs[reg]=USING_REG; |
222 | 1543 clear_ptr_cache_reg(regv_l(reg)); |
207 | 1544 regs[regv_l(reg)]=USING_REG; |
222 | 1545 clear_ptr_cache_reg(regv_h(reg)); |
207 | 1546 regs[regv_h(reg)]=USING_REG; |
206 | 1547 } |
219 | 1548 creg = lreg = reg; |
104 | 1549 } |
1550 | |
1551 void | |
217 | 1552 set_lreg_operand(int reg,int mode) |
216 | 1553 { |
217 | 1554 // save_stack,clear_ptr_cache is assmued |
1555 if (!is_longlong_reg(reg)) { error(-1); return; } | |
1556 if (mode) { | |
255 | 1557 if (regv_l(reg)!=3) |
1558 printf("\tmr r3,%s\n", lregister_name_high(reg)); | |
1559 if (regv_l(reg)!=4) | |
1560 printf("\tmr r4,%s\n", lregister_name_low(reg)); | |
1561 } | |
1562 } | |
1563 | |
1564 void | |
1565 set_lreg_operand1(int reg,int mode) | |
1566 { | |
1567 // save_stack,clear_ptr_cache is assmued | |
1568 if (!is_longlong_reg(reg)) { error(-1); return; } | |
1569 if (mode) { | |
217 | 1570 if (regv_l(reg)!=5) |
228 | 1571 printf("\tmr r5,%s\n", lregister_name_high(reg)); |
217 | 1572 if (regv_l(reg)!=6) |
228 | 1573 printf("\tmr r6,%s\n", lregister_name_low(reg)); |
217 | 1574 } |
216 | 1575 } |
1576 | |
1577 void | |
207 | 1578 use_reg(int arg) |
104 | 1579 { |
210 | 1580 // printf("# use reg %d\n",arg); |
208 | 1581 if (arg<0||arg> REAL_MAX_REGISTER+REAL_MAX_FREGISTER+ REAL_MAX_LREGISTER) |
1582 error(-1); | |
223 | 1583 clear_ptr_cache_reg(arg); |
207 | 1584 regs[arg]=USING_REG; |
1585 if (is_longlong_reg(arg)) { | |
228 | 1586 clear_ptr_cache_reg(regv_l(arg)); |
207 | 1587 regs[regv_l(arg)]=USING_REG; |
228 | 1588 clear_ptr_cache_reg(regv_h(arg)); |
207 | 1589 regs[regv_h(arg)]=USING_REG; |
206 | 1590 } |
104 | 1591 } |
1592 | |
105 | 1593 void |
1594 code_save_input_registers() | |
1595 { | |
119 | 1596 int args; |
1597 NMTBL *n; | |
1598 int reg; | |
1599 int tag; | |
1600 int lvar; | |
1601 int t; | |
1602 /* fnptr->dsp=list4(type,fnptr->dsp,(int)n,0); */ | |
1603 int reg_offset = 0; | |
1604 int offset = 0; | |
1605 | |
1606 for(args = fnptr->dsp;args;args = cadr(args)) { | |
1607 n = (NMTBL *)caddr(args); | |
1608 tag = n->sc; | |
1609 reg = n->dsp; | |
1610 if (!n||n==&null_nptr) error(REG_ERR); | |
1611 if (tag==REGISTER) { | |
1612 /* regs[reg]==INPUT_REG case should be considered */ | |
1613 n->dsp = offset; | |
245 | 1614 offset+=SIZE_OF_INT; |
119 | 1615 t = INT; |
1616 reg += reg_offset; /* for duplicated floating point argument */ | |
1617 } else if (tag==DREGISTER) { | |
145 | 1618 /* regs[reg]==INPUT_REG case should be considered */ |
119 | 1619 n->dsp = offset; |
120 | 1620 t = n->ty; |
245 | 1621 if(t==FLOAT) { offset+=SIZE_OF_FLOAT; reg_offset+=1; } |
1622 else if(t==DOUBLE) { offset+=SIZE_OF_DOUBLE; reg_offset+=2; } | |
120 | 1623 else error(-1); |
206 | 1624 } else if (tag==LREGISTER) { |
1625 /* regs[reg]==INPUT_REG case should be considered */ | |
1626 n->dsp = offset; | |
1627 t = n->ty; | |
245 | 1628 offset+=SIZE_OF_LONGLONG; reg_offset+=2; |
122 | 1629 } else { |
1630 offset += size(n->ty); | |
119 | 1631 continue; |
122 | 1632 } |
119 | 1633 n->sc = LVAR; |
1634 lvar = list2(LVAR,n->dsp); | |
1635 g_expr_u(assign_expr0(list2(LVAR,n->dsp),list3(tag,reg,(int)n),n->ty,t)); | |
206 | 1636 if (tag==REGISTER||tag==DREGISTER||tag==FREGISTER||tag==LREGISTER) { |
119 | 1637 free_register(reg); |
1638 } | |
1639 } | |
121 | 1640 my_func_args = offset; |
105 | 1641 } |
1642 | |
228 | 1643 static int |
1644 not_simple_p(int e3) | |
223 | 1645 { |
255 | 1646 return e3==FUNCTION||e3==CONV||e3==RSTRUCT||e3==STASS|| |
1647 e3==LLSHIFT||e3==LULSHIFT||e3==LRSHIFT||e3==LURSHIFT|| | |
1648 e3==LDIV||e3==LUDIV||e3==LMOD||e3==LUMOD; | |
223 | 1649 } |
1650 | |
1651 int | |
108 | 1652 simple_args(int e3) |
1653 { | |
228 | 1654 return !contains_in_list_p(e3,not_simple_p); |
108 | 1655 } |
1656 | |
119 | 1657 int |
1658 caller_arg_offset_v(int arg) | |
1659 { | |
245 | 1660 return ARG_LVAR_OFFSET+arg*SIZE_OF_INT; |
119 | 1661 } |
111 | 1662 |
233 | 1663 void |
1664 use_input_reg(int reg,int mode) | |
1665 { | |
1666 if (is_int_reg(reg)) { | |
1667 if (ireg&® == ireg) { | |
1668 if (creg==ireg) creg = 0; | |
1669 ireg = 0; | |
1670 } | |
1671 if (lreg) { | |
1672 if (regv_l(lreg)==reg) { | |
1673 regs[lreg]=0; | |
1674 if (regv_h(lreg)>reg&®s[regv_h(lreg)]==USING_REG) { | |
1675 free_register(regv_h(lreg)); | |
1676 } | |
1677 if (creg==lreg) creg = 0; | |
1678 lreg = 0; | |
1679 } else if (regv_h(lreg)==reg) { | |
1680 regs[lreg]=0; | |
1681 if (regv_h(lreg)>reg&®s[regv_l(lreg)]==USING_REG) { | |
1682 free_register(regv_l(lreg)); | |
1683 } | |
1684 if (creg==lreg) creg = 0; | |
1685 lreg = 0; | |
1686 } | |
1687 } | |
1688 } else if (is_longlong_reg(reg)) { | |
1689 use_input_reg(regv_h(reg),0); | |
1690 use_input_reg(regv_l(reg),0); | |
1691 } else if (is_float_reg(reg)) { | |
1692 if (freg&® == freg) { | |
1693 if (creg==freg) creg = 0; | |
1694 freg = 0; | |
1695 } | |
1696 } | |
1697 if (mode) use_reg(reg); | |
1698 } | |
1699 | |
108 | 1700 int |
89 | 1701 function(int e1) |
1702 { | |
119 | 1703 int e2,e3,e4,e5,nargs,t,r0,r1; |
104 | 1704 int arg,reg_arg,freg_arg,arg_assign; |
136
069960078249
remove redundant funcall argument for prototyped code in PowerPC case.
kono
parents:
135
diff
changeset
|
1705 int dots; |
111 | 1706 int reg_arg_list=0,ret_type,special_lvar; |
127 | 1707 NMTBL *fn = 0; |
108 | 1708 int jmp = 0; |
1709 char *jrn; | |
95 | 1710 |
111 | 1711 special_lvar = -1; |
136
069960078249
remove redundant funcall argument for prototyped code in PowerPC case.
kono
parents:
135
diff
changeset
|
1712 ret_type = cadr(cadddr(e1)); |
069960078249
remove redundant funcall argument for prototyped code in PowerPC case.
kono
parents:
135
diff
changeset
|
1713 if (ret_type==CHAR) ret_type=INT; |
069960078249
remove redundant funcall argument for prototyped code in PowerPC case.
kono
parents:
135
diff
changeset
|
1714 |
069960078249
remove redundant funcall argument for prototyped code in PowerPC case.
kono
parents:
135
diff
changeset
|
1715 /* check argments type is DOTS? */ |
069960078249
remove redundant funcall argument for prototyped code in PowerPC case.
kono
parents:
135
diff
changeset
|
1716 t = caddr(cadddr(e1)); |
069960078249
remove redundant funcall argument for prototyped code in PowerPC case.
kono
parents:
135
diff
changeset
|
1717 if (t==0 || t==DOTS) dots = 1; |
069960078249
remove redundant funcall argument for prototyped code in PowerPC case.
kono
parents:
135
diff
changeset
|
1718 else { |
069960078249
remove redundant funcall argument for prototyped code in PowerPC case.
kono
parents:
135
diff
changeset
|
1719 dots = 0; |
069960078249
remove redundant funcall argument for prototyped code in PowerPC case.
kono
parents:
135
diff
changeset
|
1720 for(t = caddr(cadddr(e1));t;t = cadr(t)) { |
069960078249
remove redundant funcall argument for prototyped code in PowerPC case.
kono
parents:
135
diff
changeset
|
1721 if (car(t)==DOTS) dots = 1; |
069960078249
remove redundant funcall argument for prototyped code in PowerPC case.
kono
parents:
135
diff
changeset
|
1722 } |
069960078249
remove redundant funcall argument for prototyped code in PowerPC case.
kono
parents:
135
diff
changeset
|
1723 } |
108 | 1724 |
1725 e2 = cadr(e1); | |
1726 if (car(e2) == FNAME) { | |
1727 fn=(NMTBL *)cadr(e2); | |
1728 } else { | |
1729 jmp = get_register_var(0); | |
1730 if (car(jmp)!=REGISTER) error(-1); | |
1731 reg_arg_list = list2(jmp,reg_arg_list); | |
116 | 1732 g_expr(e2); |
221 | 1733 if (!is_int_reg(creg)) error(-1); |
116 | 1734 code_register(creg,cadr(jmp)); |
1735 /* g_expr(assign_expr0(jmp,e2,INT,INT)); functions are lvalue */ | |
108 | 1736 } |
1737 | |
99 | 1738 /* now all input register vars are free */ |
108 | 1739 code_save_stacks(); |
222 | 1740 // set_lreg(LREG_LREGISTER,0); |
221 | 1741 set_freg(FREG_FREGISTER,0); |
207 | 1742 set_ireg(CREG_REGISTER,0); |
108 | 1743 |
1744 nargs = reg_arg = freg_arg = arg_assign = 0; | |
105 | 1745 for (e3 = reverse0(caddr(e1)); e3; e3 = cadr(e3)) { |
89 | 1746 t=caddr(e3); |
111 | 1747 e4 = car(e3); |
89 | 1748 if(scalar(t)) { |
122 | 1749 if (reg_arg>=MAX_INPUT_REGISTER_VAR) { |
119 | 1750 arg = list2(LVAR,caller_arg_offset_v(nargs)); |
116 | 1751 } else if (!simple_args(e3) && cadr(e3)) { |
105 | 1752 arg = get_register_var(0); |
104 | 1753 arg_assign = list2( |
137 | 1754 assign_expr0(get_input_register_var(reg_arg,0,0), |
1755 arg,t,t), | |
104 | 1756 arg_assign); |
96 | 1757 } else { |
126 | 1758 arg = get_input_register_var(reg_arg,0,0); |
89 | 1759 } |
99 | 1760 reg_arg_list = list2(arg,reg_arg_list); |
233 | 1761 /* protect from input register free */ |
1762 if (car(arg)==REGISTER) | |
1763 use_input_reg(cadr(arg),1); | |
99 | 1764 g_expr_u(assign_expr0(arg,e4,t,t)); |
89 | 1765 nargs ++ ; reg_arg++; |
99 | 1766 continue; |
202 | 1767 } else if (t==LONGLONG||t==ULONGLONG) { |
227 | 1768 if (reg_arg>=MAX_INPUT_REGISTER_VAR) { |
206 | 1769 arg = list2(LVAR,caller_arg_offset_v(nargs)); |
227 | 1770 } else if (reg_arg+1>=MAX_INPUT_REGISTER_VAR) { |
1771 // half register, half memory case | |
1772 // put whole long long anyway | |
1773 arg = list2(LVAR,caller_arg_offset_v(nargs)); | |
1774 arg_assign = list2( | |
232 | 1775 assign_expr0(r0=get_input_register_var(reg_arg,0,0), |
227 | 1776 arg,INT,INT), |
1777 arg_assign); | |
233 | 1778 use_input_reg(cadr(r0),1); |
206 | 1779 } else if (!simple_args(e3) && cadr(e3)) { |
223 | 1780 arg = get_lregister_var(0); |
255 | 1781 if (car(arg)==LREGISTER) { |
1782 // r0=get_input_lregiste... is not preserved | |
1783 // we cannot mark r0 used, it consumes unused register | |
1784 // but get_input_register is preserved. | |
1785 arg_assign = list2( | |
1786 assign_expr0(get_input_register_var(reg_arg,0,0), | |
1787 list2(REGISTER,regv_h(cadr(arg))),INT,INT), | |
1788 list2( | |
1789 assign_expr0(get_input_register_var(reg_arg+1,0,0), | |
1790 list2(REGISTER,regv_l(cadr(arg))),INT,INT), | |
1791 arg_assign)); | |
1792 } else { | |
1793 arg_assign = list2( | |
1794 assign_expr0(get_input_register_var(reg_arg,0,0), | |
1795 list2(LVAR,cadr(arg)+SIZE_OF_INT),INT,INT), | |
1796 list2( | |
1797 assign_expr0(get_input_register_var(reg_arg+1,0,0), | |
1798 list2(LVAR,cadr(arg)),INT,INT), | |
1799 arg_assign)); | |
1800 } | |
206 | 1801 } else { |
1802 arg = get_input_lregister_var(reg_arg,0,0); | |
233 | 1803 use_input_reg(cadr(arg),1); |
206 | 1804 } |
1805 reg_arg_list = list2(arg,reg_arg_list); | |
1806 g_expr_u(assign_expr0(arg,e4,t,t)); | |
1807 nargs ++ ; reg_arg++; | |
1808 nargs ++ ; reg_arg++; | |
202 | 1809 continue; |
89 | 1810 } else if (t==DOUBLE||t==FLOAT) { |
137 | 1811 if (reg_arg<MAX_INPUT_REGISTER_VAR) { |
119 | 1812 /* sigh... |
1813 printf requies floating value in integer registers | |
1814 */ | |
137 | 1815 if (dots) { |
1816 if (car(e4)==DRLVAR) { | |
1817 special_lvar = cadr(e4); | |
1818 e5 = list2(LVAR,special_lvar); | |
1819 } else { | |
245 | 1820 special_lvar = new_lvar(SIZE_OF_DOUBLE); |
137 | 1821 g_expr(assign_expr0( |
1822 (e5=list2(LVAR,special_lvar)),e4,DOUBLE,t)); | |
1823 reg_arg_list = list2(e5,reg_arg_list); | |
1824 e4 = list2(DREGISTER,freg); | |
1825 /* freg should not change until XXX */ | |
1826 } | |
1827 r0=get_input_register_var(reg_arg,0,0); | |
1828 r1 = reg_arg+1+MIN_TMP_REG; | |
206 | 1829 if (regs[r1]==PTRC_REG) |
1830 clear_ptr_cache_reg(list2(REGISTER,r1)); | |
137 | 1831 /* else if (regs[r1]) error(-1); */ |
1832 r1=get_input_register_var_1(reg_arg+1,0,0); | |
233 | 1833 use_input_reg(cadr(r0),1); /* protect from input register free */ |
1834 use_input_reg(cadr(r1),1); /* protect from input register free */ | |
137 | 1835 reg_arg_list = list2(r0,reg_arg_list); |
1836 reg_arg_list = list2(r1,reg_arg_list); | |
1837 arg_assign = list2( assign_expr0(r0,e5,INT,INT), arg_assign); | |
1838 arg_assign = list2( assign_expr0(r1, | |
245 | 1839 list2(LVAR,special_lvar+SIZE_OF_INT), |
137 | 1840 INT,INT), arg_assign); |
111 | 1841 } |
1842 reg_arg += 2; | |
1843 } | |
136
069960078249
remove redundant funcall argument for prototyped code in PowerPC case.
kono
parents:
135
diff
changeset
|
1844 if (dots && freg_arg>=4 && freg_arg<MAX_INPUT_DREGISTER_VAR) { |
119 | 1845 /* oh my god! |
1846 it requies integer register and floating register and | |
1847 stack value. You are crazy. | |
1848 */ | |
1849 arg_assign = list2( | |
1850 assign_expr0(list2(LVAR,caller_arg_offset_v(nargs)), | |
138 | 1851 get_input_dregister_var(freg_arg,0,0,1),t,t), |
119 | 1852 arg_assign); |
1853 } | |
122 | 1854 if (freg_arg>=MAX_INPUT_DREGISTER_VAR) { |
119 | 1855 arg = list2(LVAR,caller_arg_offset_v(nargs)); |
137 | 1856 } else if (!simple_args(e3) && cadr(e3)) { |
138 | 1857 arg = get_dregister_var(0,1); |
104 | 1858 arg_assign = list2( |
138 | 1859 assign_expr0(get_input_dregister_var(freg_arg,0,0,1), |
137 | 1860 arg,t,t), |
104 | 1861 arg_assign); |
99 | 1862 } else { |
138 | 1863 arg = get_input_dregister_var(freg_arg,0,0,1); |
99 | 1864 } |
233 | 1865 reg_arg_list = list2(arg,reg_arg_list); |
208 | 1866 if (car(arg)==DREGISTER) |
233 | 1867 use_input_reg(cadr(arg),1); /* protect from input register free */ |
118 | 1868 g_expr_u(assign_expr0(arg,e4,t,t)); /* XXX */ |
99 | 1869 freg_arg++; |
245 | 1870 nargs += size(t)/SIZE_OF_INT; |
89 | 1871 continue; |
203 | 1872 } else if (t>=0&&(car(t)==STRUCT||car(t)==UNION)) { |
119 | 1873 arg = list2(LVAR,caller_arg_offset_v(nargs)); |
1874 nargs += struct_push(e4,t,arg); | |
89 | 1875 continue; |
1876 } else { | |
1877 error(TYERR); | |
1878 } | |
1879 ++nargs; | |
1880 } | |
116 | 1881 if (max_func_args<nargs) max_func_args=nargs; |
104 | 1882 for(;arg_assign;arg_assign=cadr(arg_assign)) { |
1883 g_expr_u(car(arg_assign)); | |
1884 } | |
96 | 1885 clear_ptr_cache(); |
89 | 1886 if (car(e2) == FNAME) { |
108 | 1887 printf("\tbl\tL_%s$stub\n",fn->nm); |
89 | 1888 } else { |
108 | 1889 jrn = register_name(cadr(jmp)); |
89 | 1890 printf("\tmtctr %s\n",jrn); |
1891 printf("\tbctrl\n"); | |
1892 } | |
99 | 1893 for(;reg_arg_list;reg_arg_list=cadr(reg_arg_list)) { |
108 | 1894 arg = car(reg_arg_list); |
206 | 1895 if (car(arg)==REGISTER||car(arg)==DREGISTER||car(arg)==FREGISTER |
1896 ||car(arg)==LREGISTER) | |
147 | 1897 free_register(cadr(arg)); |
119 | 1898 else if (car(arg)==LVAR&&cadr(arg)<0) free_lvar(cadr(arg)); |
99 | 1899 } |
105 | 1900 if (ret_type==DOUBLE||ret_type==FLOAT) { |
104 | 1901 set_freg(RET_FREGISTER,0); |
206 | 1902 } else if (ret_type==ULONGLONG||ret_type==LONGLONG) { |
1903 set_lreg(RET_LREGISTER,0); | |
207 | 1904 use_reg(RET_LREGISTER); |
105 | 1905 } else if (ret_type==VOID) { |
96 | 1906 } else { |
207 | 1907 set_ireg(RET_REGISTER,0); |
96 | 1908 } |
105 | 1909 return ret_type; |
89 | 1910 } |
1911 | |
1912 void | |
1913 code_frame_pointer(int e3) { | |
221 | 1914 use_int(e3); |
128 | 1915 #if R1SAVE |
1916 printf("\tmr r1,%s\n",register_name(e3)); | |
1917 #else | |
126 | 1918 printf("\tmr r30,%s\n",register_name(e3)); |
128 | 1919 #endif |
89 | 1920 } |
1921 | |
1922 | |
1923 void | |
1924 code_fix_frame_pointer(int disp_offset) { | |
128 | 1925 int l = 0; |
1926 printf("\tla r30,"); | |
1927 printf("lo16(%d+L_%d)(r30)\n",FUNC_LVAR,lvar_offset_label); | |
89 | 1928 } |
1929 | |
1930 void | |
1931 code_jmp(char *s) { | |
128 | 1932 max_reg_var = REG_VAR_BASE-REG_VAR_MIN; |
1933 max_freg_var = FREG_VAR_BASE-FREG_VAR_MIN; | |
89 | 1934 printf("\tb L_%s$stub\n",s); |
1935 } | |
1936 | |
1937 | |
1938 void | |
1939 code_indirect_jmp(int e2) { | |
128 | 1940 max_reg_var = REG_VAR_BASE-REG_VAR_MIN; |
1941 max_freg_var = FREG_VAR_BASE-FREG_VAR_MIN; | |
221 | 1942 use_int(e2); |
89 | 1943 printf("\tmtctr %s\n",register_name(e2)); |
1944 printf("\tbctr\n"); | |
1945 } | |
1946 | |
95 | 1947 int |
221 | 1948 code_rindirect(int e1, int reg,int offset, int us) |
89 | 1949 { |
221 | 1950 char *crn,*rrn; |
196 | 1951 g_expr(e1); |
221 | 1952 if (!is_int_reg(creg)) error(-1); |
90 | 1953 crn=register_name(creg); |
221 | 1954 use_int(reg); |
1955 rrn=register_name(reg); | |
1956 printf("\tlwz %s,%d(%s)\n",rrn,offset,crn); | |
206 | 1957 return us?UNSIGNED:INT; |
196 | 1958 } |
1959 | |
1960 int | |
245 | 1961 code_crindirect(int e1, int reg,int offset, int sign) |
196 | 1962 { |
221 | 1963 char *crn,*rrn; |
196 | 1964 g_expr(e1); |
221 | 1965 if (!is_int_reg(creg)) error(-1); |
196 | 1966 crn=register_name(creg); |
221 | 1967 use_int(reg); |
1968 rrn=register_name(reg); | |
245 | 1969 printf("\tlbz %s,%d(%s)\n",rrn,offset,crn); |
1970 if (sign) { | |
1971 cext(sign,1,reg); | |
95 | 1972 return CHAR; |
196 | 1973 } |
245 | 1974 return UCHAR; |
196 | 1975 } |
1976 | |
1977 int | |
245 | 1978 code_srindirect(int e1, int reg,int offset, int sign) |
196 | 1979 { |
221 | 1980 char *crn,*rrn; |
196 | 1981 g_expr(e1); |
221 | 1982 if (!is_int_reg(creg)) error(-1); |
196 | 1983 crn=register_name(creg); |
221 | 1984 use_int(reg); |
1985 rrn = register_name(reg); | |
245 | 1986 printf("\tlhz %s,%d(%s)\n",rrn,offset,crn); |
1987 if (sign) { | |
1988 cext(sign,SIZE_OF_SHORT,reg); | |
165 | 1989 return SHORT; |
89 | 1990 } |
245 | 1991 return USHORT; |
89 | 1992 } |
1993 | |
196 | 1994 #if FLOAT_CODE |
1995 int | |
221 | 1996 code_drindirect(int e1, int reg,int offset, int d) |
196 | 1997 { |
1998 char *crn; | |
1999 g_expr(e1); | |
221 | 2000 if (!is_int_reg(creg)) error(-1); |
196 | 2001 crn=register_name(creg); |
221 | 2002 use_float(d,reg); |
196 | 2003 printf("\t%s %s,%d(%s)\n",fload(d), |
221 | 2004 fregister_name(reg),offset,crn); |
206 | 2005 return d?DOUBLE:FLOAT; |
196 | 2006 } |
2007 #endif | |
2008 | |
2009 #if LONGLONG_CODE | |
2010 int | |
221 | 2011 code_lrindirect(int e1, int reg, int offset, int us) |
196 | 2012 { |
2013 char *crn; | |
222 | 2014 int creg0; |
2015 | |
196 | 2016 g_expr(e1); |
221 | 2017 if (!is_int_reg(creg)) error(-1); |
222 | 2018 crn=register_name(creg0=creg); |
221 | 2019 use_longlong(reg); |
222 | 2020 if (creg0!=regv_h(reg)) { |
2021 printf("\tlwz %s,%d(%s)\n",lregister_name_high(reg),offset,crn); | |
245 | 2022 printf("\tlwz %s,%d(%s)\n",lregister_name_low(reg),offset+SIZE_OF_INT,crn); |
222 | 2023 } else { |
245 | 2024 printf("\tlwz %s,%d(%s)\n",lregister_name_low(reg),offset+SIZE_OF_INT,crn); |
222 | 2025 printf("\tlwz %s,%d(%s)\n",lregister_name_high(reg),offset,crn); |
2026 } | |
206 | 2027 return us?ULONGLONG:LONGLONG; |
196 | 2028 } |
2029 #endif | |
2030 | |
2031 | |
89 | 2032 void |
103 | 2033 code_assign_gvar(int e2,int creg,int byte) { |
90 | 2034 int r; |
221 | 2035 use_int(creg); |
109 | 2036 r = get_ptr_cache((NMTBL*)cadr(e2)); |
211 | 2037 code_assign(r,byte,creg); |
89 | 2038 } |
2039 | |
2040 void | |
103 | 2041 code_assign_lvar(int e2,int creg,int byte) { |
90 | 2042 char *crn; |
221 | 2043 use_int(creg); |
90 | 2044 crn=register_name(creg); |
119 | 2045 lvar_intro(e2); |
165 | 2046 if (byte==1) { |
2047 printf("\tstb %s,",crn); | |
245 | 2048 } else if (byte==SIZE_OF_SHORT) { |
165 | 2049 printf("\tsth %s,",crn); |
90 | 2050 } else { |
165 | 2051 printf("\tstw %s,",crn); |
90 | 2052 } |
165 | 2053 lvar(e2); |
89 | 2054 } |
2055 | |
2056 void | |
111 | 2057 code_assign_register(int e2,int byte,int creg) { |
221 | 2058 use_int(creg); |
104 | 2059 if (e2!=creg) |
2060 printf("\tmr %s,%s\n",register_name(e2),register_name(creg)); | |
89 | 2061 } |
2062 | |
2063 void | |
118 | 2064 code_assign(int e2,int byte,int creg) { |
233 | 2065 char *drn; |
221 | 2066 char *crn; |
233 | 2067 use_int(e2); |
2068 drn=register_name(e2); | |
221 | 2069 use_int(creg); |
2070 crn=register_name(creg); | |
95 | 2071 |
165 | 2072 if (byte==1) { |
108 | 2073 printf("\tstb %s,0(%s)\n",crn,drn); |
245 | 2074 } else if (byte==SIZE_OF_SHORT) { |
165 | 2075 printf("\tsth %s,0(%s)\n",crn,drn); |
90 | 2076 } else { |
108 | 2077 printf("\tstw %s,0(%s)\n",crn,drn); |
90 | 2078 } |
89 | 2079 } |
2080 | |
2081 | |
2082 void | |
221 | 2083 code_register_assop(int e2,int reg, int op,int byte) { |
2084 // reg <= reg(e2) op=reg | |
2085 use_int(reg); | |
2086 tosop(op,e2,reg); | |
89 | 2087 } |
2088 | |
2089 void | |
221 | 2090 code_assop(int op,int creg, int byte,int sign) { |
90 | 2091 char *xrn,*crn,*drn; |
89 | 2092 int xreg; |
90 | 2093 int edx = get_register(); if(!edx) error(-1); |
221 | 2094 // (*creg) op = pop() |
2095 | |
2096 use_int(creg); | |
93 | 2097 xrn = register_name(xreg = emit_pop(0)); /* pop e3 value */ |
113 | 2098 printf("# assop\n\tmr %s,%s\n",register_name(edx),register_name(creg)); |
221 | 2099 ld_indexx(byte,0,edx,creg,sign); |
2100 tosop(op,creg,xreg); | |
90 | 2101 crn = register_name(creg); |
2102 drn = register_name(edx); | |
165 | 2103 if (byte==1) { |
108 | 2104 printf("\tstb %s,0(%s)\n",crn,drn); |
245 | 2105 } else if (byte==SIZE_OF_SHORT) { |
165 | 2106 printf("\tsth %s,0(%s)\n",crn,drn); |
90 | 2107 } else { |
108 | 2108 printf("\tstw %s,0(%s)\n",crn,drn); |
90 | 2109 } |
2110 free_register(edx); | |
89 | 2111 emit_pop_free(xreg); |
2112 } | |
2113 | |
2114 | |
2115 void | |
221 | 2116 tosop(int op,int creg,int oreg) |
89 | 2117 { |
221 | 2118 int dx = -1; |
252 | 2119 int ox = -1; |
95 | 2120 char *orn,*crn,*drn; |
221 | 2121 // creg = creg op oreg |
2122 | |
2123 use_int(creg); | |
103 | 2124 if(oreg==-1) { |
2125 error(-1); | |
2126 } else if (oreg<= -REG_LVAR_OFFSET) { | |
252 | 2127 ox = get_register(); if (ox<0) error(-1); |
2128 code_rlvar(oreg+REG_LVAR_OFFSET,ox); | |
2129 oreg = ox; | |
103 | 2130 } |
2131 | |
89 | 2132 switch(op) { |
2133 case LSHIFT: | |
2134 case ULSHIFT: | |
221 | 2135 shift("slw",creg,oreg); |
252 | 2136 if(ox!=-1) free_register(ox); |
89 | 2137 return; |
2138 case RSHIFT: | |
221 | 2139 shift("sraw",creg,oreg); |
252 | 2140 if(ox!=-1) free_register(ox); |
89 | 2141 return; |
2142 case URSHIFT: | |
221 | 2143 shift("srw",creg,oreg); |
252 | 2144 if(ox!=-1) free_register(ox); |
89 | 2145 return; |
2146 } | |
93 | 2147 orn = register_name(oreg); |
89 | 2148 crn = register_name(creg); |
2149 switch(op) { | |
2150 case ADD: | |
114 | 2151 printf("\tadd %s,%s,%s\n",crn,crn,orn); |
89 | 2152 break; |
2153 case SUB: | |
114 | 2154 printf("\tsub %s,%s,%s\n",crn,crn,orn); |
89 | 2155 break; |
112 | 2156 case CMP: |
113 | 2157 printf("\tcmpw cr0,%s,%s\n",crn,orn); |
112 | 2158 break; |
89 | 2159 case BAND: |
114 | 2160 printf("\tand %s,%s,%s\n",crn,crn,orn); |
89 | 2161 break; |
2162 case EOR: | |
114 | 2163 printf("\txor %s,%s,%s\n",crn,crn,orn); |
89 | 2164 break; |
2165 case BOR: | |
114 | 2166 printf("\tor %s,%s,%s\n",crn,crn,orn); |
89 | 2167 break; |
2168 case MUL: | |
116 | 2169 printf("\tmullw %s,%s,%s\n",crn,crn,orn); |
2170 break; | |
89 | 2171 case UMUL: |
114 | 2172 printf("\tmullw %s,%s,%s\n",crn,crn,orn); |
89 | 2173 break; |
2174 case DIV: | |
114 | 2175 printf("\tdivw %s,%s,%s\n",crn,crn,orn); |
90 | 2176 break; |
89 | 2177 case UDIV: |
114 | 2178 printf("\tdivwu %s,%s,%s\n",crn,crn,orn); |
89 | 2179 break; |
2180 case MOD: | |
90 | 2181 dx=get_register(); |
95 | 2182 drn = register_name(dx); |
116 | 2183 printf("\tdivw %s,%s,%s\n",drn,crn,orn); |
2184 printf("\tmullw %s,%s,%s\n",drn,drn,orn); | |
2185 printf("\tsubf %s,%s,%s\n",crn,drn,crn); | |
90 | 2186 break; |
89 | 2187 case UMOD: |
90 | 2188 dx=get_register(); |
95 | 2189 drn = register_name(dx); |
114 | 2190 printf("\tdivwu %s,%s,%s\n",drn,crn,orn); |
116 | 2191 printf("\tmullw %s,%s,%s\n",drn,drn,orn); |
2192 printf("\tsubf %s,%s,%s\n",crn,drn,crn); | |
89 | 2193 break; |
112 | 2194 default: |
2195 error(-1); | |
89 | 2196 } |
221 | 2197 if(dx!=-1) free_register(dx); |
252 | 2198 if(ox!=-1) free_register(ox); |
89 | 2199 } |
2200 | |
189 | 2201 int |
2202 code_const_op_p(int op,int v) | |
2203 { | |
240 | 2204 if (car(v)!=CONST) return 0; |
189 | 2205 if (op==BAND||op==DIV||op==UDIV||op==MOD||op==UMOD) return 0; |
240 | 2206 v = cadr(v); |
214 | 2207 return (-32766<v&&v<32767); |
189 | 2208 } |
2209 | |
211 | 2210 void |
221 | 2211 oprtc(int op,int creg, int v) |
189 | 2212 { |
221 | 2213 char *crn; |
2214 use_int(creg); | |
2215 crn = register_name(creg); | |
240 | 2216 v = cadr(v); |
221 | 2217 |
189 | 2218 switch(op) { |
2219 case LSHIFT: | |
2220 case ULSHIFT: | |
2221 printf("\tslwi %s,%s,%d\n",crn,crn,v); | |
2222 return; | |
2223 case RSHIFT: | |
2224 printf("\tsrawi %s,%s,%d\n",crn,crn,v); | |
2225 return; | |
2226 case URSHIFT: | |
2227 printf("\tsrwi %s,%s,%d\n",crn,crn,v); | |
2228 return; | |
2229 case ADD: | |
2230 printf("\taddi %s,%s,lo16(%d)\n",crn,crn,v); | |
2231 break; | |
2232 case SUB: | |
221 | 2233 printf("\taddi %s,%s,lo16(-%d)\n",crn,crn,v); |
189 | 2234 break; |
2235 case CMP: | |
2236 printf("\tcmpwi cr0,%s,lo16(%d)\n",crn,v); | |
2237 break; | |
2238 case EOR: | |
2239 printf("\txori %s,%s,lo16(%d)\n",crn,crn,v); | |
2240 break; | |
2241 case BOR: | |
2242 printf("\tori %s,%s,lo16(%d)\n",crn,crn,v); | |
2243 break; | |
2244 case MUL: | |
2245 printf("\tmulli %s,%s,lo16(%d)\n",crn,crn,v); | |
2246 break; | |
2247 case UMUL: | |
2248 printf("\tmulli %s,%s,lo16(%d)\n",crn,crn,v); | |
2249 break; | |
2250 default: | |
2251 error(-1); | |
2252 } | |
2253 } | |
89 | 2254 |
2255 void | |
221 | 2256 shift(char *op, int creg, int reg) |
89 | 2257 { |
221 | 2258 char *crn; |
93 | 2259 char *rrn = register_name(reg); |
221 | 2260 use_int(creg); |
2261 crn = register_name(creg); | |
186 | 2262 printf("\t%s %s,%s,%s\n",op,crn,crn,rrn); |
89 | 2263 } |
2264 | |
2265 void | |
221 | 2266 ld_indexx(int byte, int n, int xreg,int creg, int sign) |
89 | 2267 { |
221 | 2268 char *crn; |
2269 use_int(creg); | |
2270 crn = register_name(creg); | |
246 | 2271 printf("\t%s %s,%d(%s)\n",cload(byte),register_name(creg),n, |
90 | 2272 register_name(xreg)); |
246 | 2273 cext(sign,byte,creg); |
89 | 2274 } |
2275 | |
95 | 2276 int |
2277 code_csvalue() | |
2278 { | |
2279 return creg; | |
2280 } | |
2281 | |
89 | 2282 void |
95 | 2283 code_cmpdimm(int e, int csreg) |
89 | 2284 { |
2285 /* used in dosiwtch() */ | |
2286 if(chk) return; | |
108 | 2287 printf("\tcmpwi cr0,%s,%d\n",register_name(csreg),e); |
89 | 2288 } |
2289 | |
2290 void | |
2291 code_opening(char *filename) | |
2292 { | |
2293 printf("\t.file \"%s\"\n",filename); | |
108 | 2294 /* printf("\t.version\t\"01.01\"\n"); */ |
89 | 2295 /* printf("gcc2_compiled.:\n"); */ |
2296 printf(".text\n"); | |
2297 } | |
2298 | |
2299 void | |
95 | 2300 rexpr(int e1, int l1, char *s,int t) |
89 | 2301 { |
90 | 2302 g_expr(list3(CMP,cadr(e1),caddr(e1))); |
102 | 2303 printf("\tb%s cr0,L_%d\n",s,l1); |
89 | 2304 } |
2305 | |
2306 | |
2307 void | |
2308 jcond(int l, char cond) | |
2309 { | |
2310 if (chk) return; | |
102 | 2311 printf("\tb%s cr0,L_%d\n",cond?"ne":"eq",l); |
89 | 2312 } |
2313 | |
2314 void | |
2315 jmp(int l) | |
2316 { | |
2317 control=0; | |
2318 if (chk) return; | |
102 | 2319 printf("\tb\tL_%d\n",l); |
89 | 2320 } |
2321 | |
2322 void | |
2323 gen_comment(char *s) | |
2324 { | |
2325 if (chk) return; | |
2326 printf("## %s",s); | |
2327 } | |
2328 | |
2329 void | |
2330 code_enter(char *name) | |
2331 { | |
100
a9e6f2a2946f
Wrote all code for PowerPC and no compile error. Let's fix all bugs...
kono
parents:
99
diff
changeset
|
2332 if (output_mode!=TEXT_EMIT_MODE) |
a9e6f2a2946f
Wrote all code for PowerPC and no compile error. Let's fix all bugs...
kono
parents:
99
diff
changeset
|
2333 text_mode(); |
a9e6f2a2946f
Wrote all code for PowerPC and no compile error. Let's fix all bugs...
kono
parents:
99
diff
changeset
|
2334 else |
108 | 2335 printf("\t.align 2\n"); |
89 | 2336 if (stmode!=STATIC) |
102 | 2337 printf(".globl _%s\n",name); |
126 | 2338 #ifdef DOT_SIZE |
89 | 2339 printf("\t.type\t%s,@function\n",name); |
126 | 2340 #endif |
101 | 2341 printf("_%s:\n",name); |
100
a9e6f2a2946f
Wrote all code for PowerPC and no compile error. Let's fix all bugs...
kono
parents:
99
diff
changeset
|
2342 code_disp_label=fwdlabel(); |
128 | 2343 printf("\tla r1,lo16(L_%d)(r30)\n",code_disp_label); |
126 | 2344 printf("\tbcl 20,31,L_%d\n",code_base = fwdlabel()); |
2345 fwddef(code_base); | |
2346 printf("\tmflr r31\n"); | |
119 | 2347 max_func_args = 0; |
89 | 2348 } |
2349 | |
2350 | |
2351 void | |
2352 code_enter1(int args) | |
2353 { | |
222 | 2354 // set_lreg(LREG_LREGISTER,0); |
207 | 2355 set_ireg(CREG_REGISTER,0); |
106 | 2356 set_freg(FREG_FREGISTER,0); |
89 | 2357 } |
2358 | |
2359 void | |
2360 code_leave(char *name) | |
2361 { | |
128 | 2362 int r1_offsetv; |
245 | 2363 disp&= -SIZE_OF_INT; |
2364 r1_offsetv = -disp+max_func_args*SIZE_OF_INT+code_disp_offset; | |
128 | 2365 |
2366 printf(".set L_%d,%d\n",code_disp_label,-r1_offsetv); | |
89 | 2367 local_table(); |
208 | 2368 // free_all_register(); |
89 | 2369 } |
2370 | |
2371 void | |
2372 enter(char *name) | |
2373 { | |
100
a9e6f2a2946f
Wrote all code for PowerPC and no compile error. Let's fix all bugs...
kono
parents:
99
diff
changeset
|
2374 if (output_mode!=TEXT_EMIT_MODE) |
a9e6f2a2946f
Wrote all code for PowerPC and no compile error. Let's fix all bugs...
kono
parents:
99
diff
changeset
|
2375 text_mode(); |
a9e6f2a2946f
Wrote all code for PowerPC and no compile error. Let's fix all bugs...
kono
parents:
99
diff
changeset
|
2376 else |
108 | 2377 printf("\t.align 2\n"); |
89 | 2378 if (stmode!=STATIC) |
101 | 2379 printf(".globl _%s\n",name); |
108 | 2380 /* |
100
a9e6f2a2946f
Wrote all code for PowerPC and no compile error. Let's fix all bugs...
kono
parents:
99
diff
changeset
|
2381 printf("\t.type\t%s,@function\n",name); |
108 | 2382 */ |
101 | 2383 printf("_%s:\n",name); |
100
a9e6f2a2946f
Wrote all code for PowerPC and no compile error. Let's fix all bugs...
kono
parents:
99
diff
changeset
|
2384 code_setup=fwdlabel(); |
a9e6f2a2946f
Wrote all code for PowerPC and no compile error. Let's fix all bugs...
kono
parents:
99
diff
changeset
|
2385 printf("\tmflr r0\n"); |
102 | 2386 printf("\tbl L_%d\n",code_setup); |
100
a9e6f2a2946f
Wrote all code for PowerPC and no compile error. Let's fix all bugs...
kono
parents:
99
diff
changeset
|
2387 code_base=fwdlabel(); |
111 | 2388 fwddef(code_base); |
116 | 2389 r1_offset_label = fwdlabel(); |
2390 lvar_offset_label = fwdlabel(); | |
2391 printf("\tstwu r1,lo16(-L_%d)(r1)\n",r1_offset_label); | |
100
a9e6f2a2946f
Wrote all code for PowerPC and no compile error. Let's fix all bugs...
kono
parents:
99
diff
changeset
|
2392 printf("\tmr r30,r1\n"); |
a9e6f2a2946f
Wrote all code for PowerPC and no compile error. Let's fix all bugs...
kono
parents:
99
diff
changeset
|
2393 printf("\tmflr r31\n"); |
116 | 2394 max_func_args = 0; |
89 | 2395 } |
2396 | |
2397 void | |
2398 enter1() | |
2399 { | |
182 | 2400 text_mode(); |
208 | 2401 // set_lreg(LREG_LREGISTER,0); |
207 | 2402 set_ireg(CREG_REGISTER,0); |
106 | 2403 set_freg(FREG_FREGISTER,0); |
100
a9e6f2a2946f
Wrote all code for PowerPC and no compile error. Let's fix all bugs...
kono
parents:
99
diff
changeset
|
2404 } |
a9e6f2a2946f
Wrote all code for PowerPC and no compile error. Let's fix all bugs...
kono
parents:
99
diff
changeset
|
2405 |
a9e6f2a2946f
Wrote all code for PowerPC and no compile error. Let's fix all bugs...
kono
parents:
99
diff
changeset
|
2406 int |
a9e6f2a2946f
Wrote all code for PowerPC and no compile error. Let's fix all bugs...
kono
parents:
99
diff
changeset
|
2407 reg_save_offset() |
a9e6f2a2946f
Wrote all code for PowerPC and no compile error. Let's fix all bugs...
kono
parents:
99
diff
changeset
|
2408 { |
108 | 2409 return -( |
245 | 2410 (REAL_MAX_REGISTER-(REG_VAR_BASE-max_reg_var))*SIZE_OF_INT+ |
2411 (REAL_MAX_FREGISTER-(FREG_VAR_BASE-max_freg_var))*SIZE_OF_DOUBLE | |
108 | 2412 ); |
89 | 2413 } |
2414 | |
2415 void | |
2416 leave(int control, char *name) | |
2417 { | |
130 | 2418 int retcont1=0,sz; |
128 | 2419 |
2420 if (max_freg_var>=0 && max_freg_var<=3) max_freg_var=3; | |
2421 reg_save = reg_save_offset(); | |
111 | 2422 |
100
a9e6f2a2946f
Wrote all code for PowerPC and no compile error. Let's fix all bugs...
kono
parents:
99
diff
changeset
|
2423 if (control) { |
108 | 2424 code_set_return_register(1); |
89 | 2425 } |
126 | 2426 if (retcont) { |
2427 if (control) jmp(retlabel); | |
128 | 2428 retcont1 = fwdlabel(); |
126 | 2429 fwddef(retcont); |
2430 if (cadr(fnptr->ty)==FLOAT||cadr(fnptr->ty)==DOUBLE) { | |
2431 printf("\tfmr f1,f31\n"); | |
128 | 2432 } else if (cadr(fnptr->ty)>0&&( |
2433 car(cadr(fnptr->ty))==STRUCT || | |
2434 car(cadr(fnptr->ty))==UNION)) { | |
2435 sz = size(cadr(fnptr->ty)); | |
2436 printf("\tli r7,%d\n",sz); | |
2437 printf("\tsubl r6,r7,r30\n"); | |
245 | 2438 printf("\tlwz r3,lo16(%d)(r30)\n",(my_func_args-1)*SIZE_OF_INT); |
128 | 2439 emit_copy(6,3,sz,0,1,1); |
126 | 2440 } else if (cadr(fnptr->ty)!=VOID) { |
2441 printf("\tmr r3,r29\n"); | |
2442 } | |
128 | 2443 #if !R1SAVE |
2444 printf("\tla r1,lo16(%d)(r30)\n", | |
245 | 2445 -reg_save+my_func_args*SIZE_OF_INT); |
128 | 2446 #endif |
2447 printf("\tb L_%d\n",retcont1); | |
126 | 2448 } |
89 | 2449 fwddef(retlabel); |
100
a9e6f2a2946f
Wrote all code for PowerPC and no compile error. Let's fix all bugs...
kono
parents:
99
diff
changeset
|
2450 printf("\tlwz r1,0(r1)\n"); |
128 | 2451 if (retcont) { |
2452 fwddef(retcont1); | |
2453 } | |
110 | 2454 if (max_freg_var>=0) { |
2455 printf("\tlmw r%d,%d(r1)\n", | |
111 | 2456 REG_VAR_BASE-max_reg_var,reg_save); |
2457 freg_save = 72-(REAL_MAX_FREGISTER-(FREG_VAR_BASE-max_freg_var))*4; | |
100
a9e6f2a2946f
Wrote all code for PowerPC and no compile error. Let's fix all bugs...
kono
parents:
99
diff
changeset
|
2458 printf("\tb restFP+%d ; restore f%d-f31\n", |
111 | 2459 freg_save, |
100
a9e6f2a2946f
Wrote all code for PowerPC and no compile error. Let's fix all bugs...
kono
parents:
99
diff
changeset
|
2460 FREG_VAR_BASE-max_freg_var); |
a9e6f2a2946f
Wrote all code for PowerPC and no compile error. Let's fix all bugs...
kono
parents:
99
diff
changeset
|
2461 } else { |
a9e6f2a2946f
Wrote all code for PowerPC and no compile error. Let's fix all bugs...
kono
parents:
99
diff
changeset
|
2462 printf("\tlwz r0,8(r1)\n"); |
a9e6f2a2946f
Wrote all code for PowerPC and no compile error. Let's fix all bugs...
kono
parents:
99
diff
changeset
|
2463 printf("\tmtlr r0\n"); |
110 | 2464 printf("\tlmw r%d,%d(r1)\n", |
116 | 2465 REG_VAR_BASE-max_reg_var,reg_save); |
100
a9e6f2a2946f
Wrote all code for PowerPC and no compile error. Let's fix all bugs...
kono
parents:
99
diff
changeset
|
2466 printf("\tblr\n"); |
a9e6f2a2946f
Wrote all code for PowerPC and no compile error. Let's fix all bugs...
kono
parents:
99
diff
changeset
|
2467 } |
89 | 2468 |
245 | 2469 disp &= -SIZE_OF_INT; |
100
a9e6f2a2946f
Wrote all code for PowerPC and no compile error. Let's fix all bugs...
kono
parents:
99
diff
changeset
|
2470 fwddef(code_setup); |
110 | 2471 printf("\tstmw r%d,%d(r1)\n", |
116 | 2472 REG_VAR_BASE-max_reg_var,reg_save); |
110 | 2473 printf("\tstw r0,8(r1)\n"); |
2474 if (max_freg_var>=0) | |
100
a9e6f2a2946f
Wrote all code for PowerPC and no compile error. Let's fix all bugs...
kono
parents:
99
diff
changeset
|
2475 printf("\tb saveFP+%d ; save f%d-f31\n", |
111 | 2476 freg_save, |
100
a9e6f2a2946f
Wrote all code for PowerPC and no compile error. Let's fix all bugs...
kono
parents:
99
diff
changeset
|
2477 FREG_VAR_BASE-max_freg_var); |
110 | 2478 else { |
100
a9e6f2a2946f
Wrote all code for PowerPC and no compile error. Let's fix all bugs...
kono
parents:
99
diff
changeset
|
2479 printf("\tblr\n"); |
110 | 2480 } |
100
a9e6f2a2946f
Wrote all code for PowerPC and no compile error. Let's fix all bugs...
kono
parents:
99
diff
changeset
|
2481 |
116 | 2482 code_offset_set(); |
89 | 2483 local_table(); |
2484 labelno++; | |
208 | 2485 // free_all_register(); |
89 | 2486 } |
2487 | |
2488 | |
2489 void | |
107 | 2490 code_set_return_register(int mode) { |
111 | 2491 if (cadr(fnptr->ty)==DOUBLE||cadr(fnptr->ty)==FLOAT) { |
107 | 2492 set_freg(RET_FREGISTER,mode); |
206 | 2493 } else if (cadr(fnptr->ty)==LONGLONG||cadr(fnptr->ty)==ULONGLONG) { |
2494 set_lreg(RET_LREGISTER,mode); | |
147 | 2495 } else if (cadr(fnptr->ty)==VOID) { |
103 | 2496 } else { |
207 | 2497 set_ireg(RET_REGISTER,mode); |
103 | 2498 } |
89 | 2499 } |
2500 | |
187 | 2501 int |
2502 code_get_fixed_creg(int reg,int type) { | |
2503 return creg; | |
2504 } | |
2505 | |
89 | 2506 void |
187 | 2507 code_set_fixed_creg(int reg,int mode,int type) { |
108 | 2508 if (type==FLOAT||type==DOUBLE) { |
187 | 2509 set_freg(reg,mode); |
206 | 2510 } else if (type==LONGLONG||type==ULONGLONG) { |
195 | 2511 set_lreg(reg,mode); |
210 | 2512 // use_reg(reg); |
108 | 2513 } else { |
207 | 2514 set_ireg(reg,mode); |
108 | 2515 } |
107 | 2516 } |
2517 | |
2518 void | |
89 | 2519 gen_gdecl(char *n, int gpc) |
2520 { | |
102 | 2521 /* |
89 | 2522 if (stmode!=STATIC) |
99 | 2523 printf(".globl _%s\n",n); |
102 | 2524 */ |
89 | 2525 } |
2526 | |
211 | 2527 void |
2528 | |
89 | 2529 align(int t) |
2530 { | |
2531 if (t!=CHAR) { | |
2532 if (data_alignment & 1) | |
2533 printf("\t.align 2\n"); | |
2534 data_alignment = 0; | |
2535 } | |
2536 } | |
2537 | |
2538 void | |
2539 emit_data(int e, int t, NMTBL *n) | |
2540 { | |
2541 int l; | |
195 | 2542 #if FLOAT_CODE |
89 | 2543 double d; |
2544 float f; | |
195 | 2545 #endif |
206 | 2546 #if LONGLONG_CODE |
2547 long long ll; | |
2548 #endif | |
89 | 2549 char *name; |
2550 name = n->nm; | |
156 | 2551 if(mode!=GDECL && mode!=STADECL) { |
89 | 2552 error(-1); return; |
2553 } | |
2554 if (chk) return; | |
2555 if (n->dsp != -1) { | |
2556 n->dsp = -1; /* initiallized flag */ | |
102 | 2557 printf(".globl\t_%s\n",name); |
89 | 2558 data_mode(name); |
2559 align(t); | |
102 | 2560 printf("_%s:\n",name); |
89 | 2561 } else { |
2562 data_mode(0); | |
2563 } | |
2564 if(car(e)==CONST) { | |
168 | 2565 if (t==CHAR||t==UCHAR) { |
89 | 2566 printf("\t.byte %d\n",cadr(e)); |
2567 if (data_alignment>0) | |
2568 data_alignment++; | |
2569 gpc += 1; | |
168 | 2570 } else if (t==SHORT||t==USHORT) { |
2571 printf("\t.short %d\n",cadr(e)); | |
89 | 2572 if (data_alignment>0) data_alignment++; |
245 | 2573 gpc += SIZE_OF_SHORT; |
89 | 2574 } else { |
2575 printf("\t.long %d\n",cadr(e)); | |
245 | 2576 gpc += SIZE_OF_INT; |
89 | 2577 } |
195 | 2578 #if LONGLONG_CODE |
206 | 2579 } else if(t==LONGLONG||t==ULONGLONG) { |
2580 ll = lcadr(e); | |
2581 printf("\t.long\t0x%x,0x%x\n",code_l2(ll),code_l1(ll)); | |
195 | 2582 #endif |
2583 #if FLOAT_CODE | |
89 | 2584 } else if(t==DOUBLE) { |
2585 d = dcadr(e); | |
99 | 2586 printf("\t.long\t0x%x,0x%x\n",code_d2(d),code_d1(d)); |
89 | 2587 } else if(t==FLOAT) { |
2588 f = dcadr(e); | |
2589 printf("\t.long\t0x%x\n",*(int *)&f); | |
195 | 2590 #endif |
89 | 2591 } else if(t!=CHAR) { |
245 | 2592 gpc += SIZE_OF_INT; |
89 | 2593 if(car(e)==ADDRESS&&car(cadr(e))==GVAR) { |
116 | 2594 printf("\t.long _%s\n",((NMTBL *)cadr(cadr(e)))->nm); |
89 | 2595 } else if(car(e)==FNAME) { |
116 | 2596 printf("\t.long _%s\n",((NMTBL *)cadr(e))->nm); |
109 | 2597 } else if(car(e)==GVAR) { |
116 | 2598 printf("\t.long _%s\n",((NMTBL *)cadr(e))->nm); |
89 | 2599 } else if(car(e)==STRING) { |
2600 if (car(n->ty)!=ARRAY || cadr(n->ty)!=CHAR) { | |
2601 l = fwdlabel(); | |
102 | 2602 printf("\t.long L_%d\n",l); |
108 | 2603 printf(".cstring\n\t.align 2\n"); |
102 | 2604 printf("L_%d:\n",l); |
89 | 2605 output_mode = RODATA_EMIT_MODE; |
2606 } | |
2607 ascii((char *)cadr(e)); | |
2608 } else error(TYERR); | |
168 | 2609 } else error(TYERR); |
89 | 2610 } |
2611 | |
2612 void | |
2613 emit_data_closing(NMTBL *n) | |
2614 { | |
126 | 2615 #ifdef DOT_SIZE |
89 | 2616 int lb; |
126 | 2617 #endif |
89 | 2618 if (chk) return; |
2619 if (mode==GDECL) { | |
2620 data_mode(0); | |
126 | 2621 #ifdef DOT_SIZE |
89 | 2622 lb=fwdlabel(); |
102 | 2623 printf("L_%d:\n",lb); |
2624 printf("\t.size\t%s,L_%d-%s\n",n->nm,lb,n->nm); | |
126 | 2625 #endif |
89 | 2626 } |
2627 } | |
2628 | |
2629 void | |
2630 global_table(void) | |
2631 { | |
2632 NMTBL *n; | |
98 | 2633 int init; char *extrn; |
89 | 2634 init=0; |
2635 for(n=ntable;n < &ntable[GSYMS];n++) { | |
109 | 2636 if ((n->sc == GVAR) && n->dsp != -1) { |
89 | 2637 /* n->dsp = -1 means initialized global */ |
2638 if (init==0) { | |
2639 data_mode(0); | |
2640 init=1; | |
2641 } | |
97 | 2642 printf(".comm _%s,%d\n",n->nm,size(n->ty)); |
109 | 2643 } else if ((n->sc==STATIC) && n->dsp != -1) { |
2644 /* n->dsp = -1 means initialized global */ | |
2645 if (init==0) { | |
2646 data_mode(0); | |
2647 init=1; | |
2648 } | |
2649 printf(".lcomm _%s,%d\n",n->nm,size(n->ty)); | |
97 | 2650 } |
2651 } | |
2652 for(n=ntable;n < &ntable[GSYMS];n++) { | |
103 | 2653 if (is_code(n)||is_function(n)) { |
97 | 2654 extrn = n->nm; |
103 | 2655 if (n->sc==EXTRN1) { |
2656 data_mode(0); | |
2657 printf(".picsymbol_stub\n"); | |
97 | 2658 printf("L_%s$stub:\n",extrn); |
2659 printf("\t.indirect_symbol _%s\n",extrn); | |
2660 printf("\tmflr r0\n"); | |
2661 printf("\tbcl 20,31,L0$_%s\n",extrn); | |
2662 printf("L0$_%s:\n",extrn); | |
2663 printf("\tmflr r11\n"); | |
2664 printf("\taddis r11,r11,ha16(L_%s$lazy_ptr-L0$_%s)\n",extrn,extrn); | |
2665 printf("\tmtlr r0\n"); | |
2666 printf("\tlwz r12,lo16(L_%s$lazy_ptr-L0$_%s)(r11)\n",extrn,extrn); | |
2667 printf("\tmtctr r12\n"); | |
2668 printf("\taddi r11,r11,lo16(L_%s$lazy_ptr-L0$_%s)\n",extrn,extrn); | |
2669 printf("\tbctr\n"); | |
2670 printf(".data\n"); | |
2671 printf(".lazy_symbol_pointer\n"); | |
2672 printf("L_%s$lazy_ptr:\n",extrn); | |
2673 printf("\t.indirect_symbol _%s\n",extrn); | |
2674 printf("\t.long dyld_stub_binding_helper\n"); | |
103 | 2675 } else if (n->sc==FUNCTION||n->sc==CODE) { |
2676 text_mode(); | |
2677 printf("\t.set L_%s$stub,_%s\n",extrn,extrn); | |
109 | 2678 data_mode(0); |
111 | 2679 printf("L_%s$non_lazy_ptr:\n\t.long\t_%s\n",extrn,extrn); |
108 | 2680 } |
97 | 2681 } |
2682 } | |
109 | 2683 init=0; |
2684 for(n=ntable;n < &ntable[GSYMS];n++) { | |
2685 if (n->sc == GVAR) { | |
2686 if (init==0) { | |
119 | 2687 printf(".data\n"); |
109 | 2688 init=1; |
2689 } | |
116 | 2690 printf("L_%s$non_lazy_ptr:\n\t.long\t_%s\n",n->nm,n->nm); |
109 | 2691 } |
2692 } | |
97 | 2693 init = 0; |
2694 for(n=ntable;n < &ntable[GSYMS];n++) { | |
116 | 2695 if (is_code(n)||is_function(n)) continue; |
109 | 2696 if (n->sc==EXTRN1) { |
97 | 2697 if(init==0) { |
119 | 2698 printf(".data\n"); |
97 | 2699 printf(".non_lazy_symbol_pointer\n"); |
2700 init=1; | |
2701 } | |
2702 printf("L_%s$non_lazy_ptr:\n",n->nm); | |
2703 printf("\t.indirect_symbol _%s\n",n->nm); | |
2704 printf("\t.long\t0\n"); | |
89 | 2705 } |
2706 } | |
2707 } | |
2708 | |
2709 void | |
2710 local_table(void) | |
2711 { | |
2712 NMTBL *n; | |
2713 int init; | |
2714 init=0; | |
2715 /* static local variables */ | |
2716 for(n=ntable+GSYMS;n < &ntable[GSYMS+LSYMS];n++) { | |
2717 if (n->sc == GVAR) { | |
2718 if (init==0) { | |
2719 data_mode(0); | |
2720 init=1; | |
2721 } | |
156 | 2722 if (n->dsp != -1) /* initialized static */ |
2723 printf(".lcomm _%s,%d\n",n->nm,size(n->ty)); | |
2724 printf("L_%s$non_lazy_ptr:\n\t.long\t_%s\n",n->nm,n->nm); | |
89 | 2725 } |
2726 } | |
2727 } | |
2728 | |
2729 void | |
2730 text_mode(void) | |
2731 { | |
2732 if (output_mode!=TEXT_EMIT_MODE) { | |
2733 printf(".text\n"); | |
2734 printf("\t.align 2\n"); | |
2735 output_mode = TEXT_EMIT_MODE; | |
2736 } | |
2737 } | |
2738 | |
2739 void | |
2740 data_mode(char *name) | |
2741 { | |
2742 if (output_mode!=DATA_EMIT_MODE) { | |
2743 printf(".data\n"); | |
2744 output_mode = DATA_EMIT_MODE; | |
2745 } | |
108 | 2746 /* |
89 | 2747 if (name) |
2748 printf("\t.type\t%s,@object\n",name); | |
108 | 2749 */ |
89 | 2750 } |
2751 | |
195 | 2752 #if FLOAT_CODE |
2753 | |
89 | 2754 /* floating point */ |
2755 | |
96 | 2756 static int float_one_lib_used=0; |
2757 static char *float_one_lib[] = { | |
2758 ".data", | |
108 | 2759 /* ".literal8", */ |
96 | 2760 " .align 3", |
2761 "__float_one:", | |
2762 " .long 1065353216", | |
2763 ".text", | |
109 | 2764 /* ".set L__float_one$non_lazy_ptr,__float_one", */ |
96 | 2765 0 |
2766 }; | |
97 | 2767 static int float_zero_lib_used=0; |
2768 static char *float_zero_lib[] = { | |
2769 ".data", | |
108 | 2770 /* ".literal8", */ |
97 | 2771 " .align 3", |
2772 "__float_zero:", | |
2773 " .long 0", | |
2774 ".text", | |
109 | 2775 /* ".set L__float_zero$non_lazy_ptr,__float_zero", */ |
97 | 2776 0 |
2777 }; | |
2778 | |
89 | 2779 char * |
2780 fstore(int d) | |
2781 { | |
90 | 2782 return (d?"stfd":"stfs"); |
89 | 2783 } |
2784 | |
2785 char * | |
2786 fload(int d) | |
2787 { | |
90 | 2788 return d?"lfd":"lfs"; |
89 | 2789 } |
2790 | |
95 | 2791 void |
138 | 2792 code_cmp_dregister(int e2,int d) |
95 | 2793 { |
99 | 2794 char *frn,*rrn,*grn; |
2795 int greg,r; | |
138 | 2796 grn = register_name(greg = get_dregister(d)); |
221 | 2797 use_float(d,e2); |
132 | 2798 frn = register_name(e2); |
99 | 2799 float_zero_lib_used=1; |
109 | 2800 r = get_ptr_cache(&float_zero); |
99 | 2801 rrn = register_name(r); |
108 | 2802 printf("\tlfs %s,0(%s)\n",grn,rrn); |
99 | 2803 printf("\tfcmpu cr0,%s,%s\n",grn,frn); |
147 | 2804 free_register(greg); |
99 | 2805 return; |
95 | 2806 } |
2807 | |
2808 void | |
138 | 2809 code_dregister(int e2,int freg,int d) |
95 | 2810 { |
221 | 2811 use_float(d,freg); |
147 | 2812 if (freg!=e2) { |
2813 if (is_int_reg(e2)) error(-1); | |
108 | 2814 printf("\tfmr %s,%s\n",fregister_name(freg),fregister_name(e2)); |
147 | 2815 } |
95 | 2816 } |
2817 | |
211 | 2818 void |
2819 code_dassign_gvar(int e2,int freg,int d) | |
89 | 2820 { |
90 | 2821 int r; |
221 | 2822 use_float(d,freg); |
109 | 2823 r = get_ptr_cache((NMTBL*)cadr(e2)); |
108 | 2824 printf("\t%s %s,0(%s)\n",fstore(d),fregister_name(freg),register_name(r)); |
89 | 2825 } |
2826 | |
211 | 2827 void |
2828 code_dassign_lvar(int e2,int freg,int d) | |
89 | 2829 { |
221 | 2830 use_float(d,freg); |
119 | 2831 lvar_intro(e2); |
2832 printf("\t%s %s,",fstore(d),fregister_name(freg)); | |
2833 lvar(e2); | |
89 | 2834 } |
2835 | |
211 | 2836 void |
2837 code_dassign(int e2,int freg,int d) | |
89 | 2838 { |
221 | 2839 use_float(d,freg); |
108 | 2840 printf("\t%s %s,0(%s)\n",fstore(d),fregister_name(freg),register_name(e2)); |
89 | 2841 } |
2842 | |
111 | 2843 void |
138 | 2844 code_dassign_dregister(int e2,int d,int freg) { |
221 | 2845 use_float(d,freg); |
147 | 2846 if (e2!=freg) { |
111 | 2847 printf("\tfmr %s,%s\n",fregister_name(e2),fregister_name(freg)); |
147 | 2848 } |
111 | 2849 } |
2850 | |
89 | 2851 static double d0 = 1.0; |
2852 | |
2853 int | |
2854 code_d1(double d) | |
2855 { | |
2856 int *i = (int *)&d0; int *j = (int *)&d; | |
99 | 2857 return (i[1] == 0x3ff00000)?j[0]:j[1]; |
89 | 2858 } |
2859 | |
2860 int | |
2861 code_d2(double d) | |
2862 { | |
2863 int *i = (int *)&d0; int *j = (int *)&d; | |
99 | 2864 return (i[1] == 0x3ff00000)?j[1]:j[0]; |
89 | 2865 } |
2866 | |
133 | 2867 int |
2868 code_f(double d) | |
2869 { | |
2870 float f = d; | |
2871 int *j = (int *)&f; | |
2872 return *j; | |
2873 } | |
2874 | |
211 | 2875 void |
2876 | |
138 | 2877 code_dconst(int e2,int freg,int d) |
89 | 2878 { |
2879 int lb; | |
138 | 2880 double value = dcadr(e2); |
90 | 2881 int r; |
97 | 2882 char *rrn,*frn; |
221 | 2883 |
2884 use_float(d,freg); | |
97 | 2885 frn = fregister_name(freg); |
138 | 2886 if (value==0.0) { |
97 | 2887 float_zero_lib_used=1; |
109 | 2888 r = get_ptr_cache(&float_zero); |
98 | 2889 rrn = register_name(r); |
108 | 2890 printf("\tlfs %s,0(%s)\n",frn,rrn); |
97 | 2891 return; |
89 | 2892 } |
138 | 2893 if (value==1.0) { |
97 | 2894 float_one_lib_used=1; |
109 | 2895 r = get_ptr_cache(&float_one); |
98 | 2896 rrn = register_name(r); |
108 | 2897 printf("\tlfs %s,0(%s)\n",frn,rrn); |
97 | 2898 return; |
89 | 2899 } |
97 | 2900 rrn = register_name((r=get_register())); |
230 | 2901 use_reg(r); // to clear ptr cache |
108 | 2902 printf(" \t.data\n\t.align 3\n"); |
89 | 2903 lb=fwdlabel(); |
102 | 2904 printf("L_%d:\n",lb); |
138 | 2905 if (d) { |
2906 printf("\t.long\t0x%x,0x%x\n",code_d2(value),code_d1(value)); | |
133 | 2907 } else { |
138 | 2908 printf("\t.long\t0x%x\n",code_f(value)); |
133 | 2909 } |
89 | 2910 if (output_mode==TEXT_EMIT_MODE) { |
2911 printf(".text\n"); | |
2912 } else { | |
2913 text_mode(); | |
2914 } | |
102 | 2915 printf("\taddis %s,r31,ha16(L_%d-L_%d)\n",rrn,lb,code_base); |
2916 printf("\tla %s,lo16(L_%d-L_%d)(%s)\n",rrn,lb,code_base,rrn); | |
138 | 2917 if (d) { |
133 | 2918 printf("\tlfd %s,0(%s)\n",frn,rrn); |
2919 } else { | |
2920 printf("\tlfs %s,0(%s)\n",frn,rrn); | |
2921 } | |
90 | 2922 free_register(r); |
89 | 2923 } |
2924 | |
133 | 2925 |
211 | 2926 void |
2927 code_dneg(int freg,int d) | |
89 | 2928 { |
221 | 2929 char *frn; |
2930 use_float(d,freg); | |
2931 frn = fregister_name(freg); | |
95 | 2932 printf("\tfneg %s,%s\n",frn,frn); |
89 | 2933 } |
2934 | |
211 | 2935 void |
221 | 2936 code_d2i() |
89 | 2937 { |
147 | 2938 char *frn; |
2939 char *crn; | |
245 | 2940 int e2 = new_lvar(SIZE_OF_DOUBLE); |
147 | 2941 |
221 | 2942 use_double0(); |
2943 frn = fregister_name(freg); | |
2944 use_int0(); | |
147 | 2945 crn = register_name(creg); |
2946 | |
119 | 2947 free_lvar(e2); |
93 | 2948 printf("\tfctiwz %s,%s\n",frn,frn); |
119 | 2949 lvar_intro(e2); |
2950 printf("\tstfd %s,",frn); lvar(e2); | |
245 | 2951 lvar_intro(e2+SIZE_OF_DOUBLE-SIZE_OF_INT); |
2952 printf("\tlwz %s,",crn); lvar(e2+SIZE_OF_DOUBLE-SIZE_OF_INT); | |
89 | 2953 } |
2954 | |
91 | 2955 static int i2d_lib_used=0; |
2956 static char *i2d_lib[] = { | |
2957 ".data", | |
108 | 2958 /* ".literal8", */ |
91 | 2959 " .align 3", |
2960 "__i2dLC0:", | |
2961 " .long 1127219200", | |
2962 " .long -2147483648", | |
2963 ".text", | |
2964 " .align 2", | |
111 | 2965 "i2d_:", |
91 | 2966 " mflr r0", |
2967 " bcl 20,31,__i2dL1$pb", | |
2968 "__i2dL1$pb:", | |
2969 " mflr r10", | |
2970 " mtlr r0", | |
2971 " xoris r3,r3,0x8000", | |
116 | 2972 " stw r3,-28(r30)", |
91 | 2973 " lis r0,0x4330", |
116 | 2974 " stw r0,-32(r30)", |
2975 " lfd f0,-32(r30)", | |
91 | 2976 " addis r9,r10,ha16(__i2dLC0-__i2dL1$pb)", |
2977 " lfd f1,lo16(__i2dLC0-__i2dL1$pb)(r9)", | |
2978 " fsub f1,f0,f1", | |
2979 " blr", | |
2980 0 | |
2981 }; | |
2982 | |
211 | 2983 void |
221 | 2984 code_i2d() |
89 | 2985 { |
95 | 2986 i2d_lib_used = 1; |
113 | 2987 clear_ptr_cache(); |
2988 code_save_stacks(); | |
207 | 2989 set_ireg(RET_REGISTER,1); |
91 | 2990 printf("\tbl i2d_\n"); |
104 | 2991 set_freg(RET_FREGISTER,0); |
89 | 2992 } |
2993 | |
91 | 2994 static int d2u_lib_used=0; |
2995 static char *d2u_lib[] = { | |
108 | 2996 /* ".literal8", */ |
91 | 2997 " .align 3", |
2998 "__d2uLC0:", | |
2999 " .long 1105199104", | |
3000 " .long 0", | |
3001 ".text", | |
3002 " .align 2", | |
111 | 3003 "d2u_:", |
91 | 3004 " mflr r0", |
3005 " bcl 20,31,__d2uL1$pb", | |
3006 "__d2uL1$pb:", | |
3007 " mflr r10", | |
3008 " mtlr r0", | |
3009 " addis r9,r10,ha16(__d2uLC0-__d2uL1$pb)", | |
3010 " lfd f0,lo16(__d2uLC0-__d2uL1$pb)(r9)", | |
3011 " fcmpu cr0,f1,f0", | |
3012 " cror 2,1,2", | |
3013 " beq- cr0,__d2uL2", | |
3014 " fctiwz f0,f1", | |
116 | 3015 " stfd f0,-32(r30)", |
3016 " lwz r3,-28(r30)", | |
91 | 3017 " blr", |
3018 "__d2uL2:", | |
3019 " addis r9,r10,ha16(__d2uLC0-__d2uL1$pb)", | |
3020 " lfd f0,lo16(__d2uLC0-__d2uL1$pb)(r9)", | |
3021 " fsub f0,f1,f0", | |
3022 " fctiwz f0,f0", | |
116 | 3023 " stfd f0,-24(r30)", |
3024 " lwz r3,-20(r30)", | |
91 | 3025 " xoris r3,r3,0x8000", |
3026 " blr", | |
3027 0 | |
3028 }; | |
3029 | |
211 | 3030 void |
221 | 3031 code_d2u() |
89 | 3032 { |
113 | 3033 code_save_stacks(); |
3034 clear_ptr_cache(); | |
91 | 3035 d2u_lib_used=1; |
104 | 3036 set_freg(RET_FREGISTER,1); |
111 | 3037 printf("\tbl d2u_\n"); |
207 | 3038 set_ireg(RET_REGISTER,0); |
91 | 3039 } |
90 | 3040 |
91 | 3041 static int u2d_lib_used=0; |
3042 static char *u2d_lib[] = { | |
3043 ".data", | |
108 | 3044 /* ".literal8", */ |
91 | 3045 " .align 3", |
3046 "__u2dLC1:", | |
3047 " .long 1127219200", | |
3048 " .long 0", | |
3049 ".text", | |
3050 " .align 2", | |
111 | 3051 "u2d_:", |
91 | 3052 " mflr r0", |
3053 " bcl 20,31,__u2dL2$pb", | |
3054 "__u2dL2$pb:", | |
3055 " mflr r10", | |
3056 " mtlr r0", | |
116 | 3057 " stw r3,-28(r30)", |
91 | 3058 " lis r0,0x4330", |
116 | 3059 " stw r0,-32(r30)", |
3060 " lfd f0,-32(r30)", | |
91 | 3061 " addis r9,r10,ha16(__u2dLC1-__u2dL2$pb)", |
3062 " lfd f1,lo16(__u2dLC1-__u2dL2$pb)(r9)", | |
3063 " fsub f1,f0,f1", | |
3064 " blr", | |
3065 0 | |
3066 }; | |
89 | 3067 |
211 | 3068 void |
221 | 3069 code_u2d() |
89 | 3070 { |
113 | 3071 code_save_stacks(); |
3072 clear_ptr_cache(); | |
147 | 3073 u2d_lib_used = 1; |
207 | 3074 set_ireg(RET_REGISTER,1); |
111 | 3075 printf("\tbl u2d_\n"); |
228 | 3076 set_freg(RET_FREGISTER,0); |
89 | 3077 } |
3078 | |
211 | 3079 void |
221 | 3080 code_d2f() { } |
211 | 3081 void |
221 | 3082 code_f2d() { } |
211 | 3083 void |
221 | 3084 code_f2i() { code_d2i(); } |
211 | 3085 void |
221 | 3086 code_f2u() { code_d2u(); } |
211 | 3087 void |
221 | 3088 code_i2f() { code_i2d(); } |
211 | 3089 void |
221 | 3090 code_u2f() { code_u2d(); } |
211 | 3091 |
3092 void | |
3093 code_drgvar(int e2,int d,int freg) | |
89 | 3094 { |
91 | 3095 int r; |
109 | 3096 r = get_ptr_cache((NMTBL*)cadr(e2)); |
221 | 3097 use_float(d,freg); |
108 | 3098 printf("\t%s %s,0(%s)\n",fload(d),fregister_name(freg),register_name(r)); |
89 | 3099 } |
3100 | |
3101 | |
211 | 3102 void |
3103 code_drlvar(int e2,int d,int freg) | |
89 | 3104 { |
221 | 3105 use_float(d,freg); |
119 | 3106 lvar_intro(e2); |
3107 printf("\t%s %s,",fload(d),fregister_name(freg)); lvar(e2); | |
89 | 3108 } |
3109 | |
211 | 3110 void |
221 | 3111 code_cmp_drgvar(int e2,int reg,int d) |
89 | 3112 { |
91 | 3113 int r; |
221 | 3114 char *frn; |
138 | 3115 int g=get_dregister(d); |
97 | 3116 char *grn=fregister_name(g); |
221 | 3117 |
3118 use_float(d,reg); | |
3119 frn=fregister_name(reg); | |
3120 | |
109 | 3121 r = get_ptr_cache((NMTBL*)cadr(e2)); |
108 | 3122 printf("\t%s %s,0(%s)\n",fload(1),grn,register_name(r)); |
91 | 3123 printf("\tfcmpu cr0,%s,%s\n",frn,grn); |
147 | 3124 free_register(g); |
89 | 3125 } |
3126 | |
211 | 3127 void |
221 | 3128 code_cmp_drlvar(int e2,int reg,int d) |
89 | 3129 { |
221 | 3130 char *frn; |
138 | 3131 int g=get_dregister(d); |
97 | 3132 char *grn=fregister_name(g); |
108 | 3133 |
221 | 3134 use_float(d,reg); |
3135 frn=fregister_name(reg); | |
3136 | |
119 | 3137 lvar_intro(e2); |
3138 printf("\t%s %s,",fload(1),grn); lvar(e2); | |
91 | 3139 printf("\tfcmpu cr0,%s,%s\n",frn,grn); |
147 | 3140 free_register(g); |
89 | 3141 } |
3142 | |
211 | 3143 void |
221 | 3144 dtosop(int op,int reg,int e1) |
89 | 3145 { |
127 | 3146 char *opn=""; |
221 | 3147 char *frn; |
97 | 3148 char *grn=fregister_name(e1); |
221 | 3149 |
3150 use_float(1,reg); | |
3151 frn=fregister_name(reg); | |
89 | 3152 switch(op) { |
133 | 3153 case FADD: |
91 | 3154 case DADD: opn="fadd"; break; |
133 | 3155 case FSUB: |
101 | 3156 case DSUB: opn="fsub"; break; |
133 | 3157 case FDIV: |
101 | 3158 case DDIV: opn="fdiv"; break; |
133 | 3159 case FMUL: |
101 | 3160 case DMUL: opn="fmul"; break; |
133 | 3161 case FCMP: |
91 | 3162 case DCMP: |
234 | 3163 printf("\tfcmpu cr7,%s,%s\n",frn,grn); |
147 | 3164 free_register(e1); |
101 | 3165 return; |
133 | 3166 case FCMPGE: |
91 | 3167 case DCMPGE: |
108 | 3168 printf("\tfcmpu cr7,%s,%s\n",frn,grn); |
147 | 3169 free_register(e1); |
101 | 3170 return; |
133 | 3171 default: |
3172 error(-1); return; | |
89 | 3173 } |
91 | 3174 printf("\t%s %s,%s,%s\n",opn,frn,frn,grn); |
89 | 3175 } |
3176 | |
3177 void | |
221 | 3178 code_dassop(int op,int reg,int d) { |
91 | 3179 /* we have lvalue in creg, applied floating value is in freg */ |
221 | 3180 // (*creg) op = pop() |
138 | 3181 int xreg=emit_dpop(d); |
221 | 3182 char *crn; |
209 | 3183 char *frn; |
221 | 3184 |
3185 crn=register_name(ireg); | |
3186 use_float(d,reg); | |
3187 frn =fregister_name(reg); | |
209 | 3188 |
108 | 3189 printf("\t%s %s,0(%s)\n",fload(d),frn,crn); |
221 | 3190 dtosop(op,reg,xreg); |
108 | 3191 printf("\t%s %s,0(%s)\n",fstore(d),frn,crn); |
138 | 3192 emit_dpop_free(xreg,d); |
89 | 3193 } |
3194 | |
219 | 3195 void |
3196 code_register_dassop(int reg,int op,int d) { | |
221 | 3197 // reg op= dpop() |
219 | 3198 int xreg=emit_dpop(d); |
221 | 3199 dtosop(op,reg,xreg); |
3200 emit_dpop_free(xreg,d); | |
219 | 3201 } |
91 | 3202 |
89 | 3203 void |
107 | 3204 code_dpreinc(int e1,int e2,int d,int reg) { |
91 | 3205 char *frn; |
3206 char *crn; | |
3207 int g; | |
3208 char *grn,*drn; | |
3209 int r; | |
3210 | |
144 | 3211 if (car(e2)==DREGISTER||car(e2)==FREGISTER) { |
221 | 3212 crn=register_name(cadr(e2)); |
3213 } else { | |
3214 g_expr(e2); | |
3215 if (!is_int_reg(creg)) error(-1); | |
3216 crn=register_name(ireg); | |
144 | 3217 } |
91 | 3218 |
209 | 3219 float_one_lib_used=1; |
3220 r = get_ptr_cache(&float_one); | |
3221 drn=register_name(r); | |
3222 | |
221 | 3223 use_float(d,reg); |
3224 | |
3225 frn=fregister_name(reg); | |
138 | 3226 grn=fregister_name(g=get_dregister(d)); |
108 | 3227 printf("\tlfs %s,0(%s)\n",grn,drn); |
221 | 3228 |
3229 if (car(e2)==DREGISTER||car(e2)==FREGISTER) { | |
3230 printf("\tfmr %s,%s\n",crn,frn); | |
3231 printf("\t%s %s,%s,%s\n",(caddr(e1)>0)?"fadd":"fsub",crn,frn,grn); | |
3232 } else { | |
3233 printf("\t%s %s,0(%s)\n",fload(d),frn,crn); | |
3234 printf("\t%s %s,%s,%s\n",(caddr(e1)>0)?"fadd":"fsub",frn,frn,grn); | |
3235 printf("\t%s %s,0(%s)\n",fstore(d),frn,crn); | |
3236 } | |
147 | 3237 free_register(g); |
89 | 3238 } |
3239 | |
3240 void | |
107 | 3241 code_dpostinc(int e1,int e2,int d,int reg) { |
91 | 3242 char *frn; |
3243 char *crn; | |
3244 int g; | |
3245 char *grn,*drn; | |
3246 int r; | |
3247 | |
144 | 3248 if (car(e2)==DREGISTER||car(e2)==FREGISTER) { |
221 | 3249 crn=register_name(cadr(e2)); |
3250 } else { | |
3251 g_expr(e2); | |
3252 if (!is_int_reg(creg)) error(-1); | |
3253 crn=register_name(creg); | |
144 | 3254 } |
209 | 3255 |
3256 float_one_lib_used=1; | |
3257 r = get_ptr_cache(&float_one); | |
3258 drn=register_name(r); | |
3259 | |
221 | 3260 use_float(d,reg); |
3261 | |
3262 frn=fregister_name(reg); | |
138 | 3263 grn=fregister_name(g=get_dregister(d)); |
108 | 3264 printf("\tlfs %s,0(%s)\n",grn,drn); |
221 | 3265 |
3266 if (car(e2)==DREGISTER||car(e2)==FREGISTER) { | |
3267 printf("\t%s %s,%s,%s\n",(caddr(e1)>0)?"fadd":"fsub",frn,crn,grn); | |
3268 printf("\tfmr %s,%s\n",frn,crn); | |
3269 } else { | |
3270 printf("\t%s %s,0(%s)\n",fload(d),frn,crn); | |
3271 printf("\t%s %s,%s,%s\n",(caddr(e1)>0)?"fadd":"fsub",grn,frn,grn); | |
3272 printf("\t%s %s,0(%s)\n",fstore(d),grn,crn); | |
3273 } | |
147 | 3274 free_register(g); |
89 | 3275 } |
3276 | |
3277 void | |
229 | 3278 drexpr(int e1, int e2,int l1, int op,int cond) |
3279 { | |
231 | 3280 if (!cond) { |
229 | 3281 switch(op) { |
3282 case FOP+GT: | |
232 | 3283 drexpr(e2,e1,l1,FOP+GE,1); return; |
229 | 3284 case FOP+GE: |
232 | 3285 drexpr(e2,e1,l1,FOP+GT,1); return; |
229 | 3286 case FOP+EQ: |
3287 op=FOP+NEQ; break; | |
3288 case FOP+NEQ: | |
3289 op=FOP+EQ; break; | |
3290 case DOP+GT: | |
232 | 3291 drexpr(e2,e1,l1,DOP+GE,1); return; |
229 | 3292 case DOP+GE: |
232 | 3293 drexpr(e2,e1,l1,DOP+GT,1); return; |
229 | 3294 case DOP+EQ: |
3295 op=DOP+NEQ; break; | |
3296 case DOP+NEQ: | |
3297 op=DOP+EQ; break; | |
3298 } | |
3299 } | |
234 | 3300 // g_expr(list3( ((op==DOP+GE||op==FOP+GE)?DCMPGE:DCMP), e2,e1)); |
3301 g_expr(list3(DCMP, e1,e2)); | |
89 | 3302 switch(op) { |
229 | 3303 case DOP+GT: |
3304 case FOP+GT: | |
234 | 3305 printf("\tbgt\tcr7,L_%d\n",l1); |
229 | 3306 break; |
89 | 3307 case DOP+GE: |
133 | 3308 case FOP+GE: |
234 | 3309 // printf("\tcrnor 30,29,30\n"); |
3310 // printf("\tbeq\tcr7,L_%d\n",l1); | |
3311 printf("\tbge\tcr7,L_%d\n",l1); | |
89 | 3312 break; |
3313 case DOP+EQ: | |
133 | 3314 case FOP+EQ: |
234 | 3315 printf("\tbeq\tcr7,L_%d\n",l1); |
89 | 3316 break; |
3317 case DOP+NEQ: | |
133 | 3318 case FOP+NEQ: |
234 | 3319 printf("\tbne\tcr7,L_%d\n",l1); |
89 | 3320 break; |
3321 } | |
3322 } | |
3323 | |
138 | 3324 int emit_dpop(int d) |
89 | 3325 { |
114 | 3326 int xreg,reg; |
97 | 3327 xreg=pop_fregister(); |
3328 if (xreg<= -REG_LVAR_OFFSET) { | |
138 | 3329 reg = get_dregister(d); |
119 | 3330 code_drlvar(REG_LVAR_OFFSET+xreg,1,reg); |
117 | 3331 free_lvar(REG_LVAR_OFFSET+xreg); |
205 | 3332 xreg=reg; |
96 | 3333 } |
3334 return xreg; | |
89 | 3335 } |
3336 | |
211 | 3337 void |
3338 emit_dpop_free(int e1,int d) | |
89 | 3339 { |
147 | 3340 free_register(e1); |
89 | 3341 } |
3342 | |
211 | 3343 void |
3344 emit_dpush(int d) | |
89 | 3345 { |
97 | 3346 int new_reg; |
221 | 3347 if (!is_float_reg(creg)) error(-1); |
102 | 3348 if (freg_sp>MAX_MAX) error(-1); |
221 | 3349 new_reg = get_dregister(1); /* ���Ф˼��� */ |
97 | 3350 freg_stack[freg_sp++] = freg; /* push ���뤫���˥쥸������Ȥ� */ |
147 | 3351 creg = freg = new_reg; |
89 | 3352 } |
3353 | |
195 | 3354 #endif |
3355 | |
3356 #if LONGLONG_CODE | |
3357 | |
3358 | |
3359 /* 64bit int part */ | |
219 | 3360 static void |
3361 lmove(int to,int from) | |
3362 { | |
227 | 3363 int tmp; |
3364 if (regv_h(to)==regv_l(from)&&(regv_l(to)==regv_h(from))) { | |
3365 tmp = get_register(); | |
228 | 3366 printf("\tmr %s,%s\n",register_name(tmp),lregister_name_low(from)); |
227 | 3367 printf("\tmr %s,%s\n",lregister_name_high(to),lregister_name_high(from)); |
3368 printf("\tmr %s,%s\n",lregister_name_low(to),register_name(tmp)); | |
3369 free_register(tmp); | |
3370 } else if (regv_h(to)==regv_l(from)) { | |
226 | 3371 printf("\tmr %s,%s\n",lregister_name_low(to),lregister_name_low(from)); |
3372 printf("\tmr %s,%s\n",lregister_name_high(to),lregister_name_high(from)); | |
3373 } else { | |
3374 printf("\tmr %s,%s\n",lregister_name_high(to),lregister_name_high(from)); | |
3375 printf("\tmr %s,%s\n",lregister_name_low(to),lregister_name_low(from)); | |
3376 } | |
219 | 3377 } |
195 | 3378 |
211 | 3379 static void |
229 | 3380 pcond(char *s,int l1) |
210 | 3381 { |
3382 printf("\tb%s cr0,L_%d\n",s,l1); | |
3383 } | |
3384 | |
3385 void | |
229 | 3386 lrexpr(int e1, int e2,int l1, int op,int cond) |
195 | 3387 { |
221 | 3388 int reg; |
210 | 3389 int e3; |
3390 g_expr(e1); | |
3391 emit_lpush(); | |
3392 g_expr(e2); | |
3393 e3 = emit_lpop(); | |
221 | 3394 if (!is_longlong_reg(creg)) error(-1); |
3395 reg = lreg; | |
3396 | |
3397 tosop(CMP,regv_h(reg),regv_h(e3)); | |
210 | 3398 switch(op) { |
3399 case LOP+GT: | |
229 | 3400 pcond(code_gt(cond),l1); break; |
210 | 3401 case LOP+GE: |
229 | 3402 pcond(code_ge(cond),l1); break; |
210 | 3403 case LOP+EQ: |
229 | 3404 pcond(code_eq(cond),l1); break; |
210 | 3405 case LOP+NEQ: |
229 | 3406 pcond(code_eq(!cond),l1); break; |
210 | 3407 case LOP+LT: |
229 | 3408 pcond(code_ge(!cond),l1); break; |
210 | 3409 case LOP+LE: |
229 | 3410 pcond(code_gt(!cond),l1); break; |
210 | 3411 case LOP+UGT: |
231 | 3412 pcond(code_ugt(cond),l1); break; |
210 | 3413 case LOP+UGE: |
231 | 3414 pcond(code_uge(cond),l1); break; |
210 | 3415 default: |
3416 error(-1); | |
3417 } | |
221 | 3418 tosop(CMP,regv_l(reg),regv_l(e3)); |
210 | 3419 switch(op) { |
3420 case LOP+GT: | |
229 | 3421 pcond(code_gt(cond),l1); break; |
210 | 3422 case LOP+GE: |
229 | 3423 pcond(code_ge(cond),l1); break; |
210 | 3424 case LOP+EQ: |
229 | 3425 pcond(code_eq(cond),l1); break; |
210 | 3426 case LOP+NEQ: |
229 | 3427 pcond(code_eq(!cond),l1); break; |
210 | 3428 case LOP+LT: |
229 | 3429 pcond(code_ge(!cond),l1); break; |
210 | 3430 case LOP+LE: |
229 | 3431 pcond(code_gt(!cond),l1); break; |
210 | 3432 case LOP+UGT: |
231 | 3433 pcond(code_ugt(cond),l1); break; |
210 | 3434 case LOP+UGE: |
231 | 3435 pcond(code_uge(cond),l1); break; |
210 | 3436 default: |
3437 error(-1); | |
3438 } | |
3439 emit_lpop_free(e3); | |
195 | 3440 } |
3441 | |
211 | 3442 int |
3443 emit_lpop() | |
195 | 3444 { |
210 | 3445 int xreg,reg; |
237 | 3446 xreg=lreg_stack[--lreg_sp]; |
210 | 3447 if (xreg<= -REG_LVAR_OFFSET) { |
3448 reg = get_lregister(); | |
3449 code_lrlvar(REG_LVAR_OFFSET+xreg,reg); | |
3450 free_lvar(REG_LVAR_OFFSET+xreg); | |
3451 xreg = reg; | |
3452 } | |
3453 return xreg; | |
195 | 3454 } |
3455 | |
211 | 3456 void |
3457 code_lregister(int e2,int reg) | |
195 | 3458 { |
221 | 3459 use_longlong(reg); |
3460 if (reg!=e2) { | |
3461 lmove(reg,e2); | |
211 | 3462 } |
195 | 3463 } |
3464 | |
211 | 3465 void |
3466 code_cmp_lregister(int reg) | |
195 | 3467 { |
221 | 3468 use_longlong(reg); |
211 | 3469 printf("\tor %s,%s,%s\n", |
3470 lregister_name_low(reg), | |
3471 lregister_name_low(reg), | |
3472 lregister_name_high(reg)); | |
3473 printf("\tcmpwi cr0,%s,0\n",lregister_name_low(reg)); | |
195 | 3474 } |
3475 | |
211 | 3476 void |
3477 code_cmp_lrgvar(int e1,int creg) | |
195 | 3478 { |
221 | 3479 use_longlong(creg); |
211 | 3480 code_lrgvar(e1,creg); |
3481 code_cmp_lregister(creg); | |
3482 } | |
3483 | |
3484 void | |
3485 code_cmp_lrlvar(int e1,int creg) | |
3486 { | |
221 | 3487 use_longlong(creg); |
211 | 3488 code_lrlvar(e1,creg); |
3489 code_cmp_lregister(creg); | |
195 | 3490 } |
3491 | |
211 | 3492 void |
3493 code_lassign(int e2,int creg) | |
195 | 3494 { |
211 | 3495 char *drn = register_name(e2); |
221 | 3496 char *crn_h; |
3497 char *crn_l; | |
3498 | |
3499 use_longlong(creg); | |
3500 crn_h = lregister_name_high(creg); | |
3501 crn_l = lregister_name_low(creg); | |
211 | 3502 |
226 | 3503 if (e2==regv_h(creg)) { |
245 | 3504 printf("\tstw %s,%d(%s)\n",crn_l,SIZE_OF_INT,drn); |
226 | 3505 printf("\tstw %s,0(%s)\n",crn_h,drn); |
3506 } else { | |
3507 printf("\tstw %s,0(%s)\n",crn_h,drn); | |
245 | 3508 printf("\tstw %s,%d(%s)\n",crn_l,SIZE_OF_INT,drn); |
226 | 3509 } |
195 | 3510 } |
3511 | |
211 | 3512 void |
3513 code_lassign_gvar(int e2,int creg) | |
195 | 3514 { |
211 | 3515 int r; |
3516 r = get_ptr_cache((NMTBL*)cadr(e2)); | |
3517 code_lassign(r,creg); | |
195 | 3518 } |
3519 | |
211 | 3520 void |
3521 code_lassign_lvar(int e2,int creg) | |
195 | 3522 { |
221 | 3523 char *crn_h; |
3524 char *crn_l; | |
3525 | |
3526 use_longlong(creg); | |
3527 crn_h = lregister_name_high(creg); | |
3528 crn_l = lregister_name_low(creg); | |
211 | 3529 lvar_intro(e2); |
3530 printf("\tstw %s,",crn_h);lvar(e2); | |
245 | 3531 printf("\tstw %s,",crn_l);lvar(e2+SIZE_OF_INT); |
195 | 3532 } |
3533 | |
211 | 3534 void |
3535 code_lassign_lregister(int e2,int reg) | |
195 | 3536 { |
221 | 3537 use_longlong(reg); |
219 | 3538 if (e2!=reg) { |
3539 lmove(e2,reg); | |
211 | 3540 } |
195 | 3541 } |
3542 | |
207 | 3543 static long long ll0 = 1LL; |
206 | 3544 |
3545 static int | |
3546 code_l1(long long d) | |
3547 { | |
207 | 3548 int *i = (int *)&ll0; int *j = (int *)&d; |
206 | 3549 return (i[1] == 1)?j[1]:j[0]; |
3550 } | |
3551 | |
3552 static int | |
3553 code_l2(long long d) | |
3554 { | |
207 | 3555 int *i = (int *)&ll0; int *j = (int *)&d; |
206 | 3556 return (i[1] == 1)?j[0]:j[1]; |
3557 } | |
3558 | |
211 | 3559 void |
3560 code_lconst(int e1,int creg) | |
3561 { | |
221 | 3562 use_longlong(creg); |
211 | 3563 code_const(code_l1(lcadr(e1)),regv_l(creg)); |
3564 code_const(code_l2(lcadr(e1)),regv_h(creg)); | |
3565 } | |
3566 | |
3567 void | |
3568 code_lneg(int creg) | |
195 | 3569 { |
221 | 3570 use_longlong(creg); |
211 | 3571 printf("\tsubfic %s,%s,0\n", |
3572 lregister_name_low(creg),lregister_name_low(creg)); | |
221 | 3573 printf("\tsubfze %s,%s\n", |
211 | 3574 lregister_name_high(creg),lregister_name_high(creg)); |
195 | 3575 } |
3576 | |
211 | 3577 void |
221 | 3578 code_lrgvar(int e1,int creg) |
211 | 3579 { |
3580 int r; | |
221 | 3581 char *crn_h; |
3582 char *crn_l; | |
3583 use_longlong(creg); | |
3584 crn_h = lregister_name_high(creg); | |
3585 crn_l = lregister_name_low(creg); | |
211 | 3586 r = get_ptr_cache((NMTBL*)cadr(e1)); |
3587 printf("\tlwz %s,0(%s)\n",crn_h,register_name(r)); | |
245 | 3588 printf("\tlwz %s,%d(%s)\n",crn_l,SIZE_OF_INT,register_name(r)); |
211 | 3589 } |
3590 | |
3591 void | |
3592 code_lrlvar(int e1,int creg) | |
195 | 3593 { |
221 | 3594 char *crn_h; |
3595 char *crn_l; | |
3596 use_longlong(creg); | |
3597 crn_h = lregister_name_high(creg); | |
3598 crn_l = lregister_name_low(creg); | |
211 | 3599 lvar_intro(e1); |
3600 printf("\tlwz %s,",crn_h); lvar(e1); | |
245 | 3601 printf("\tlwz %s,",crn_l); lvar(e1+SIZE_OF_INT); |
195 | 3602 } |
3603 | |
221 | 3604 #if 0 |
216 | 3605 static int lumod_lib_used=0; |
217 | 3606 static char *lumod_lib[] = { |
216 | 3607 }; |
3608 | |
3609 static int lmod_lib_used=0; | |
217 | 3610 static char *lmod_lib[] = { |
216 | 3611 }; |
3612 | |
3613 static int ludiv_lib_used=0; | |
217 | 3614 static char *ludiv_lib[] = { |
216 | 3615 }; |
3616 | |
3617 static int ldiv_lib_used=0; | |
217 | 3618 static char *ldiv_lib[] = { |
216 | 3619 }; |
221 | 3620 #endif |
216 | 3621 |
3622 static int lsrd_lib_used=0; | |
217 | 3623 static char *lsrd_lib[] = { |
3624 ".text", | |
3625 " .align 2", | |
3626 "lsrd__:", | |
3627 " mr. r5,r5", | |
3628 " beqlr", | |
3629 " subfic r2,r5,32", | |
3630 " stw r3,-32(r1)", | |
3631 " stw r4,-28(r1)", | |
3632 " cmpwi cr7,r2,0", | |
3633 " bgt+ cr7,L__lsrd1", | |
3634 " neg r0,r2", | |
3635 " lwz r2,-32(r1)", | |
3636 " li r9,0", | |
3637 " srw r2,r2,r0", | |
3638 " stw r9,-48(r1)", | |
3639 " b L__lsrd2", | |
3640 "L__lsrd1: lwz r0,-32(r1)", | |
3641 " slw r9,r0,r2", | |
3642 " lwz r2,-28(r1)", | |
3643 " srw r0,r0,r5", | |
3644 " srw r2,r2,r5", | |
3645 " stw r0,-48(r1)", | |
3646 " or r2,r2,r9", | |
3647 "L__lsrd2: stw r2,-44(r1)", | |
3648 " lwz r3,-48(r1)", | |
3649 " lwz r4,-44(r1)", | |
3650 " blr", | |
219 | 3651 0 |
217 | 3652 }; |
3653 | |
3654 static int asld_lib_used=0; | |
3655 static char *asld_lib[] = { | |
3656 ".text", | |
3657 " .align 2", | |
3658 "asld__:", | |
3659 " mr. r5,r5", | |
3660 " beqlr", | |
3661 " subfic r2,r5,32", | |
3662 " stw r3,-32(r1)", | |
3663 " stw r4,-28(r1)", | |
3664 " cmpwi cr7,r2,0", | |
3665 " bgt+ cr7,L__asld1", | |
3666 " neg r0,r2", | |
3667 " lwz r2,-28(r1)", | |
3668 " li r9,0", | |
3669 " slw r2,r2,r0", | |
3670 " stw r9,-44(r1)", | |
3671 " b L__asld2", | |
3672 "L__asld1: lwz r0,-28(r1)", | |
3673 " srw r9,r0,r2", | |
3674 " lwz r2,-32(r1)", | |
3675 " slw r0,r0,r5", | |
3676 " slw r2,r2,r5", | |
3677 " stw r0,-44(r1)", | |
3678 " or r2,r2,r9", | |
3679 "L__asld2: stw r2,-48(r1)", | |
3680 " lwz r3,-48(r1)", | |
3681 " lwz r4,-44(r1)", | |
3682 " blr", | |
219 | 3683 0 |
216 | 3684 }; |
3685 | |
3686 static int asrd_lib_used=0; | |
217 | 3687 static char *asrd_lib[] = { |
3688 ".text", | |
3689 " .align 2", | |
3690 "asrd__:", | |
3691 " mr. r5,r5", | |
3692 " beqlr", | |
3693 " subfic r2,r5,32", | |
3694 " stw r3,-32(r1)", | |
3695 " stw r4,-28(r1)", | |
3696 " cmpwi cr7,r2,0", | |
3697 " bgt+ cr7,L__asrd1", | |
3698 " lwz r0,-32(r1)", | |
3699 " neg r2,r2", | |
3700 " sraw r2,r0,r2", | |
3701 " srawi r0,r0,31", | |
3702 " b L__asrd2", | |
3703 "L__asrd1: lwz r0,-32(r1)", | |
3704 " slw r9,r0,r2", | |
3705 " lwz r2,-28(r1)", | |
3706 " sraw r0,r0,r5", | |
3707 " srw r2,r2,r5", | |
3708 " or r2,r2,r9", | |
3709 "L__asrd2: stw r0,-48(r1)", | |
3710 " stw r2,-44(r1)", | |
3711 " lwz r3,-48(r1)", | |
3712 " lwz r4,-44(r1)", | |
3713 " blr", | |
219 | 3714 0 |
216 | 3715 }; |
3716 | |
217 | 3717 static void |
3718 extern_conv(char *conv) | |
3719 { | |
3720 code_save_stacks(); | |
3721 clear_ptr_cache(); | |
3722 extern_define(conv,0,FUNCTION,1); | |
3723 printf("\tbl L_%s$stub\n",conv); | |
3724 } | |
3725 | |
216 | 3726 #if FLOAT_CODE |
218 | 3727 #if 0 |
217 | 3728 static int d2ll_lib_used=0; |
3729 static char *d2ll_lib[] = { | |
216 | 3730 }; |
3731 | |
3732 static int d2ull_lib_used=0; | |
217 | 3733 static char *d2ull_lib[] = { |
216 | 3734 }; |
3735 | |
3736 static int f2ll_lib_used=0; | |
217 | 3737 static char *f2ll_lib[] = { |
216 | 3738 }; |
3739 | |
3740 static int f2ull_lib_used=0; | |
217 | 3741 static char *f2ull_lib[] = { |
216 | 3742 }; |
3743 | |
3744 static int ll2d_lib_used=0; | |
217 | 3745 static char *ll2d_lib[] = { |
216 | 3746 }; |
3747 | |
3748 static int ll2f_lib_used=0; | |
217 | 3749 static char *ll2f_lib[] = { |
216 | 3750 }; |
218 | 3751 #endif |
216 | 3752 |
3753 #endif | |
3754 | |
3755 static void | |
255 | 3756 code_asld_lib(int reg,int oreg) |
211 | 3757 { |
3758 code_save_stacks(); | |
3759 clear_ptr_cache(); | |
3760 asld_lib_used = 1; | |
255 | 3761 set_lreg_operand(reg,1); |
3762 set_lreg(RET_LREGISTER,0); | |
228 | 3763 if (regv_l(oreg)!=5) { |
3764 printf("\tmr r5,%s\n", lregister_name_low(oreg)); | |
3765 } | |
221 | 3766 printf("\tbl asld__\n"); |
195 | 3767 } |
3768 | |
216 | 3769 static void |
255 | 3770 code_asrd_lib(int reg,int oreg) // ___ashrdi3$stub |
216 | 3771 { |
3772 code_save_stacks(); | |
3773 clear_ptr_cache(); | |
3774 asrd_lib_used = 1; | |
255 | 3775 set_lreg_operand(reg,1); |
3776 set_lreg(RET_LREGISTER,0); | |
228 | 3777 if (regv_l(oreg)!=5) { |
3778 printf("\tmr r5,%s\n", lregister_name_low(oreg)); | |
3779 } | |
221 | 3780 printf("\tbl asrd__\n"); |
216 | 3781 } |
3782 | |
3783 static void | |
255 | 3784 code_lsrd_lib(int reg,int oreg) // ___lshrdi3$stub |
216 | 3785 { |
3786 code_save_stacks(); | |
3787 clear_ptr_cache(); | |
3788 lsrd_lib_used = 1; | |
255 | 3789 set_lreg_operand(reg,1); |
3790 set_lreg(RET_LREGISTER,0); | |
231 | 3791 if (regv_l(oreg)!=5) { |
3792 printf("\tmr r5,%s\n", lregister_name_low(oreg)); | |
3793 } | |
221 | 3794 printf("\tbl lsrd__\n"); |
216 | 3795 } |
3796 | |
3797 static void | |
255 | 3798 code_ldiv_lib(int reg,int oreg) // ___divdi3$stub |
216 | 3799 { |
223 | 3800 code_save_stacks(); |
3801 clear_ptr_cache(); | |
255 | 3802 set_lreg_operand(reg,1); |
3803 set_lreg(RET_LREGISTER,0); | |
3804 set_lreg_operand1(oreg,1); | |
217 | 3805 extern_conv("__divdi3"); |
216 | 3806 } |
3807 | |
3808 static void | |
255 | 3809 code_ludiv_lib(int reg,int oreg) // ___udivdi3$stub |
216 | 3810 { |
223 | 3811 code_save_stacks(); |
3812 clear_ptr_cache(); | |
255 | 3813 set_lreg_operand(reg,1); |
3814 set_lreg(RET_LREGISTER,0); | |
3815 set_lreg_operand1(oreg,1); | |
217 | 3816 extern_conv("__udivdi3"); |
216 | 3817 } |
3818 | |
3819 static void | |
255 | 3820 code_lmod_lib(int reg,int oreg) // ___moddi3$stub |
216 | 3821 { |
223 | 3822 code_save_stacks(); |
3823 clear_ptr_cache(); | |
255 | 3824 set_lreg_operand(reg,1); |
3825 set_lreg(RET_LREGISTER,0); | |
3826 set_lreg_operand1(oreg,1); | |
217 | 3827 extern_conv("__moddi3"); |
216 | 3828 } |
3829 | |
3830 static void | |
255 | 3831 code_lumod_lib(int reg,int oreg) // ___umoddi3$stub |
216 | 3832 { |
223 | 3833 code_save_stacks(); |
3834 clear_ptr_cache(); | |
255 | 3835 set_lreg(RET_LREGISTER,0); |
3836 set_lreg_operand(reg,1); | |
3837 set_lreg_operand1(oreg,1); | |
217 | 3838 extern_conv("__umoddi3"); |
216 | 3839 } |
3840 | |
221 | 3841 #define check_lreg(reg) if (reg!=lreg) { lmove(reg,lreg); } |
3842 | |
211 | 3843 void |
221 | 3844 ltosop(int op,int reg,int oreg) |
195 | 3845 { |
221 | 3846 int dx = -1; |
252 | 3847 int ox = -1; |
211 | 3848 char *orn_h,*crn_h,*drn_h; |
3849 char *orn_l,*crn_l,*drn_l; | |
221 | 3850 // creg = creg op oreg |
3851 | |
3852 use_longlong(reg); | |
211 | 3853 if(oreg==-1) { |
3854 error(-1); | |
3855 } else if (oreg<= -REG_LVAR_OFFSET) { | |
252 | 3856 ox = get_lregister(); if (ox<0) error(-1); |
3857 use_reg(ox); | |
3858 code_rlvar(oreg+REG_LVAR_OFFSET,ox); | |
3859 oreg = ox; | |
211 | 3860 } |
3861 | |
3862 switch(op) { | |
3863 case LLSHIFT: | |
3864 case LULSHIFT: | |
255 | 3865 code_asld_lib(reg,oreg); // ___ashldi3$stub |
221 | 3866 check_lreg(reg); |
252 | 3867 if(ox!=-1) free_register(ox); |
211 | 3868 return; |
3869 case LRSHIFT: | |
255 | 3870 code_asrd_lib(reg,oreg); // ___ashrdi3$stub |
221 | 3871 check_lreg(reg); |
252 | 3872 if(ox!=-1) free_register(ox); |
211 | 3873 return; |
3874 case LURSHIFT: | |
255 | 3875 code_lsrd_lib(reg,oreg); // ___lshrdi3$stub |
221 | 3876 check_lreg(reg); |
252 | 3877 if(ox!=-1) free_register(ox); |
211 | 3878 return; |
3879 } | |
3880 orn_h = lregister_name_high(oreg); | |
3881 orn_l = lregister_name_low(oreg); | |
221 | 3882 crn_h = lregister_name_high(reg); |
3883 crn_l = lregister_name_low(reg); | |
211 | 3884 switch(op) { |
219 | 3885 case LADD: |
211 | 3886 printf("\taddc %s,%s,%s\n",crn_l,crn_l,orn_l); |
3887 printf("\tadde %s,%s,%s\n",crn_h,crn_h,orn_h); | |
3888 break; | |
219 | 3889 case LSUB: |
228 | 3890 printf("\tsubfc %s,%s,%s\n",crn_l,orn_l,crn_l); |
3891 printf("\tsubfe %s,%s,%s\n",crn_h,orn_h,crn_h); | |
211 | 3892 break; |
3893 case LCMP: | |
3894 error(-1); | |
3895 break; | |
219 | 3896 case LBAND: |
211 | 3897 printf("\tand %s,%s,%s\n",crn_l,crn_l,orn_l); |
3898 printf("\tand %s,%s,%s\n",crn_h,crn_h,orn_h); | |
3899 break; | |
219 | 3900 case LEOR: |
211 | 3901 printf("\txor %s,%s,%s\n",crn_l,crn_l,orn_l); |
3902 printf("\txor %s,%s,%s\n",crn_h,crn_h,orn_h); | |
3903 break; | |
219 | 3904 case LBOR: |
211 | 3905 printf("\tor %s,%s,%s\n",crn_l,crn_l,orn_l); |
3906 printf("\tor %s,%s,%s\n",crn_h,crn_h,orn_h); | |
3907 break; | |
219 | 3908 case LMUL: |
3909 case LUMUL: | |
223 | 3910 code_save_stacks(); |
3911 clear_ptr_cache(); | |
211 | 3912 dx=get_lregister(); |
223 | 3913 use_reg(dx); |
211 | 3914 drn_l = lregister_name_low(dx); |
3915 drn_h = lregister_name_high(dx); | |
3916 /* | |
3917 drn_l = l32( crn_l * orn_l); | |
3918 drn_h = h32( crn_l * orn_l); | |
3919 orn_l = l32( crn_h * orn_l); | |
3920 drn_h = drn_h + orn_l; | |
3921 crn_l = l32( crn_l * orn_h); | |
3922 crn_h = drn_h + crn_l; | |
3923 crn_l = drn_l; | |
3924 */ | |
3925 printf("\tmulhwu %s,%s,%s\n",drn_h,crn_l,orn_l); | |
228 | 3926 printf("\tmullw %s,%s,%s\n", drn_l,crn_l,orn_l); |
3927 printf("\tmullw %s,%s,%s\n", orn_l,crn_h,orn_l); | |
3928 printf("\tadd %s,%s,%s\n", drn_h,drn_h,orn_l); | |
3929 printf("\tmullw %s,%s,%s\n", crn_l,orn_h,crn_l); | |
3930 printf("\tadd %s,%s,%s\n", crn_h,drn_h,crn_l); | |
3931 printf("\tmr %s,%s\n", crn_l,drn_l); | |
211 | 3932 break; |
219 | 3933 case LDIV: |
255 | 3934 code_ldiv_lib(reg,oreg); // ___divdi3$stub |
221 | 3935 check_lreg(reg); |
211 | 3936 break; |
219 | 3937 case LUDIV: |
255 | 3938 code_ludiv_lib(reg,oreg); // ___udivdi3$stub |
221 | 3939 check_lreg(reg); |
211 | 3940 break; |
219 | 3941 case LMOD: |
255 | 3942 code_lmod_lib(reg,oreg); // ___moddi3$stub |
221 | 3943 check_lreg(reg); |
211 | 3944 break; |
219 | 3945 case LUMOD: |
255 | 3946 code_lumod_lib(reg,oreg); // ___umoddi3$stub |
221 | 3947 check_lreg(reg); |
211 | 3948 break; |
3949 default: | |
3950 error(-1); | |
3951 } | |
252 | 3952 if(ox!=-1) free_register(dx); |
221 | 3953 if(dx!=-1) free_register(dx); |
195 | 3954 } |
3955 | |
216 | 3956 int |
3957 code_lconst_op_p(int op,int e) | |
214 | 3958 { |
215 | 3959 int v; |
3960 if (car(e)==LCONST) { | |
222 | 3961 if (!(-32766<lcadr(e)&&lcadr(e)<32767)) return 0; |
215 | 3962 v = lcaddr(e); |
3963 } else if (car(e)==CONST) { | |
222 | 3964 if (!(-32766<cadr(e)&&cadr(e)<32767)) return 0; |
215 | 3965 v = caddr(e); |
222 | 3966 } else return 0; |
215 | 3967 |
214 | 3968 switch(op) { |
231 | 3969 case LLSHIFT: |
3970 case LULSHIFT: | |
3971 case LRSHIFT: | |
3972 case LURSHIFT: | |
215 | 3973 return (0<v&&v<31); |
219 | 3974 case LADD: |
3975 case LSUB: | |
215 | 3976 return 1; |
219 | 3977 case LBOR: |
215 | 3978 return (v>0); |
214 | 3979 default: |
3980 return 0; | |
3981 } | |
3982 } | |
3983 | |
216 | 3984 void |
221 | 3985 loprtc(int op,int creg,int e) |
213 | 3986 { |
221 | 3987 char *crn_h; |
3988 char *crn_l; | |
215 | 3989 char *grn; |
214 | 3990 int v; |
215 | 3991 int greg; |
3992 | |
221 | 3993 use_longlong(creg); |
3994 crn_h = lregister_name_high(creg); | |
3995 crn_l = lregister_name_low(creg); | |
3996 | |
222 | 3997 if (car(e)==LCONST) v = lcadr(e); |
3998 else if (car(e)==CONST) v = cadr(e); | |
213 | 3999 |
4000 switch(op) { | |
219 | 4001 case LLSHIFT: |
4002 case LULSHIFT: | |
215 | 4003 greg = get_register(); |
223 | 4004 use_reg(greg); |
215 | 4005 grn = register_name(greg); |
231 | 4006 printf("\tsrwi %s,%s,%d\n",grn,crn_l,32-v); |
4007 printf("\tslwi %s,%s,%d\n",crn_h,crn_h,v); | |
4008 printf("\tor %s,%s,%s\n",crn_h,grn,crn_h); | |
215 | 4009 printf("\tslwi %s,%s,%d\n",crn_l,crn_l,v); |
4010 free_register(greg); | |
213 | 4011 return; |
219 | 4012 case LRSHIFT: |
215 | 4013 greg = get_register(); |
223 | 4014 use_reg(greg); |
215 | 4015 grn = register_name(greg); |
4016 printf("\tsrwi %s,%s,%d\n",grn,crn_l,v); | |
231 | 4017 printf("\tinsrwi %s,%s,%d,0\n",grn,crn_h,v); |
215 | 4018 printf("\tsrawi %s,%s,%d\n",crn_h,crn_h,v); |
4019 printf("\tmr %s,%s\n",crn_l,grn); | |
4020 free_register(greg); | |
213 | 4021 return; |
219 | 4022 case LURSHIFT: |
215 | 4023 greg = get_register(); |
223 | 4024 use_reg(greg); |
215 | 4025 grn = register_name(greg); |
231 | 4026 printf("\tslwi %s,%s,%d\n",grn,crn_h,32-v); |
215 | 4027 printf("\tsrwi %s,%s,%d\n",crn_l,crn_l,v); |
231 | 4028 printf("\tor %s,%s,%s\n",crn_l,grn,crn_l); |
4029 printf("\tsrwi %s,%s,%d\n",crn_h,crn_h,v); | |
215 | 4030 free_register(greg); |
4031 return; | |
231 | 4032 case LSUB: |
4033 v = -v; | |
219 | 4034 case LADD: |
231 | 4035 printf("\taddic %s,%s,%d\n",crn_l,crn_l,v); |
4036 if (v<0) | |
4037 printf("\taddme %s,%s\n",crn_h,crn_h); | |
4038 else | |
4039 printf("\taddze %s,%s\n",crn_h,crn_h); | |
213 | 4040 break; |
219 | 4041 case LBOR: |
215 | 4042 printf("\tori %s,%s,lo16(%d)\n",crn_l,crn_l,v); |
213 | 4043 break; |
4044 default: | |
4045 error(-1); | |
4046 } | |
4047 } | |
4048 | |
4049 | |
211 | 4050 void |
4051 emit_lpop_free(int xreg) | |
195 | 4052 { |
211 | 4053 if (xreg>=0) |
4054 free_register(xreg); | |
195 | 4055 } |
4056 | |
211 | 4057 void |
4058 emit_lpush() | |
4059 { | |
4060 int new_reg; | |
212 | 4061 if (!is_longlong_reg(creg)) error(-1); |
211 | 4062 if (lreg_sp>MAX_MAX) error(-1); |
221 | 4063 new_reg = get_lregister(); /* ���Ф˼���(?) */ |
211 | 4064 lreg_stack[lreg_sp++] = creg; /* push ���뤫���˥쥸������Ȥ� */ |
4065 lreg = creg = new_reg; | |
4066 } | |
4067 | |
4068 void | |
239 | 4069 code_i2ll(int reg) |
195 | 4070 { |
215 | 4071 char *crn,*crn_h,*crn_l; |
239 | 4072 int reg0; |
4073 crn = register_name(reg0 = ireg); | |
4074 use_longlong(reg); | |
221 | 4075 crn_h = lregister_name_high(lreg); |
4076 crn_l = lregister_name_low(lreg); | |
239 | 4077 if (reg0!=regv_l(lreg)) |
215 | 4078 printf("\tmr %s,%s\n",crn_l,crn); |
4079 printf("\tsrawi %s,%s,31\n",crn_h,crn_l); | |
195 | 4080 } |
4081 | |
211 | 4082 void |
239 | 4083 code_i2ull(int reg) |
195 | 4084 { |
239 | 4085 code_i2ll(reg); |
195 | 4086 } |
4087 | |
211 | 4088 void |
239 | 4089 code_u2ll(int reg) |
195 | 4090 { |
215 | 4091 char *crn,*crn_h,*crn_l; |
239 | 4092 int reg0; |
4093 crn = register_name(reg0 = ireg); | |
4094 use_longlong(reg); | |
221 | 4095 crn_h = lregister_name_high(lreg); |
4096 crn_l = lregister_name_low(lreg); | |
239 | 4097 if (reg0!=regv_l(lreg)) |
215 | 4098 printf("\tmr %s,%s\n",crn_l,crn); |
4099 printf("\tli %s,0\n",crn_h); | |
195 | 4100 } |
4101 | |
211 | 4102 void |
4103 code_u2ull(int creg) | |
195 | 4104 { |
215 | 4105 code_u2ll(creg); |
195 | 4106 } |
4107 | |
211 | 4108 void |
239 | 4109 code_ll2i(int reg) |
195 | 4110 { |
219 | 4111 char *crn_l; |
239 | 4112 int reg0; |
4113 crn_l = lregister_name_low(reg0=lreg); | |
4114 use_int(reg); | |
4115 if (ireg!=regv_l(reg0)) | |
221 | 4116 printf("\tmr %s,%s\n",register_name(ireg),crn_l); |
195 | 4117 } |
4118 | |
211 | 4119 void |
4120 code_ll2u(int creg) | |
195 | 4121 { |
215 | 4122 code_ll2i(creg); |
195 | 4123 } |
4124 | |
211 | 4125 void |
4126 code_ull2i(int creg) | |
195 | 4127 { |
215 | 4128 code_ll2i(creg); |
195 | 4129 } |
4130 | |
211 | 4131 void |
4132 code_ull2u(int creg) | |
195 | 4133 { |
215 | 4134 code_ll2i(creg); |
195 | 4135 } |
4136 | |
4137 #if FLOAT_CODE | |
216 | 4138 |
211 | 4139 void |
239 | 4140 code_d2ll(int reg) |
195 | 4141 { |
215 | 4142 // fixdfdi$stub |
218 | 4143 set_freg(RET_FREGISTER,1); |
221 | 4144 extern_conv("__fixdfdi"); |
216 | 4145 set_lreg(RET_LREGISTER,0); |
239 | 4146 if (reg!=USE_CREG&®!=RET_LREGISTER) |
4147 use_longlong(reg); | |
195 | 4148 } |
4149 | |
211 | 4150 void |
239 | 4151 code_d2ull(int reg) |
195 | 4152 { |
218 | 4153 set_freg(RET_FREGISTER,1); |
221 | 4154 extern_conv("__fixunsdfdi"); |
216 | 4155 set_lreg(RET_LREGISTER,0); |
239 | 4156 if (reg!=USE_CREG&®!=RET_LREGISTER) |
4157 use_longlong(reg); | |
195 | 4158 } |
4159 | |
211 | 4160 void |
239 | 4161 code_f2ll(int reg) |
195 | 4162 { |
218 | 4163 set_freg(RET_FREGISTER,1); |
221 | 4164 extern_conv("__fixdfdi"); |
216 | 4165 set_lreg(RET_LREGISTER,0); |
239 | 4166 if (reg!=USE_CREG&®!=RET_LREGISTER) |
4167 use_longlong(reg); | |
195 | 4168 } |
4169 | |
211 | 4170 void |
239 | 4171 code_f2ull(int reg) |
195 | 4172 { |
218 | 4173 set_freg(RET_FREGISTER,1); |
221 | 4174 extern_conv("__fixsfdi"); |
216 | 4175 set_lreg(RET_LREGISTER,0); |
239 | 4176 if (reg!=USE_CREG&®!=RET_LREGISTER) |
4177 use_longlong(reg); | |
195 | 4178 } |
4179 | |
211 | 4180 void |
239 | 4181 code_ll2d(int reg) |
195 | 4182 { |
216 | 4183 set_lreg(RET_LREGISTER,1); |
221 | 4184 extern_conv("__floatdidf"); |
218 | 4185 set_freg(RET_FREGISTER,0); |
239 | 4186 if (reg!=USE_CREG&®!=RET_FREGISTER) |
4187 use_float(1,reg); | |
195 | 4188 } |
4189 | |
217 | 4190 |
211 | 4191 void |
239 | 4192 code_ll2f(int reg) |
195 | 4193 { |
216 | 4194 set_lreg(RET_LREGISTER,1); |
221 | 4195 extern_conv("__floatdisf"); |
218 | 4196 set_freg(RET_FREGISTER,0); |
239 | 4197 if (reg!=USE_CREG&®!=RET_FREGISTER) |
4198 use_float(0,reg); | |
195 | 4199 } |
4200 | |
211 | 4201 void |
4202 code_ull2d(int creg) | |
195 | 4203 { |
215 | 4204 code_ll2d(creg); |
195 | 4205 } |
4206 | |
211 | 4207 void |
4208 code_ull2f(int creg) | |
195 | 4209 { |
215 | 4210 code_ll2f(creg); |
195 | 4211 } |
4212 | |
4213 #endif | |
4214 | |
221 | 4215 static char * |
4216 addze(int dir) | |
4217 { | |
4218 return dir>0?"ze":"me"; | |
4219 } | |
195 | 4220 |
211 | 4221 void |
4222 code_lpreinc(int e1,int e2,int reg) | |
195 | 4223 { |
211 | 4224 char *xrn,*drn_h,*drn_l; |
222 | 4225 int dreg,xreg; |
211 | 4226 int dir=caddr(e1); |
4227 if (car(e2)==LREGISTER) { | |
221 | 4228 use_longlong(reg); |
4229 printf("\taddic %s,%s,%d\n", | |
211 | 4230 lregister_name_low(cadr(e2)),lregister_name_low(cadr(e2)), dir); |
221 | 4231 printf("\tadd%s %s,%s\n", addze(dir), |
211 | 4232 lregister_name_high(cadr(e2)),lregister_name_high(cadr(e2))); |
4233 if (cadr(reg)!=cadr(e2)) { | |
219 | 4234 lmove(cadr(reg),cadr(e2)); |
211 | 4235 } |
4236 return; | |
4237 } | |
4238 g_expr(e2); | |
221 | 4239 if(!is_int_reg(creg)) error(-1); |
222 | 4240 emit_push(); |
221 | 4241 if (reg==USE_CREG) { |
4242 dreg=get_lregister(); if (!dreg) error(-1); | |
4243 drn_h = lregister_name_high(dreg); | |
4244 drn_l = lregister_name_low(dreg); | |
4245 set_lreg(dreg,0); // free old lreg==creg | |
4246 } else { | |
4247 drn_h = lregister_name_high(reg); | |
4248 drn_l = lregister_name_low(reg); | |
4249 } | |
222 | 4250 xreg = emit_pop(0); |
4251 xrn = register_name(xreg); | |
245 | 4252 printf("\tlwz %s,%d(%s)\n",drn_l,SIZE_OF_INT,xrn); |
221 | 4253 printf("\tlwz %s,0(%s)\n",drn_h,xrn); |
4254 printf("\taddic %s,%s,%d\n",drn_l,drn_l,dir); | |
4255 printf("\tadd%s %s,%s\n",addze(dir),drn_h,drn_h); | |
245 | 4256 printf("\tstw %s,%d(%s)\n",drn_l,SIZE_OF_INT,xrn); |
211 | 4257 printf("\tstw %s,0(%s)\n",drn_h,xrn); |
222 | 4258 emit_pop_free(xreg); |
195 | 4259 } |
4260 | |
211 | 4261 void |
4262 code_lpostinc(int e1,int e2,int reg) | |
195 | 4263 { |
211 | 4264 char *xrn,*drn_h,*drn_l; |
4265 char *nrn_h,*nrn_l; | |
222 | 4266 int dreg,nreg,xreg; |
211 | 4267 int dir=caddr(e1); |
4268 if (car(e2)==LREGISTER) { | |
221 | 4269 use_longlong(reg); |
219 | 4270 lmove(cadr(reg),cadr(e2)); |
221 | 4271 printf("\taddic %s,%s,%d\n", |
211 | 4272 lregister_name_low(cadr(e2)),lregister_name_low(cadr(e2)), dir); |
221 | 4273 printf("\tadd%s %s,%s\n", addze(dir), |
211 | 4274 lregister_name_high(cadr(e2)),lregister_name_high(cadr(e2))); |
4275 return; | |
4276 } | |
4277 g_expr(e2); | |
221 | 4278 if(!is_int_reg(creg)) error(-1); |
222 | 4279 emit_push(); |
221 | 4280 nreg=get_lregister(); if (!nreg) error(-1); |
211 | 4281 nrn_h = lregister_name_high(nreg); |
4282 nrn_l = lregister_name_low(nreg); | |
221 | 4283 if (reg==USE_CREG) { |
4284 dreg=get_lregister(); if (!dreg) error(-1); | |
4285 drn_h = lregister_name_high(dreg); | |
4286 drn_l = lregister_name_low(dreg); | |
4287 set_lreg(dreg,0); // free old lreg==creg | |
4288 } else { | |
4289 drn_h = lregister_name_high(reg); | |
4290 drn_l = lregister_name_low(reg); | |
4291 } | |
222 | 4292 xreg = emit_pop(0); |
4293 xrn = register_name(xreg); | |
245 | 4294 printf("\tlwz %s,%d(%s)\n",drn_l,SIZE_OF_INT,xrn); |
221 | 4295 printf("\tlwz %s,0(%s)\n",drn_h,xrn); |
4296 printf("\taddic %s,%s,%d\n",nrn_l,drn_l,dir); | |
4297 printf("\tadd%s %s,%s\n",addze(dir),nrn_h,drn_h); | |
245 | 4298 printf("\tstw %s,%d(%s)\n",nrn_l,SIZE_OF_INT,xrn); |
211 | 4299 printf("\tstw %s,0(%s)\n",nrn_h,xrn); |
222 | 4300 emit_pop_free(xreg); |
211 | 4301 free_register(nreg); |
195 | 4302 } |
4303 | |
211 | 4304 void |
221 | 4305 code_lassop(int op,int reg) |
195 | 4306 { |
211 | 4307 int xreg; |
4308 int edx,edx0=-1; | |
221 | 4309 |
4310 // (*creg) op = pop() | |
211 | 4311 xreg = emit_lpop(0); /* pop e3 value */ |
4312 if (!is_int_reg(creg)) error(-1); | |
221 | 4313 edx = ireg; |
223 | 4314 emit_push(); |
221 | 4315 use_longlong(reg); |
4316 if (regv_l(lreg)==edx || regv_h(lreg)==edx) { | |
211 | 4317 edx0 = get_register(); if(!edx0) error(-1); |
4318 printf("# lassop\n\tmr %s,%s\n",register_name(edx0),register_name(edx)); | |
4319 edx = edx0; | |
4320 } | |
221 | 4321 printf("\tlwz %s,0(%s)\n",lregister_name_high(reg), |
211 | 4322 register_name(edx)); |
221 | 4323 printf("\tlwz %s,%d(%s)\n",lregister_name_low(reg), |
245 | 4324 SIZE_OF_INT,register_name(edx)); |
223 | 4325 free_register(edx); |
221 | 4326 ltosop(op,reg,xreg); |
223 | 4327 edx = emit_pop(0); |
221 | 4328 printf("\tstw %s,0(%s)\n",lregister_name_high(reg), |
211 | 4329 register_name(edx)); |
221 | 4330 printf("\tstw %s,%d(%s)\n",lregister_name_low(reg), |
245 | 4331 SIZE_OF_INT,register_name(edx)); |
211 | 4332 free_register(edx); |
4333 emit_lpop_free(xreg); | |
195 | 4334 } |
4335 | |
219 | 4336 void |
4337 code_register_lassop(int reg,int op) { | |
221 | 4338 // reg op = pop() |
219 | 4339 int xreg=emit_lpop(); |
221 | 4340 ltosop(op,reg,xreg); |
4341 emit_lpop_free(xreg); | |
219 | 4342 } |
4343 | |
195 | 4344 |
4345 #endif | |
4346 | |
95 | 4347 void |
4348 code_save_stacks() | |
4349 { | |
103 | 4350 int i,reg; |
101 | 4351 for(i=0;i<reg_sp;i++) { |
103 | 4352 if ((reg=reg_stack[i])>=0) { |
101 | 4353 code_assign_lvar( |
245 | 4354 (reg_stack[i]=new_lvar(SIZE_OF_INT)),reg,0); |
101 | 4355 reg_stack[i]= reg_stack[i]-REG_LVAR_OFFSET; |
4356 } | |
4357 } | |
195 | 4358 #if FLOAT_CODE |
101 | 4359 for(i=0;i<freg_sp;i++) { |
103 | 4360 if ((reg=freg_stack[i])>=0) { |
101 | 4361 code_dassign_lvar( |
245 | 4362 (freg_stack[i]=new_lvar(SIZE_OF_DOUBLE)),reg,1); |
101 | 4363 freg_stack[i]= freg_stack[i]-REG_LVAR_OFFSET; |
4364 } | |
4365 } | |
195 | 4366 #endif |
212 | 4367 #if LONGLONG_CODE |
4368 for(i=0;i<lreg_sp;i++) { | |
4369 if ((reg=lreg_stack[i])>=0) { | |
223 | 4370 code_lassign_lvar( |
245 | 4371 (lreg_stack[i]=new_lvar(SIZE_OF_LONGLONG)),reg); |
212 | 4372 lreg_stack[i]= lreg_stack[i]-REG_LVAR_OFFSET; |
4373 } | |
4374 } | |
4375 #endif | |
96 | 4376 } |
4377 | |
4378 void | |
4379 emit_lib(char *p[]) | |
95 | 4380 { |
98 | 4381 while(*p) { |
4382 printf("%s\n",*p++); | |
96 | 4383 } |
4384 } | |
4385 | |
4386 void | |
4387 code_closing() | |
4388 { | |
195 | 4389 #if FLOAT_CODE |
96 | 4390 if (d2u_lib_used) emit_lib(d2u_lib); |
4391 if (u2d_lib_used) emit_lib(u2d_lib); | |
4392 if (float_one_lib_used) emit_lib(float_one_lib); | |
98 | 4393 if (float_zero_lib_used) emit_lib(float_zero_lib); |
96 | 4394 if (i2d_lib_used) emit_lib(i2d_lib); |
195 | 4395 #endif |
213 | 4396 #if LONGLONG_CODE |
218 | 4397 if (asld_lib_used) emit_lib(asld_lib); |
221 | 4398 if (lsrd_lib_used) emit_lib(lsrd_lib); |
4399 if (asrd_lib_used) emit_lib(asrd_lib); | |
4400 #if 0 | |
216 | 4401 if (lumod_lib_used) emit_lib(lumod_lib); |
4402 if (lmod_lib_used) emit_lib(lmod_lib); | |
4403 if (ludiv_lib_used) emit_lib(ludiv_lib); | |
4404 if (ldiv_lib_used) emit_lib(ldiv_lib); | |
221 | 4405 #endif |
213 | 4406 #if FLOAT_CODE |
218 | 4407 #if 0 |
216 | 4408 if (dl2ll_lib_used) emit_lib(dl2ll_lib); |
4409 if (d2ull_lib_used) emit_lib(d2ull_lib); | |
4410 if (f2ll_lib_used) emit_lib(f2ll_lib); | |
4411 if (f2ull_lib_used) emit_lib(f2ull_lib); | |
4412 if (ll2d_lib_used) emit_lib(ll2d_lib); | |
4413 if (ll2f_lib_used) emit_lib(ll2f_lib); | |
213 | 4414 #endif |
4415 #endif | |
218 | 4416 #endif |
97 | 4417 global_table(); |
108 | 4418 /* printf("\t.ident \"Micro-C compiled\"\n"); */ |
95 | 4419 } |
4420 | |
89 | 4421 /* end */ |
4422 |