Mercurial > hg > CbC > old > device
annotate mc-code-powerpc.c @ 542:492f06738550
working... (struct init fix)
author | kono |
---|---|
date | Sun, 01 Jan 2006 18:49:07 +0900 (2006-01-01) |
parents | a349f9c2aef5 |
children | dbfd6e88e2c3 |
rev | line source |
---|---|
326 | 1 /* Micro-C Code Generation Part for Power PC (Mac OS X) */ |
89 | 2 /* $Id$ */ |
3 | |
327 | 4 #include <stdio.h> |
89 | 5 #include "mc.h" |
327 | 6 #include "mc-parse.h" |
93 | 7 #include "mc-code.h" |
89 | 8 #include "mc-codegen.h" |
9 | |
173 | 10 char *l_include_path[] = { |
11 "/usr/include/", | |
469 | 12 "/usr/lib/gcc/i686-apple-darwin8/4.0.0/include/", |
173 | 13 0 |
14 }; | |
15 | |
324 | 16 |
327 | 17 static |
18 char *init_src0 = "\ | |
313 | 19 #define __ppc__ 1\n\ |
20 #define __BIG_ENDIAN__ 1\n\ | |
21 #define __STDC__ 1\n\ | |
469 | 22 #define __GNUC__ 1\n\ |
526 | 23 #define __inline inline\n\ |
24 #define __inline__ inline\n\ | |
313 | 25 #define __builtin_va_list int\n\ |
26 #define __builtin_va_start(ap,arg) ap=(((int)(&arg))+sizeof(arg))\n\ | |
27 #define __builtin_va_arg(ap,type) (*((type *)ap)++)\n\ | |
28 #define alloca __builtin_alloca\n\ | |
29 "; | |
30 | |
89 | 31 #define TEXT_EMIT_MODE 0 |
32 #define DATA_EMIT_MODE 1 | |
33 #define RODATA_EMIT_MODE 2 | |
34 | |
221 | 35 static void ld_indexx(int byte, int n, int xreg,int reg,int sign); |
93 | 36 static void local_table(void); |
221 | 37 static void shift(char *op, int creg,int reg); |
444 | 38 static int push_struct(int e4,int t,int arg); |
518 | 39 static void ascii(char *s); |
40 | |
93 | 41 |
341 | 42 |
221 | 43 static int creg; |
44 | |
89 | 45 static int output_mode = TEXT_EMIT_MODE; |
340 | 46 int data_alignment = 0; |
89 | 47 |
48 static int code_disp_label; | |
111 | 49 static int code_setup; |
116 | 50 static int r1_offset_label; |
51 static int lvar_offset_label; | |
313 | 52 static int max_func_arg_label; |
116 | 53 |
54 static int reg_save; | |
55 static int freg_save; | |
56 | |
205 | 57 static int freg,ireg,lreg; |
147 | 58 |
238 | 59 int code_lassop_p = 1; |
60 | |
245 | 61 #define SIZE_OF_INT 4 |
62 #define SIZE_OF_SHORT 2 | |
63 #define SIZE_OF_FLOAT 4 | |
64 #define SIZE_OF_DOUBLE 8 | |
65 #define SIZE_OF_LONGLONG 8 | |
66 #define ENDIAN 1 | |
411 | 67 #define ENDIAN_L 1 |
68 #define ENDIAN_D 1 | |
245 | 69 |
205 | 70 static int reg_sp; /* REGister Stack-Pointer */ |
71 static int reg_stack[MAX_MAX]; /* �ºݤΥ쥸�������ΰ� */ | |
138 | 72 |
73 /* floating point registers */ | |
74 | |
205 | 75 static int freg_sp; /* floating point REGister Stack-Pointer */ |
76 static int freg_stack[MAX_MAX]; /* �ºݤΥ쥸�������ΰ� */ | |
89 | 77 |
206 | 78 static int lreg_sp; /* longlong REGister Stack-Pointer */ |
79 static int lreg_stack[MAX_MAX]; /* �ºݤΥ쥸�������ΰ� */ | |
80 | |
119 | 81 #define REG_fp 1 |
82 #define REG_sp 30 | |
83 #define REG_VAR_BASE 29 | |
130 | 84 #define REG_VAR_MIN 18 |
119 | 85 #define MIN_TMP_REG 3 |
130 | 86 #define MAX_TMP_REG 11 |
119 | 87 |
88 #define PTRC_REG 3 | |
89 | |
90 #define FREG_VAR_BASE 31 | |
130 | 91 #define FREG_VAR_MIN 20 |
119 | 92 #define MIN_TMP_FREG 1 |
130 | 93 #define MAX_TMP_FREG 14 |
119 | 94 |
95 int MAX_REGISTER=30; /* PowerPC�Υ쥸������10�ĤޤǻȤ�*/ | |
122 | 96 int MAX_FREGISTER=31; |
119 | 97 #define REAL_MAX_REGISTER 32 /* PowerPC�Υ쥸������32�Ȥ�������*/ |
98 #define REAL_MAX_FREGISTER 32 /* PowerPC�Υ쥸������32�Ȥ�������*/ | |
207 | 99 #define REAL_MAX_LREGISTER 16 |
119 | 100 |
145 | 101 #define FREG_OFFSET REAL_MAX_REGISTER |
207 | 102 #define LREG_OFFSET (REAL_MAX_REGISTER+REAL_MAX_FREGISTER) |
103 | |
104 #define RET_REGISTER 3 | |
105 #define RET_FREGISTER (1+FREG_OFFSET) | |
222 | 106 #define RET_LREGISTER_H 3 /* high word */ |
207 | 107 #define RET_LREGISTER_L 4 /* low word */ |
108 #define RET_LREGISTER LREG_OFFSET | |
145 | 109 |
122 | 110 int MAX_INPUT_REGISTER_VAR = 11-MIN_TMP_REG; |
111 int MAX_CODE_INPUT_REGISTER_VAR = 11-MIN_TMP_REG; | |
112 int MAX_INPUT_DREGISTER_VAR = 14-MIN_TMP_FREG; | |
138 | 113 int MAX_INPUT_FREGISTER_VAR = 14-MIN_TMP_FREG; |
122 | 114 int MAX_CODE_INPUT_DREGISTER_VAR = 14-MIN_TMP_FREG; |
138 | 115 int MAX_CODE_INPUT_FREGISTER_VAR = 14-MIN_TMP_FREG; |
119 | 116 |
207 | 117 static int powerpc_regs[REAL_MAX_REGISTER+REAL_MAX_FREGISTER+ |
118 REAL_MAX_LREGISTER]; | |
119 static int regv_h0[REAL_MAX_LREGISTER]; | |
120 static int regv_l0[REAL_MAX_LREGISTER]; | |
211 | 121 #define regv_h(i) regv_h0[(i)-LREG_OFFSET] |
122 #define regv_l(i) regv_l0[(i)-LREG_OFFSET] | |
205 | 123 |
124 static int *regs = powerpc_regs; | |
119 | 125 |
207 | 126 #define CREG_REGISTER (MAX_TMP_REG) |
127 #define FREG_FREGISTER (MAX_TMP_FREG+FREG_OFFSET) | |
128 #define LREG_LREGISTER (MAX_TMP_REG+LREG_OFFSET) | |
206 | 129 |
130 | |
119 | 131 static int max_reg_var, max_freg_var; |
132 | |
133 static char *reg_name[] = { | |
134 "r0","r1","r2","r3","r4","r5","r6","r7","r8","r9", | |
135 "r10","r11","r12","r13","r14","r15","r16","r17","r18","r19", | |
136 "r20","r21","r22","r23","r24","r25","r26","r27","r28","r29", | |
145 | 137 "r30","r31", |
119 | 138 "f0","f1","f2","f3","f4","f5","f6","f7","f8","f9", |
139 "f10","f11","f12","f13","f14","f15","f16","f17","f18","f19", | |
140 "f20","f21","f22","f23","f24","f25","f26","f27","f28","f29", | |
141 "f30","f31" | |
142 }; | |
143 | |
260 | 144 #define round4(i) ((i+(SIZE_OF_INT-1))&~(SIZE_OF_INT-1)) |
258
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
145 |
207 | 146 #define register_name(i) reg_name[i] |
147 #define fregister_name(i) reg_name[i] | |
148 #define lregister_name_low(i) reg_name[regv_l(i)] | |
210 | 149 #define lregister_name_high(i) reg_name[regv_h(i)] |
207 | 150 |
431 | 151 #define DEBUG_REG 1 |
152 #if DEBUG_REG | |
467 | 153 char *rn(int i) { return register_name(i); } |
154 char *fn(int i) { return fregister_name(i); } | |
155 char *lln(int i) { return lregister_name_low(i); } | |
156 char *lhn(int i) { return lregister_name_high(i); } | |
157 int ll(int i) { return regv_l(i); } | |
158 int lh(int i) { return regv_h(i); } | |
431 | 159 #endif |
221 | 160 |
207 | 161 #define is_int_reg(i) (0<=i&&i<REAL_MAX_REGISTER) |
162 #define is_float_reg(i) (REAL_MAX_REGISTER<=i&&i<REAL_MAX_FREGISTER+REAL_MAX_REGISTER) | |
163 #define is_longlong_reg(i) (LREG_OFFSET<=i&&i<LREG_OFFSET+REAL_MAX_LREGISTER) | |
147 | 164 |
221 | 165 #define use_int(reg) if (reg==USE_CREG) reg=use_int0() |
166 static | |
167 int use_int0() { | |
168 int i = creg; | |
233 | 169 if (!i||!ireg||!is_int_reg(i)) { |
530 | 170 if (lreg) { free_register(lreg); lreg = 0; } |
205 | 171 if (!ireg) ireg = get_register(); |
222 | 172 // else if (ireg!=i) free_register(i); |
206 | 173 i = ireg; |
205 | 174 } |
207 | 175 if (!regs[i]) regs[i]=USING_REG; |
221 | 176 creg = i; |
147 | 177 return i; |
178 } | |
179 | |
222 | 180 #if LONGLONG_CODE |
181 #define use_longlong(reg) if (reg==USE_CREG) reg=use_longlong0() | |
182 | |
183 static | |
184 int use_longlong0() { | |
185 int i = creg; | |
186 if (!is_longlong_reg(i)) { | |
187 if (ireg) { free_register(ireg); ireg=0; } | |
226 | 188 if (!lreg||!regs[lreg]) lreg = get_lregister(); |
222 | 189 // else if (lreg!=i) free_register(i); |
190 i = lreg; | |
191 } | |
192 if (!regv_l(i)) regv_l(i) = get_register(); | |
193 if (!regv_h(i)) regv_h(i) = get_register(); | |
194 if (!regs[i]) regs[i]=USING_REG; | |
195 if (!regs[regv_l(i)]) regs[regv_l(i)]=USING_REG; | |
196 if (!regs[regv_h(i)]) regs[regv_h(i)]=USING_REG; | |
197 creg = i; | |
198 return i; | |
199 } | |
200 #endif | |
201 | |
202 | |
221 | 203 #if FLOAT_CODE |
204 #define use_float(d,reg) if (reg==USE_CREG) reg=d?use_double0():use_float0() | |
205 static | |
206 int use_float0() { | |
207 int i = creg; | |
207 | 208 if (!is_float_reg(i)) { |
209 if (lreg) { free_register(lreg); lreg = 0; } | |
210 if (!freg) freg = get_dregister(0); | |
208 | 211 else if (freg!=i) free_register(i); |
207 | 212 i = freg; |
213 } | |
214 if (!regs[i]) regs[i]=USING_REG; | |
221 | 215 creg = i; |
147 | 216 return i; |
217 } | |
221 | 218 static |
219 int use_double0() { | |
220 int i = creg; | |
207 | 221 if (!is_float_reg(i)) { |
222 if (lreg) { free_register(lreg); lreg = 0; } | |
223 if (!freg) freg = get_dregister(1); | |
208 | 224 else if (freg!=i) free_register(i); |
207 | 225 i = freg; |
226 } | |
227 if (!regs[i]) regs[i]=USING_REG; | |
221 | 228 creg = i; |
147 | 229 return i; |
230 } | |
221 | 231 #endif |
232 | |
195 | 233 |
234 #if FLOAT_CODE | |
119 | 235 static |
348 | 236 NMTBL float_zero = {"_float_zero",0,STATIC,FLOAT,0}; |
119 | 237 static |
348 | 238 NMTBL float_one = {"_float_one",0,STATIC,FLOAT,0}; |
119 | 239 |
240 | |
241 static char * fload(int d); | |
242 static int code_d1(double d); | |
243 static int code_d2(double d); | |
195 | 244 #endif |
206 | 245 #if LONGLONG_CODE |
246 static int code_l1(long long ll); | |
247 static int code_l2(long long ll); | |
248 #endif | |
195 | 249 |
305
117baacd1ed0
stdarg powerpc passed except long long (macro problem)
kono
parents:
304
diff
changeset
|
250 static void code_save_input_registers(int dots); |
207 | 251 static void set_ireg(int,int); |
119 | 252 static void set_freg(int,int); |
195 | 253 static void set_lreg(int,int); |
287 | 254 static void jcond(int l, char cond); |
431 | 255 static void register_usage(char *s); |
256 | |
119 | 257 |
153 | 258 static int max_func_args; |
259 static int my_func_args; | |
119 | 260 #define ARG_LVAR_OFFSET 0x10000000 |
261 | |
126 | 262 /* |
89 | 263 |
97 | 264 r0 return value etc. |
265 r3-r10 input register | |
326 | 266 r22-r29 saved register variable (input register for code segment) |
89 | 267 r30 stack pointer |
268 r31 0 | |
269 r1 frame pointer | |
97 | 270 |
271 f0 return value etc. | |
272 f1-r8 input register | |
273 f24-f31 saved register variable | |
116 | 274 |
202 | 275 function call stack frame |
375 | 276 <-------r1_offset------------------------------> |
277 <------------lvar_offset0------> | |
449 | 278 <--lvar_offset--> r30(?) r1 |
116 | 279 r+ +------------+---+---------------+----------+--------------+----+ - |
122 | 280 callee arg xx register save local caller arg xx |
245 | 281 reg_save disp max_func_args*SIZE_OF_INT |
119 | 282 lvar>0 lvar<0 lvar>0x1000 0000 |
127 | 283 |
284 code segment stack frame | |
285 | |
286 * goto��ƤӽФ����ؿ���r1 ! r1(goto����r1) | |
128 | 287 # * r30 <---r1_offset---------> r1 |
127 | 288 r+ +----------+--+----------+----------------+-----------+----------+----+ |
289 cousin arg xx reg save !callee arg !code local caller arg xx | |
290 r20-r29 lvar>0 lvar<0 lvar>0x1000 000 | |
291 f20-f31 <-my_func_args--><--disp-----><-max_func_arg-> | |
245 | 292 *SIZE_OF_INT *SIZE_OF_INT |
127 | 293 |
89 | 294 */ |
449 | 295 static int arg_offset = 24; |
296 static int arg_offset1 = 24; | |
297 int disp_offset = -12; | |
230 | 298 // #define func_disp_offset 60 |
299 #define func_disp_offset 68 | |
122 | 300 #define r1_offset func_disp_offset+12 |
449 | 301 static int code_disp_offset = 0; |
302 // static int jump_offset = 0; | |
303 | |
121 | 304 #define CODE_LVAR l+code_disp_offset |
129 | 305 #define CODE_CALLER_ARG (l-ARG_LVAR_OFFSET)+arg_offset1 |
121 | 306 #define FUNC_LVAR l+disp_offset |
307 #define CALLER_ARG (l-ARG_LVAR_OFFSET)+arg_offset1 | |
308 #define CALLEE_ARG l+arg_offset | |
89 | 309 |
116 | 310 void |
311 code_offset_set() | |
312 { | |
126 | 313 #if 0 |
121 | 314 int l; |
126 | 315 #endif |
245 | 316 int lvar_offsetv = -disp+max_func_args*SIZE_OF_INT+func_disp_offset; |
375 | 317 // int r1_offsetv = -disp+max_func_args*SIZE_OF_INT-reg_save+r1_offset; |
318 int r1_offsetv = lvar_offsetv-reg_save+12; | |
319 printf(".set L_%d,%d\n",lvar_offset_label,r1_offsetv-lvar_offsetv); | |
121 | 320 printf(".set L_%d,%d\n",r1_offset_label,r1_offsetv); |
313 | 321 if (max_func_arg_label) { |
322 printf(".set L_%d,%d\n",max_func_arg_label,max_func_args*SIZE_OF_INT+24); | |
323 max_func_arg_label = 0; | |
324 } | |
325 | |
417 | 326 #if 0 |
468 | 327 printf("## reg_save %d\n",reg_save); |
328 printf("## function %s\n",fnptr->nm); | |
121 | 329 l = ARG_LVAR_OFFSET; |
468 | 330 printf("## offset call0\t%d\n",CALLER_ARG); |
245 | 331 l = ARG_LVAR_OFFSET+max_func_args*SIZE_OF_INT; |
468 | 332 printf("## offset calln\t%d %d\n",CALLER_ARG,max_func_args*SIZE_OF_INT); |
121 | 333 l = disp; |
468 | 334 printf("## offset lvarn\t%d %d\n",FUNC_LVAR+lvar_offsetv,disp); |
121 | 335 l = 0; |
468 | 336 printf("## offset lvar0\t%d\n",FUNC_LVAR+lvar_offsetv); |
121 | 337 l = -reg_save; |
468 | 338 printf("## offset regs\t%d\n",FUNC_LVAR+lvar_offsetv); |
339 printf("## offset r1off\t%d\n",r1_offsetv); | |
121 | 340 l = 0; |
468 | 341 printf("## offset carg0\t%d\n",CALLEE_ARG+r1_offsetv); |
121 | 342 l = my_func_args; |
468 | 343 printf("## offset cargn\t%d %d\n",CALLEE_ARG+r1_offsetv,my_func_args); |
126 | 344 #endif |
116 | 345 } |
111 | 346 |
375 | 347 static int large_offset_reg; |
119 | 348 |
349 static void | |
375 | 350 lvar(int l) |
116 | 351 { |
375 | 352 char *rn; |
353 if (!large_offset_reg) { | |
354 if (fnptr->sc==CODE) { | |
355 if (l>=ARG_LVAR_OFFSET) { /* caller's arguments */ | |
356 printf("lo16(%d)(r1)\n",CODE_CALLER_ARG); | |
357 } else | |
358 printf("lo16(%d)(r30)\n",CODE_LVAR); | |
359 } else if (l<0) { /* local variable */ | |
360 printf("lo16(%d)(r30)\n",FUNC_LVAR); | |
361 } else if (l>=ARG_LVAR_OFFSET) { /* caller's arguments */ | |
362 printf("lo16(%d)(r1)\n",CALLER_ARG); | |
363 } else { /* callee's arguments */ | |
364 printf("lo16(%d+L_%d)(r30)\n",CALLEE_ARG,lvar_offset_label); | |
365 } | |
366 } else { | |
367 rn = register_name(large_offset_reg); | |
368 if (fnptr->sc==CODE) { | |
369 if (l>=ARG_LVAR_OFFSET) { /* caller's arguments */ | |
370 printf("lo16(%d)(%s)\n",CODE_CALLER_ARG,rn); | |
371 } else | |
372 printf("lo16(%d)(%s)\n",CODE_LVAR,rn); | |
373 } else if (l<0) { /* local variable */ | |
374 printf("lo16(%d)(%s)\n",FUNC_LVAR,rn); | |
375 } else if (l>=ARG_LVAR_OFFSET) { /* caller's arguments */ | |
376 printf("lo16(%d)(%s)\n",CALLER_ARG,rn); | |
377 } else { /* callee's arguments */ | |
378 printf("lo16(%d+L_%d)(%s)\n",CALLEE_ARG,lvar_offset_label,rn); | |
379 } | |
380 free_register(large_offset_reg); | |
116 | 381 } |
382 } | |
111 | 383 |
119 | 384 /* if size of local variables / input variables is more then 64k, |
385 lo16 does not work. We have to use ha16 also. But we can't know | |
386 the exact size in one path compile. We may safely use lvar16ha | |
326 | 387 if disp or max_func_args > 32k. Of course this is redundant for |
119 | 388 smaller offset. But who cares who use very large local variables? |
389 */ | |
96 | 390 |
375 | 391 #define LARGE_OFFSET(l) (l<-32000||l>32000) |
95 | 392 |
119 | 393 static void |
375 | 394 lvar_intro(int l) |
119 | 395 { |
375 | 396 char *rn; |
397 large_offset_reg=0; | |
119 | 398 if (fnptr->sc==CODE) { |
375 | 399 if (l>=ARG_LVAR_OFFSET) { /* caller's arguments */ |
400 if (LARGE_OFFSET(CODE_CALLER_ARG)) { | |
401 rn=register_name(large_offset_reg=get_register()); | |
402 printf("\taddis %s,r1,ha16(%d)\n",rn,CODE_CALLER_ARG); | |
403 } | |
404 } else { | |
405 if (LARGE_OFFSET(CODE_LVAR)) { | |
406 rn=register_name(large_offset_reg=get_register()); | |
407 printf("\taddis %s,r30,ha16(%d)\n",rn,CODE_LVAR); | |
408 } | |
409 } | |
119 | 410 } else if (l<0) { /* local variable */ |
375 | 411 if (LARGE_OFFSET(FUNC_LVAR)) { |
412 rn=register_name(large_offset_reg=get_register()); | |
413 printf("\taddis %s,r30,ha16(%d)\n",rn,FUNC_LVAR); | |
414 } | |
125 | 415 } else if (l>=ARG_LVAR_OFFSET) { /* caller's arguments */ |
375 | 416 if (LARGE_OFFSET(CALLER_ARG)) { |
417 rn=register_name(large_offset_reg=get_register()); | |
418 printf("\taddis %s,r1,ha16(%d)\n",rn,CALLER_ARG); | |
419 } | |
119 | 420 } else { /* callee's arguments */ |
375 | 421 if (LARGE_OFFSET(CALLEE_ARG)) { |
422 rn=register_name(large_offset_reg=get_register()); | |
423 printf("\taddis %s,r30,lo16(%d+L_%d)\n", | |
424 rn,CALLEE_ARG,lvar_offset_label); | |
425 } | |
119 | 426 } |
427 } | |
89 | 428 |
429 | |
119 | 430 void |
221 | 431 code_lvar(int e2,int reg) { |
432 use_int(reg); | |
119 | 433 lvar_intro(e2); |
221 | 434 printf("\tla %s,",register_name(reg)); |
119 | 435 lvar(e2); |
436 } | |
95 | 437 |
89 | 438 void |
439 code_init(void) | |
440 { | |
327 | 441 /* called only once */ |
442 | |
443 init_src = init_src0; | |
444 size_of_int = SIZE_OF_INT; | |
445 size_of_short = SIZE_OF_SHORT; | |
446 size_of_float = SIZE_OF_FLOAT; | |
447 size_of_double = SIZE_OF_DOUBLE; | |
448 size_of_longlong = SIZE_OF_LONGLONG; | |
449 endian = ENDIAN; | |
450 | |
207 | 451 regv_l(RET_LREGISTER) = RET_LREGISTER_L; |
452 regv_h(RET_LREGISTER) = RET_LREGISTER_H; | |
89 | 453 } |
454 | |
327 | 455 extern void |
456 emit_reinit() | |
457 { | |
458 /* called for each file */ | |
328 | 459 /* heap is initialized here, setup ptr cache free list */ |
460 init_ptr_cache(); | |
327 | 461 } |
462 | |
89 | 463 void |
464 gexpr_code_init(void){ | |
96 | 465 } |
466 | |
147 | 467 void |
468 code_gexpr(int e){ | |
529 | 469 if (is_int_reg(creg) && creg!=ireg) error(-1); |
531 | 470 // register_usage("code_gexpr"); |
147 | 471 } |
472 | |
89 | 473 |
109 | 474 void |
137 | 475 code_arg_register(NMTBL *fnptr) |
109 | 476 { |
137 | 477 int args = fnptr->dsp; |
478 NMTBL *n; | |
479 int reg_var = 0; | |
480 int freg_var = 0; | |
481 int type; | |
482 int reg; | |
207 | 483 int i; |
137 | 484 int is_code0 = is_code(fnptr); |
305
117baacd1ed0
stdarg powerpc passed except long long (macro problem)
kono
parents:
304
diff
changeset
|
485 int dots; |
117baacd1ed0
stdarg powerpc passed except long long (macro problem)
kono
parents:
304
diff
changeset
|
486 |
117baacd1ed0
stdarg powerpc passed except long long (macro problem)
kono
parents:
304
diff
changeset
|
487 function_type(fnptr->ty,&dots); |
137 | 488 while (args) { |
489 /* process in reverse order */ | |
490 n = (NMTBL*)caddr(args); | |
491 type = n->ty; | |
492 if (scalar(type)) { | |
493 if ((reg = get_input_register_var(reg_var,n,is_code0))) { | |
494 n->sc = REGISTER; | |
207 | 495 n->dsp = cadr(reg); |
496 regs[n->dsp]= INPUT_REG; | |
137 | 497 reg_var++; |
245 | 498 cadddr(args)=SIZE_OF_INT; |
137 | 499 } |
138 | 500 } else if (type==FLOAT) { |
501 if ((reg = get_input_dregister_var(freg_var,n,is_code0,0))) { | |
502 n->sc = DREGISTER; | |
207 | 503 n->dsp = cadr(reg); |
504 regs[n->dsp]= INPUT_REG; | |
138 | 505 freg_var++; |
205 | 506 cadddr(args)=size(type); |
138 | 507 } |
508 } else if (type==DOUBLE) { | |
509 if ((reg = get_input_dregister_var(freg_var,n,is_code0,1))) { | |
137 | 510 n->sc = DREGISTER; |
207 | 511 n->dsp = cadr(reg); |
512 regs[n->dsp]= INPUT_REG; | |
137 | 513 freg_var++; |
205 | 514 cadddr(args)=size(type); |
515 } | |
516 } else if (type==LONGLONG||type==ULONGLONG) { | |
517 if ((reg = get_input_lregister_var(reg_var,n,is_code0))) { | |
518 n->sc = LREGISTER; | |
207 | 519 n->dsp = cadr(reg); |
520 regs[i=n->dsp]= INPUT_REG; | |
521 regs[regv_l(i)]= INPUT_REG; | |
522 regs[regv_h(i)]= INPUT_REG; | |
205 | 523 reg_var+=2; |
524 cadddr(args)=size(type); | |
137 | 525 } |
526 } | |
527 args = cadr(args); | |
528 } | |
126 | 529 if (is_function(fnptr)) |
305
117baacd1ed0
stdarg powerpc passed except long long (macro problem)
kono
parents:
304
diff
changeset
|
530 code_save_input_registers(dots); |
109 | 531 } |
532 | |
208 | 533 |
89 | 534 int |
210 | 535 get_register(void) |
89 | 536 { /* �Ȥ��Ƥ��ʤ��쥸������Ĵ�٤� */ |
219 | 537 int i,j,reg; |
96 | 538 for(i=MAX_TMP_REG;i>MIN_TMP_REG;i--) { |
102 | 539 if (regs[i]) continue; /* �Ȥ��Ƥ��� */ |
540 regs[i]=USING_REG; /* ���Υ쥸������Ȥ����Ȥ������ */ | |
207 | 541 return i; /* ���ξ���ɽ���ֹ���֤� */ |
102 | 542 } |
135 | 543 /* PTR_CACHE ��Ĥ֤� */ |
341 | 544 if ((i=last_ptr_cache())) { |
545 clear_ptr_cache_reg(i); | |
96 | 546 regs[i]=USING_REG; /* ���Υ쥸������Ȥ����Ȥ������ */ |
207 | 547 return i; /* ���ξ���ɽ���ֹ���֤� */ |
96 | 548 } |
549 /* search register stack */ | |
550 for(i=0;i<reg_sp;i++) { | |
120 | 551 if ((reg=reg_stack[i])>=0) { |
96 | 552 code_assign_lvar( |
245 | 553 (j=new_lvar(SIZE_OF_INT)),reg,0); |
219 | 554 reg_stack[i]= j-REG_LVAR_OFFSET; |
120 | 555 return reg; |
89 | 556 } |
557 } | |
206 | 558 #if LONGLONG_CODE |
559 /* search register stack */ | |
560 for(i=0;i<lreg_sp;i++) { | |
561 if ((reg=lreg_stack[i])>=0) { | |
219 | 562 code_lassign_lvar( |
245 | 563 (j=new_lvar(SIZE_OF_LONGLONG)),reg); |
219 | 564 lreg_stack[i]= j-REG_LVAR_OFFSET; |
206 | 565 free_register(reg); |
566 return get_register(); | |
567 } | |
568 } | |
569 #endif | |
130 | 570 for(i=0;i<REG_VAR_BASE-REG_VAR_MIN;i++) { |
571 reg =REG_VAR_BASE-i; | |
572 if (! regs[reg]) { /* �Ȥ��Ƥ��ʤ��ʤ� */ | |
573 regs[reg]=USING_REG; /* ���Υ쥸������Ȥ����Ȥ������ */ | |
574 if (i>max_reg_var) max_reg_var=i; | |
207 | 575 return reg; /* ���ξ���ɽ���ֹ���֤� */ |
130 | 576 } |
577 } | |
96 | 578 /* �����Ƥ����꤬�ʤ��ʤ顢���顼 (���ä���ï���ȤäƤ��?) */ |
528 | 579 error(RGERR); return creg; |
89 | 580 } |
581 | |
210 | 582 #if 0 |
208 | 583 int |
584 get_register(void) | |
585 { | |
586 int i = get_register0(); | |
468 | 587 printf("## get_register %d\n",i); |
208 | 588 return i; |
589 } | |
210 | 590 #endif |
208 | 591 |
93 | 592 int |
593 pop_register(void) | |
594 { /* �쥸���������ͤ���Ф� */ | |
595 return reg_stack[--reg_sp]; | |
596 } | |
597 | |
195 | 598 #if FLOAT_CODE |
96 | 599 int |
210 | 600 get_dregister(int d) |
96 | 601 { /* �Ȥ��Ƥ��ʤ��쥸������Ĵ�٤� */ |
103 | 602 int i,reg; |
145 | 603 for(i=MAX_TMP_FREG+FREG_OFFSET;i>MIN_TMP_FREG+FREG_OFFSET;i--) { |
604 if (regs[i]) continue; /* �Ȥ��Ƥ��� */ | |
605 regs[i]=USING_REG; /* ���Υ쥸������Ȥ����Ȥ������ */ | |
207 | 606 return i; /* ���ξ���ɽ���ֹ���֤� */ |
102 | 607 } |
96 | 608 /* search register stack */ |
609 for(i=0;i<freg_sp;i++) { | |
103 | 610 if ((reg=freg_stack[i])>=0) { |
96 | 611 code_dassign_lvar( |
245 | 612 (freg_stack[i]=new_lvar(SIZE_OF_DOUBLE)),reg,1); |
96 | 613 freg_stack[i]= freg_stack[i]-REG_LVAR_OFFSET; |
120 | 614 return reg; |
96 | 615 } |
616 } | |
130 | 617 for(i=0;i<FREG_VAR_BASE-REG_VAR_MIN;i++) { |
145 | 618 reg =FREG_VAR_BASE-i+FREG_OFFSET; |
619 if (! regs[reg]) { /* �Ȥ��Ƥ��ʤ��ʤ� */ | |
620 regs[reg]=USING_REG; /* ���Υ쥸������Ȥ����Ȥ������ */ | |
130 | 621 if (i>max_freg_var) max_freg_var=i; |
207 | 622 return reg; /* ���ξ���ɽ���ֹ���֤� */ |
130 | 623 } |
624 } | |
96 | 625 /* �����Ƥ����꤬�ʤ��ʤ顢���顼 (���ä���ï���ȤäƤ��?) */ |
98 | 626 error(REG_ERR); return freg; |
96 | 627 } |
628 | |
210 | 629 #if 0 |
208 | 630 int |
631 get_dregister(int d) | |
632 { | |
633 int i = get_dregister0(d); | |
468 | 634 printf("## get_dregister %d\n",i); |
208 | 635 return i; |
636 } | |
210 | 637 #endif |
208 | 638 |
96 | 639 int |
97 | 640 pop_fregister(void) |
96 | 641 { /* �쥸���������ͤ���Ф� */ |
642 return freg_stack[--freg_sp]; | |
643 } | |
195 | 644 #endif |
645 | |
530 | 646 |
195 | 647 int |
207 | 648 get_lregister0() |
649 { | |
650 int i; | |
651 for(i=LREG_OFFSET+1;i<REAL_MAX_LREGISTER+LREG_OFFSET;i++) { | |
652 if (regs[i]==0) { | |
653 return i; | |
654 } | |
655 } | |
656 return -1; | |
657 } | |
658 | |
530 | 659 static int |
660 get_lregister1(int n,int m) | |
661 { | |
662 int i; | |
663 #if 1 | |
664 for(i=LREG_OFFSET;i<REAL_MAX_LREGISTER+LREG_OFFSET;i++) { | |
665 if (regv_l(i)==n && regv_h(i)==m) { | |
666 return i; | |
667 } | |
668 } | |
669 #endif | |
670 return get_lregister0(); | |
671 } | |
672 | |
673 | |
674 static void | |
675 cleanup_lregister0() | |
676 { | |
677 int i; | |
536 | 678 // we should not have this, but powerpc's function |
679 // lost some input register variables. | |
530 | 680 #if 1 |
681 for(i=LREG_OFFSET+1;i<REAL_MAX_LREGISTER+LREG_OFFSET;i++) { | |
682 if (regs[i]) { | |
683 if(!regv_l(i) && !regv_h(i)) { | |
684 regs[i]=0; | |
685 // printf("## cleanup lreg 0 %d\n",i); | |
686 } else if(!regs[regv_l(i)] && !regs[regv_h(i)]) { | |
687 free_register(i); | |
688 // printf("## cleanup lreg 1 %d\n",i); | |
689 } | |
690 } | |
691 } | |
692 #endif | |
693 } | |
694 | |
207 | 695 int |
205 | 696 get_lregister() |
697 { | |
207 | 698 int h,l,i; |
699 i = get_lregister0(); | |
700 if (i==-1) return -1; | |
220 | 701 h = get_register(); |
702 if (h==-1) return -1; | |
703 regv_h(i) = h; | |
704 l = get_register(); | |
530 | 705 if (l==-1) { free_register(h); free_register(i); return -1; } |
220 | 706 regv_l(i) = l; |
707 regs[i]=USING_REG; | |
530 | 708 // printf("## get_lregister %d %s %s\n",i, lregister_name_high(i), lregister_name_low(i)); |
220 | 709 return i; |
205 | 710 } |
711 | |
712 int | |
195 | 713 get_lregister_var(NMTBL *n) |
714 { | |
207 | 715 int i,j,ll; |
206 | 716 int max_reg_var_save=max_reg_var; |
207 | 717 ll = get_lregister0(); |
255 | 718 if (ll==-1) goto not_found; |
207 | 719 if (regs[ll]==0) { |
720 for(i=0;i<REG_VAR_BASE-REG_VAR_MIN;i++) { | |
721 if (! regs[REG_VAR_BASE-i]) { /* �Ȥ��Ƥ��ʤ��ʤ� */ | |
722 /* ���Υ쥸������Ȥ����Ȥ������ */ | |
723 regs[REG_VAR_BASE-i]=USING_REG; | |
724 if (i>max_reg_var) max_reg_var=i; | |
725 for(j=0;j<REG_VAR_BASE-REG_VAR_MIN;j++) { | |
726 if (! regs[REG_VAR_BASE-j]) { | |
727 /* �Ȥ��Ƥ��ʤ��ʤ� */ | |
728 /* ���Υ쥸������Ȥ����Ȥ������ */ | |
729 regs[REG_VAR_BASE-j]=USING_REG; | |
730 if (j>max_reg_var) max_reg_var=j; | |
731 /* ���ξ���ɽ���ֹ���֤� */ | |
228 | 732 regs[ll]=USING_REG; |
207 | 733 regv_l(ll) = REG_VAR_BASE-j; |
734 regv_h(ll) = REG_VAR_BASE-i; | |
735 return list3(LREGISTER,ll,(int)n); | |
736 } | |
206 | 737 } |
207 | 738 /* �ҤȤĤ����ʤ��ä� */ |
739 regs[REG_VAR_BASE-i]=0; | |
740 max_reg_var=max_reg_var_save; | |
741 goto not_found; | |
206 | 742 } |
743 } | |
744 } | |
207 | 745 not_found: |
445 | 746 return list3(LVAR,new_lvar(SIZE_OF_LONGLONG),0); |
195 | 747 } |
96 | 748 |
93 | 749 void |
750 emit_pop_free(int xreg) | |
751 { | |
103 | 752 if (xreg>=0) |
753 free_register(xreg); | |
93 | 754 } |
755 | |
211 | 756 void |
757 | |
89 | 758 free_register(int i) { /* ����ʤ��ʤä��쥸�������� */ |
468 | 759 // printf("## free_register %d\n",i); |
207 | 760 if (is_longlong_reg(i)) { |
761 regs[regv_l(i)]=0; | |
762 regs[regv_h(i)]=0; | |
530 | 763 //regv_l(i)=0; will erase input register... |
226 | 764 //regv_h(i)=0; |
206 | 765 } |
530 | 766 regs[i]=0; |
96 | 767 } |
768 | |
341 | 769 extern void |
770 use_ptr_cache(int r) | |
771 { | |
772 regs[r]=PTRC_REG; | |
773 } | |
774 | |
89 | 775 int |
138 | 776 get_input_dregister_var(int i,NMTBL *n,int is_code,int d) |
99 | 777 { |
126 | 778 if (is_code) { |
148 | 779 if(!(i<FREG_VAR_BASE-FREG_VAR_MIN)) return 0; |
780 i = FREG_VAR_BASE-i+FREG_OFFSET; | |
126 | 781 } else { |
135 | 782 if (i<0||i>=MAX_INPUT_DREGISTER_VAR) return 0; |
145 | 783 i = i+MIN_TMP_FREG+FREG_OFFSET; |
126 | 784 } |
207 | 785 return list3(DREGISTER,i,(int)n); |
205 | 786 } |
787 | |
788 int | |
789 get_input_lregister_var(int i,NMTBL *n,int is_code) | |
790 { | |
207 | 791 int ll; |
792 if (i!=-1) { | |
793 if (is_code) { | |
227 | 794 if(!(i<REG_VAR_BASE-REG_VAR_MIN)) return 0; |
207 | 795 i = REG_VAR_BASE-i; |
796 } else { | |
227 | 797 if (i<0||i>=MAX_INPUT_REGISTER_VAR) return 0; |
207 | 798 i = i+MIN_TMP_REG; |
799 } | |
530 | 800 ll = get_lregister1(i,i+1); |
411 | 801 #if ENDIAN_L==0 |
802 regv_l(ll)=i; | |
803 regv_h(ll)=i+1; | |
804 #else | |
222 | 805 regv_h(ll)=i; |
806 regv_l(ll)=i+1; | |
411 | 807 #endif |
207 | 808 } else { error(-1); ll=LREG_OFFSET+2; } |
809 return list3(LREGISTER,ll,(int)n); | |
99 | 810 } |
811 | |
812 int | |
126 | 813 get_input_register_var(int i,NMTBL *n,int is_code) |
99 | 814 { |
126 | 815 if (is_code) { |
131 | 816 if(!(i<REG_VAR_BASE-REG_VAR_MIN)) return 0; |
126 | 817 i = REG_VAR_BASE-i; |
818 } else { | |
135 | 819 if (i<0||i>=MAX_INPUT_REGISTER_VAR) return 0; |
820 i = i+MIN_TMP_REG; | |
821 } | |
207 | 822 return list3(REGISTER,i,(int)n); |
135 | 823 } |
824 | |
145 | 825 /* double register case? */ |
826 | |
135 | 827 int |
828 get_input_register_var_1(int i,NMTBL *n,int is_code) | |
829 { | |
830 if (is_code) { | |
831 if(!(i<REG_VAR_BASE-REG_VAR_MIN)) return 0; | |
832 i = REG_VAR_BASE-i; | |
833 } else { | |
834 if (i<0||i>=MAX_INPUT_REGISTER_VAR+1) return 0; | |
126 | 835 i = i+MIN_TMP_REG; |
836 } | |
207 | 837 return list3(REGISTER,i,(int)n); |
99 | 838 } |
839 | |
840 int | |
137 | 841 free_register_count(int d) |
103 | 842 { |
843 int i,count,fcount; | |
844 fcount = count = 0; | |
845 for(i=0;i<MAX_REGISTER;i++) { | |
205 | 846 if (! regs[i]) count++; |
103 | 847 } |
848 for(i=0;i<MAX_FREGISTER;i++) { | |
205 | 849 if (! regs[i+FREG_OFFSET]) fcount++; |
103 | 850 } |
468 | 851 printf("## free reg %d freg %d\n",count,fcount); |
137 | 852 return d?fcount:count; |
103 | 853 } |
854 | |
205 | 855 #if 0 |
856 static int | |
89 | 857 register_full(void) |
858 { | |
859 int i; | |
860 for(i=0;i<MAX_REGISTER;i++) { | |
861 if (! regs[i]) { | |
862 return 0; | |
863 } | |
864 } | |
865 return 1; | |
866 } | |
205 | 867 #endif |
89 | 868 |
869 void | |
870 free_all_register(void) | |
871 { | |
872 int i; | |
468 | 873 // printf("## free_all register\n"); |
206 | 874 #if LONGLONG_CODE |
226 | 875 for(i=0;i<REAL_MAX_LREGISTER;i++) { |
876 regs[i+LREG_OFFSET]=0; | |
877 regv_l(i+LREG_OFFSET) = 0; | |
878 regv_h(i+LREG_OFFSET) = 0; | |
879 } | |
206 | 880 lreg = 0; |
222 | 881 // set_lreg(LREG_LREGISTER,0); |
206 | 882 #endif |
205 | 883 for(i=0;i<MAX_REGISTER;i++) { regs[i]=0; } |
884 for(i=0;i<MAX_FREGISTER;i++) { regs[i+FREG_OFFSET]=0; } | |
195 | 885 #if FLOAT_CODE |
138 | 886 freg = get_dregister(1); |
195 | 887 set_freg(FREG_FREGISTER,0); |
888 #endif | |
889 ireg = creg = get_register(); | |
207 | 890 set_ireg(CREG_REGISTER,0); |
89 | 891 return; |
892 } | |
893 | |
345 | 894 extern int |
895 code_register_overlap(int s,int t) | |
896 { | |
897 switch(car(s)) { | |
898 case REGISTER: | |
899 switch(car(t)) { | |
900 case DREGISTER: case FREGISTER: break; | |
901 case REGISTER: | |
902 if(cadr(s)==cadr(t)) return 1; | |
903 break; | |
904 case LREGISTER: | |
905 if(cadr(s)==regv_l(cadr(t))) return 1; | |
906 if(cadr(s)==regv_h(cadr(t))) return 1; | |
907 break; | |
908 } | |
909 break; | |
910 case DREGISTER: | |
911 case FREGISTER: | |
912 switch(car(t)) { | |
913 case REGISTER: case LREGISTER: break; | |
914 case DREGISTER: case FREGISTER: | |
915 if(cadr(s)==cadr(t)) return 1; | |
916 break; | |
917 } | |
918 break; | |
919 case LREGISTER: | |
920 switch(car(t)) { | |
921 case DREGISTER: case FREGISTER: break; | |
922 case REGISTER: | |
923 if(cadr(t)==regv_l(cadr(s))) return 1; | |
924 if(cadr(t)==regv_h(cadr(s))) return 1; | |
925 break; | |
926 case LREGISTER: | |
927 if(regv_l(cadr(t))==regv_l(cadr(s))) return 1; | |
928 if(regv_l(cadr(t))==regv_h(cadr(s))) return 1; | |
929 if(regv_h(cadr(t))==regv_l(cadr(s))) return 1; | |
930 if(regv_h(cadr(t))==regv_h(cadr(s))) return 1; | |
931 break; | |
932 } | |
933 break; | |
934 } | |
935 return 0; | |
936 } | |
937 | |
531 | 938 // int lreg_count; |
530 | 939 |
89 | 940 void |
941 register_usage(char *s) | |
942 { | |
207 | 943 #if 1 |
273 | 944 int i,j; |
945 #endif | |
946 #define USAGE_MAX 4 | |
947 if (!lsrc) return; | |
467 | 948 printf("## %d: %s:",lineno,s); |
273 | 949 if (ireg) printf(" creg=%s",register_name(ireg)); |
950 if (freg) printf(" freg=%s",fregister_name(freg)); | |
951 if (lreg) printf(" lreg=%s,%s",lregister_name_high(lreg), | |
952 lregister_name_low(lreg)); | |
953 #if 1 | |
954 for(j=0,i=0;i<MAX_REGISTER;i++) if (regs[i]) j++; | |
955 if (j>USAGE_MAX) { | |
530 | 956 printf("\n## regs(%d):",j); |
273 | 957 for(i=0;i<MAX_REGISTER;i++) { printf("%d",regs[i]); } |
958 } | |
959 if (reg_sp>0) { | |
960 printf(" stack "); | |
961 for(i=reg_sp;i>0;i--) { | |
962 if(reg_stack[i-1]>=0) { | |
963 printf(" %s",register_name(reg_stack[i-1])); | |
964 } else | |
965 printf(",%d",reg_stack[i-1]); | |
966 } | |
967 } | |
968 for(j=0,i=0;i<MAX_FREGISTER;i++) if (regs[i+FREG_OFFSET]) j++; | |
969 if (j>USAGE_MAX) { | |
530 | 970 printf("\n## freg(%d):",j); |
273 | 971 for(i=0;i<MAX_FREGISTER;i++) { printf("%d",regs[i+FREG_OFFSET]); } |
972 } | |
973 if (freg_sp>0) { | |
974 printf(" fstack "); | |
975 for(i=freg_sp;i>0;i--) { | |
976 if(freg_stack[i-1]>=0) { | |
977 printf(" %s",fregister_name(freg_stack[i-1])); | |
978 } else | |
979 printf(",%d",freg_stack[i-1]); | |
980 } | |
981 } | |
982 | |
983 for(j=0,i=0;i<REAL_MAX_LREGISTER;i++) if (regs[i+LREG_OFFSET]) j++; | |
531 | 984 // lreg_count = j; |
273 | 985 if (j>USAGE_MAX) { |
530 | 986 printf("\n## lreg(%d):",j); |
273 | 987 for(i=0;i<REAL_MAX_LREGISTER;i++) { printf("%d",regs[i+LREG_OFFSET]); } |
530 | 988 #if 0 |
989 for(i=0;i<REAL_MAX_LREGISTER;i++) { | |
990 if (regs[i+LREG_OFFSET] && regv_l(i+LREG_OFFSET)) | |
991 printf(" %s-%s", lregister_name_high(i+LREG_OFFSET),lregister_name_low(i+LREG_OFFSET)); | |
992 else if (regv_l(i+LREG_OFFSET)) | |
993 printf(" *%s-%s", lregister_name_high(i+LREG_OFFSET),lregister_name_low(i+LREG_OFFSET)); | |
994 } | |
995 #endif | |
273 | 996 } |
997 if (lreg_sp>0) { | |
998 printf(" lstack "); | |
999 for(i=lreg_sp;i>0;i--) { | |
1000 if(lreg_stack[i-1]>=0) { | |
1001 printf(" %s",lregister_name_high(lreg_stack[i-1])); | |
1002 printf(",%s",lregister_name_low(lreg_stack[i-1])); | |
1003 } else | |
1004 printf(",%d",lreg_stack[i-1]); | |
1005 } | |
1006 } | |
1007 #endif | |
1008 printf("\n"); | |
1009 } | |
1010 | |
211 | 1011 void |
1012 | |
89 | 1013 gexpr_init(void) |
1014 { | |
1015 while(reg_sp > 0) { | |
292 | 1016 error(-1); |
89 | 1017 free_register(reg_stack[--reg_sp]); |
1018 } | |
148 | 1019 while(freg_sp > 0) { |
292 | 1020 error(-1); |
148 | 1021 free_register(freg_stack[--freg_sp]); |
1022 } | |
206 | 1023 while(lreg_sp > 0) { |
292 | 1024 error(-1); |
206 | 1025 free_register(lreg_stack[--lreg_sp]); |
1026 } | |
221 | 1027 use_int0(); |
516 | 1028 text_mode(0); |
89 | 1029 gexpr_code_init(); |
1030 register_usage("gexpr_init"); | |
1031 } | |
1032 | |
1033 | |
211 | 1034 void |
1035 | |
89 | 1036 emit_init(void) |
1037 { | |
327 | 1038 /* called before each declaration */ |
1039 | |
89 | 1040 free_all_register(); |
110 | 1041 max_reg_var=-1; max_freg_var=-1; |
89 | 1042 reg_sp = 0; |
123 | 1043 freg_sp = 0; |
89 | 1044 } |
1045 | |
97 | 1046 |
89 | 1047 int |
105 | 1048 get_register_var(NMTBL *n) |
89 | 1049 { |
1050 int i; | |
99 | 1051 for(i=0;i<REG_VAR_BASE-REG_VAR_MIN;i++) { |
137 | 1052 if (! regs[REG_VAR_BASE-i]) { /* �Ȥ��Ƥ��ʤ��ʤ� */ |
1053 /* ���Υ쥸������Ȥ����Ȥ������ */ | |
1054 regs[REG_VAR_BASE-i]=USING_REG; | |
97 | 1055 if (i>max_reg_var) max_reg_var=i; |
122 | 1056 /* ���ξ���ɽ���ֹ���֤� */ |
207 | 1057 return list3(REGISTER,REG_VAR_BASE-i,(int)n); |
137 | 1058 } |
96 | 1059 } |
445 | 1060 return list3(LVAR,new_lvar(SIZE_OF_INT),0); |
96 | 1061 } |
1062 | |
1063 int | |
138 | 1064 get_dregister_var(NMTBL *n,int d) |
96 | 1065 { |
1066 int i; | |
148 | 1067 for(i=0;i<FREG_VAR_BASE-FREG_VAR_MIN;i++) { |
145 | 1068 if (! regs[FREG_VAR_BASE-i+FREG_OFFSET]) { /* �Ȥ��Ƥ��ʤ��ʤ� */ |
1069 regs[FREG_VAR_BASE-i+FREG_OFFSET]=USING_REG; /*���Υ쥸������Ȥ����Ȥ������*/ | |
97 | 1070 if (i>max_freg_var) max_freg_var=i; |
122 | 1071 /* ���ξ���ɽ���ֹ���֤� */ |
206 | 1072 return list3(DREGISTER, |
207 | 1073 FREG_VAR_BASE-i+FREG_OFFSET,(int)n); |
89 | 1074 } |
1075 } | |
445 | 1076 return list3(LVAR,new_lvar(SIZE_OF_DOUBLE),0); |
89 | 1077 } |
1078 | |
426 | 1079 int |
107 | 1080 emit_push() |
89 | 1081 { |
426 | 1082 int new_reg,old=creg; |
221 | 1083 if (!is_int_reg(creg)) error(-1); |
102 | 1084 if (reg_sp>MAX_MAX) error(-1); |
221 | 1085 new_reg = get_register(); /* ���Ф˼��� */ |
97 | 1086 reg_stack[reg_sp++] = creg; /* push ���뤫���˥쥸������Ȥ� */ |
147 | 1087 ireg = creg = new_reg; |
426 | 1088 return old; |
89 | 1089 } |
1090 | |
1091 int | |
93 | 1092 emit_pop(int type) |
89 | 1093 { |
112 | 1094 int xreg,reg; |
97 | 1095 xreg=pop_register(); |
1096 if (xreg<= -REG_LVAR_OFFSET) { | |
112 | 1097 reg = get_register(); |
119 | 1098 code_rlvar(REG_LVAR_OFFSET+xreg,reg); |
117 | 1099 free_lvar(REG_LVAR_OFFSET+xreg); |
112 | 1100 xreg = reg; |
97 | 1101 } |
89 | 1102 return xreg; |
1103 } | |
1104 | |
100
a9e6f2a2946f
Wrote all code for PowerPC and no compile error. Let's fix all bugs...
kono
parents:
99
diff
changeset
|
1105 static int code_base; |
89 | 1106 |
341 | 1107 extern void |
1108 code_ptr_cache_def(int r,NMTBL *nptr) | |
89 | 1109 { |
341 | 1110 char *rrn = register_name(r); |
109 | 1111 if (nptr->sc==STATIC) { |
1112 printf("\taddis %s,r31,ha16(_%s-L_%d)\n", | |
1113 rrn,nptr->nm,code_base); | |
1114 printf("\tla %s,lo16(_%s-L_%d)(%s)\n", | |
1115 rrn,nptr->nm,code_base,rrn); | |
1116 } else { | |
1117 printf("\taddis %s,r31,ha16(L_%s$non_lazy_ptr-L_%d)\n", | |
1118 rrn,nptr->nm,code_base); | |
1119 printf("\tlwz %s,lo16(L_%s$non_lazy_ptr-L_%d)(%s)\n", | |
1120 rrn,nptr->nm,code_base,rrn); | |
1121 } | |
89 | 1122 } |
1123 | |
245 | 1124 static char *cload(int sz) { return sz==1?"lbz":sz==SIZE_OF_SHORT?"lhz":"lwz"; } |
1125 static char *cstore(int sz) { return sz==1?"stb":sz==SIZE_OF_SHORT?"sth":"stw"; } | |
230 | 1126 |
1127 static void | |
1128 cext(int sign,int sz,int reg) | |
1129 { | |
1130 char *crn = register_name(reg); | |
1131 if (sign) { | |
1132 if (sz==1) | |
1133 printf("\textsb %s,%s\n",crn,crn); | |
245 | 1134 else if (sz==SIZE_OF_SHORT) |
230 | 1135 printf("\textsh %s,%s\n",crn,crn); |
1136 } else { | |
1137 if (sz==1) | |
1138 printf("\trlwinm %s,%s,0,0xff\n",crn,crn); | |
245 | 1139 else if (sz==SIZE_OF_SHORT) |
230 | 1140 printf("\trlwinm %s,%s,0,0xffff\n",crn,crn); |
1141 } | |
1142 } | |
1143 | |
168 | 1144 |
89 | 1145 void |
92 | 1146 code_label(int labelno) |
1147 { | |
1148 clear_ptr_cache(); | |
102 | 1149 printf("L_%d:\n",labelno); |
92 | 1150 } |
1151 | |
367 | 1152 static void |
1153 code_add(int reg,int offset,int r) | |
1154 { | |
1155 char *crn = register_name(reg); | |
1156 char *rrn = register_name(r); | |
1157 if (offset==0) { | |
1158 if(r!=reg) | |
1159 printf("\tmr %s,%s\n",crn,rrn); | |
375 | 1160 } else if (LARGE_OFFSET(offset)) { |
367 | 1161 printf("\tla %s,ha16(%d)(%s)\n",crn,offset,rrn); |
1162 printf("\taddi %s,%s,lo16(%d)\n",crn,crn,offset); | |
1163 } else | |
1164 printf("\taddi %s,%s,%d\n",crn,rrn,offset); | |
1165 } | |
1166 | |
1167 static void | |
1168 code_ld(char *ld,int reg,int offset,int r) | |
1169 { | |
1170 char *crn = register_name(reg); | |
1171 char *rrn = register_name(r); | |
375 | 1172 if (LARGE_OFFSET(offset)) { |
367 | 1173 printf("\tla %s,ha16(%d)(%s)\n",crn,offset,rrn); |
1174 printf("\t%s %s,%s,lo16(%d)\n",ld,crn,crn,offset); | |
1175 } else | |
1176 printf("\t%s %s,%d(%s)\n",ld,crn,offset,rrn); | |
1177 } | |
1178 | |
1179 static void | |
1180 code_ldf(char *ld,char *crn,int offset,int r) | |
1181 { | |
1182 char *rrn = register_name(r); | |
1183 int reg; | |
1184 char *lrn; | |
1185 if (offset<-32768||32767<offset) { | |
1186 lrn = register_name(reg = get_register()); | |
1187 printf("\tla %s,ha16(%d)(%s)\n",lrn,offset,rrn); | |
1188 printf("\t%s %s,%s,lo16(%d)\n",ld,crn,lrn,offset); | |
1189 free_register(reg); | |
1190 } else | |
1191 printf("\t%s %s,%d(%s)\n",ld,crn,offset,rrn); | |
1192 } | |
1193 | |
92 | 1194 void |
221 | 1195 code_gvar(int e1,int reg) { |
1196 use_int(reg); | |
367 | 1197 code_add(reg,cadr(e1),get_ptr_cache((NMTBL*)caddr(e1))); |
89 | 1198 return; |
1199 } | |
1200 | |
1201 void | |
221 | 1202 code_rgvar(int e1,int reg) { |
1203 use_int(reg); | |
367 | 1204 code_ld("lwz",reg,cadr(e1),get_ptr_cache((NMTBL*)caddr(e1))); |
89 | 1205 } |
1206 | |
1207 void | |
221 | 1208 code_crgvar(int e1,int reg,int sign,int sz){ |
1209 use_int(reg); | |
367 | 1210 code_ld(cload(sz),reg,cadr(e1),get_ptr_cache((NMTBL*)caddr(e1))); |
230 | 1211 cext(sign,sz,reg); |
89 | 1212 } |
1213 | |
165 | 1214 |
1215 | |
89 | 1216 void |
221 | 1217 code_register(int e2,int reg) { |
1218 use_int(reg); | |
1219 if (reg!=e2) | |
1220 printf("\tmr %s,%s\n",register_name(reg),register_name(e2)); | |
89 | 1221 } |
1222 | |
353 | 1223 extern void |
1224 code_i2c(int reg) | |
1225 { | |
1226 use_int(reg); | |
1227 cext(1,1,reg); | |
1228 } | |
1229 | |
1230 extern void | |
1231 code_i2s(int reg) | |
1232 { | |
1233 use_int(reg); | |
1234 cext(1,SIZE_OF_SHORT,reg); | |
1235 } | |
1236 | |
1237 extern void | |
1238 code_u2uc(int reg) | |
1239 { | |
1240 use_int(reg); | |
1241 cext(0,1,reg); | |
1242 } | |
1243 | |
1244 extern void | |
1245 code_u2us(int reg) | |
1246 { | |
1247 use_int(reg); | |
1248 cext(0,SIZE_OF_SHORT,reg); | |
1249 } | |
89 | 1250 |
1251 void | |
95 | 1252 code_rlvar(int e2,int reg) { |
221 | 1253 use_int(reg); |
119 | 1254 lvar_intro(e2); |
1255 printf("\tlwz %s,",register_name(reg)); | |
1256 lvar(e2); | |
89 | 1257 } |
1258 | |
1259 void | |
165 | 1260 code_crlvar(int e2,int reg,int sign,int sz) { |
221 | 1261 use_int(reg); |
119 | 1262 lvar_intro(e2); |
165 | 1263 printf("\t%s %s,",cload(sz),register_name(reg)); |
119 | 1264 lvar(e2); |
230 | 1265 cext(sign,sz,reg); |
89 | 1266 } |
1267 | |
1268 void | |
221 | 1269 code_fname(NMTBL *n,int reg) { |
89 | 1270 int r; |
221 | 1271 use_int(reg); |
109 | 1272 r = get_ptr_cache(n); |
221 | 1273 if(r!=reg) |
1274 printf("\tmr %s,%s\n",register_name(reg),register_name(r)); | |
89 | 1275 return; |
1276 } | |
1277 | |
363 | 1278 void |
1279 code_label_value(int label,int reg) { | |
1280 char *crn; | |
1281 use_int(reg); | |
1282 crn = register_name(reg); | |
1283 printf("\taddis %s,r31,ha16(L_%d-L_%d)\n",crn,label,code_base); | |
1284 printf("\tla %s,lo16(L_%d-L_%d)(%s)\n",crn,label,code_base,crn); | |
1285 return; | |
1286 } | |
89 | 1287 |
1288 void | |
221 | 1289 code_const(int e2,int reg) { |
1290 char *crn; | |
1291 use_int(reg); | |
1292 crn = register_name(reg); | |
527 | 1293 // printf("## 0x%08x\n",e2); |
89 | 1294 if (-32768<e2&&e2<32768) |
1295 printf("\tli %s,%d\n",crn,e2); | |
1296 else { | |
1297 printf("\tlis %s,ha16(%d)\n",crn,e2); | |
1298 printf("\taddi %s,%s,lo16(%d)\n",crn,crn,e2); | |
1299 } | |
1300 } | |
1301 | |
1302 | |
1303 void | |
107 | 1304 code_neg(int creg) { |
221 | 1305 use_int(creg); |
93 | 1306 printf("\tneg %s,%s\n", register_name(creg), register_name(creg)); |
89 | 1307 } |
1308 | |
1309 | |
1310 void | |
107 | 1311 code_not(int creg) { |
221 | 1312 use_int(creg); |
89 | 1313 printf("\tnor %s,%s,%s\n", |
1314 register_name(creg), register_name(creg),register_name(creg)); | |
1315 } | |
1316 | |
1317 | |
1318 void | |
107 | 1319 code_lnot(int creg) { |
221 | 1320 use_int(creg); |
89 | 1321 printf("\tsubfic r0,%s,0\n", register_name(creg)); |
1322 printf("\tadde %s,r0,%s\n", register_name(creg),register_name(creg)); | |
1323 } | |
1324 | |
1325 void | |
168 | 1326 code_preinc(int e1,int e2,int dir,int sign,int sz,int reg) { |
89 | 1327 char *xrn,*drn; |
1328 if (car(e2)==REGISTER) { | |
221 | 1329 use_int(reg); |
95 | 1330 printf("\taddi %s,%s,%d\n", |
168 | 1331 register_name(cadr(e2)),register_name(cadr(e2)), dir); |
273 | 1332 if (cadr(e2)!=reg) |
1333 printf("\tmr %s,%s\n",register_name(reg),register_name(cadr(e2))); | |
89 | 1334 return; |
1335 } | |
1336 g_expr(e2); | |
221 | 1337 if (!is_int_reg(creg)) error(-1); |
89 | 1338 xrn = register_name(creg); |
221 | 1339 if (reg==USE_CREG) { |
231 | 1340 reg=get_register(); if (!reg) error(-1); |
1341 drn = register_name(reg); | |
1342 set_ireg(reg,0); | |
221 | 1343 } else { |
1344 drn = register_name(reg); | |
1345 } | |
168 | 1346 printf("\t%s %s,0(%s)\n",cload(sz),drn,xrn); |
231 | 1347 if (use) cext(sign,sz,reg); |
168 | 1348 printf("\taddi %s,%s,%d\n",drn,drn,dir); |
1349 printf("\t%s %s,0(%s)\n",cstore(sz),drn,xrn); | |
89 | 1350 } |
1351 | |
1352 | |
1353 void | |
168 | 1354 code_postinc(int e1,int e2,int dir,int sign,int sz,int reg) { |
89 | 1355 char *xrn,*crn,*nrn; |
231 | 1356 int nreg; |
89 | 1357 if (car(e2)==REGISTER) { |
221 | 1358 use_int(reg); |
107 | 1359 printf("\tmr %s,%s\n",register_name(reg),register_name(cadr(e2))); |
89 | 1360 printf("\taddi %s,%s,%d\n", |
168 | 1361 register_name(cadr(e2)),register_name(cadr(e2)),dir); |
89 | 1362 return; |
1363 } | |
1364 g_expr(e2); | |
221 | 1365 if (!is_int_reg(creg)) error(-1); |
89 | 1366 crn = register_name(creg); |
1367 nreg=get_register(); if (!nreg) error(-1); | |
1368 nrn = register_name(nreg); | |
221 | 1369 if (reg==USE_CREG) { |
231 | 1370 reg=get_register(); if (!reg) error(-1); |
1371 xrn = register_name(reg); | |
1372 set_ireg(reg,0); | |
221 | 1373 } else { |
1374 xrn = register_name(reg); | |
1375 } | |
168 | 1376 printf("\t%s %s,0(%s)\n",cload(sz),xrn,crn); |
230 | 1377 if (use) cext(sign,sz,reg); |
168 | 1378 printf("\taddi %s,%s,%d\n",nrn,xrn,dir); |
1379 printf("\t%s %s,0(%s)\n",cstore(sz),nrn,crn); | |
89 | 1380 free_register(nreg); |
1381 } | |
1382 | |
1383 | |
1384 void | |
107 | 1385 code_return(int creg) { |
221 | 1386 char *crn; |
1387 use_int(creg); | |
1388 crn = register_name(creg); | |
102 | 1389 printf("\taddis %s,r31,ha16(L_%d-L_%d)\n",crn,retcont,code_base); |
1390 printf("\tla %s,lo16(L_%d-L_%d)(%s)\n",crn,retcont,code_base,crn); | |
89 | 1391 } |
1392 | |
128 | 1393 #define R1SAVE 1 |
89 | 1394 |
1395 void | |
107 | 1396 code_environment(int creg) { |
126 | 1397 /* save frame pointer */ |
221 | 1398 use_int(creg); |
128 | 1399 #if R1SAVE |
1400 printf("\tlwz %s,0(r1)\n",register_name(creg)); | |
1401 #else | |
1402 int l = 0; | |
1403 printf("\tla %s,",register_name(creg)); | |
1404 printf("lo16(%d+L_%d)(r30)\n",FUNC_LVAR,lvar_offset_label); | |
1405 #endif | |
89 | 1406 } |
1407 | |
288 | 1408 static int rexpr_bool(int e1,int reg); |
1409 | |
1410 #if FLOAT_CODE | |
1411 static int drexpr_bool(int e1,int reg); | |
1412 #endif | |
1413 | |
1414 #if LONGLONG_CODE | |
1415 static int lrexpr_bool(int e1,int reg) | |
1416 { | |
1417 return 0; | |
1418 } | |
1419 #endif | |
1420 | |
1421 | |
1422 | |
89 | 1423 void |
221 | 1424 code_bool(int e1,int reg) { |
89 | 1425 char *xrn; |
1426 int e2,e3; | |
288 | 1427 |
1428 if (rexpr_bool(e1,reg)) return; | |
1429 #if FLOAT_CODE | |
1430 else if (drexpr_bool(e1,reg)) return; | |
1431 #endif | |
1432 #if LONGLONG_CODE | |
1433 else if (lrexpr_bool(e1,reg)) return; | |
1434 #endif | |
1435 | |
89 | 1436 b_expr(e1,1,e2=fwdlabel(),1); /* including > < ... */ |
289 | 1437 if (use) { |
1438 use_int(reg); | |
1439 xrn = register_name(reg); | |
1440 printf("\tli %s,0\n",xrn); | |
1441 jmp(e3=fwdlabel()); | |
1442 fwddef(e2); | |
1443 printf("\tli %s,1\n",xrn); | |
1444 fwddef(e3); | |
1445 } else { | |
1446 fwddef(e2); | |
1447 } | |
89 | 1448 } |
1449 | |
433 | 1450 #define code_gt(cond) (cond?"gt":"le") |
1451 | |
1452 #define code_ugt(cond) (cond?"gt":"le") | |
1453 | |
1454 #define code_ge(cond) (cond?"ge":"lt") | |
1455 | |
1456 #define code_uge(cond) (cond?"ge":"lt") | |
1457 | |
1458 #define code_eq(cond) (cond?"eq":"ne") | |
89 | 1459 |
280 | 1460 static int cmpflag = 0; |
1461 | |
1462 static void | |
1463 inc_cmpflag() | |
1464 { | |
291 | 1465 cmpflag = (cmpflag+1)%8; |
280 | 1466 } |
1467 | |
89 | 1468 void |
287 | 1469 code_cmp_crgvar(int e1,int reg,int sz,int label,int cond) { |
221 | 1470 use_int(reg); |
367 | 1471 code_ld(cload(sz),reg,cadr(e1),get_ptr_cache((NMTBL*)caddr(e1))); |
432 | 1472 cext(0,sz,reg); |
291 | 1473 inc_cmpflag(); |
367 | 1474 printf("\tcmpwi cr%d,%s,0\n",cmpflag,register_name(reg)); |
287 | 1475 jcond(label,cond); |
89 | 1476 } |
1477 | |
1478 | |
1479 void | |
287 | 1480 code_cmp_crlvar(int e2,int reg, int sz,int label,int cond) { |
221 | 1481 char *crn; |
1482 use_int(reg); | |
1483 crn = register_name(reg); | |
119 | 1484 lvar_intro(e2); |
167 | 1485 printf("\t%s %s,",cload(sz),crn); |
160 | 1486 lvar(e2); |
230 | 1487 cext(0,sz,reg); |
287 | 1488 code_cmp_register(reg,label,cond); |
160 | 1489 } |
1490 | |
89 | 1491 |
1492 void | |
287 | 1493 code_cmp_rgvar(int e1,int reg,int label,int cond) { |
221 | 1494 use_int(reg); |
367 | 1495 code_ld("lwz",reg,cadr(e1),get_ptr_cache((NMTBL*)caddr(e1))); |
287 | 1496 code_cmp_register(reg,label,cond); |
89 | 1497 } |
1498 | |
1499 | |
1500 void | |
287 | 1501 code_cmp_rlvar(int e2,int reg,int label,int cond) { |
221 | 1502 char *crn; |
1503 use_int(reg); | |
1504 crn = register_name(reg); | |
119 | 1505 lvar_intro(e2); |
1506 printf("\tlwz %s,",crn); | |
1507 lvar(e2); | |
287 | 1508 code_cmp_register(reg,label,cond); |
89 | 1509 } |
1510 | |
1511 | |
1512 void | |
287 | 1513 code_cmp_register(int e2,int label,int cond) { |
221 | 1514 use_int(e2); |
291 | 1515 inc_cmpflag(); |
280 | 1516 printf("\tcmpwi cr%d,%s,0\n",cmpflag,register_name(e2)); |
287 | 1517 jcond(label,cond); |
89 | 1518 } |
1519 | |
1520 | |
1521 void | |
107 | 1522 code_string(int e1,int creg) |
89 | 1523 { |
95 | 1524 int lb; |
319 | 1525 char *crn; |
221 | 1526 |
1527 use_int(creg); | |
1528 crn = register_name(creg); | |
319 | 1529 lb = emit_string_label(); |
1530 ascii((char *)cadr(e1)); | |
89 | 1531 if (output_mode==TEXT_EMIT_MODE) { |
1532 printf(".text\n"); | |
1533 } else { | |
516 | 1534 text_mode(0); |
89 | 1535 } |
102 | 1536 printf("\taddis %s,r31,ha16(L_%d-L_%d)\n",crn,lb,code_base); |
1537 printf("\tla %s,lo16(L_%d-L_%d)(%s)\n",crn,lb,code_base,crn); | |
89 | 1538 } |
1539 | |
1540 #define MAX_COPY_LEN 20 | |
417 | 1541 // #define MAX_COPY_LEN 10 |
89 | 1542 |
211 | 1543 void |
89 | 1544 emit_copy(int from,int to,int length,int offset,int value,int det) |
1545 { | |
221 | 1546 char *frn; |
1547 char *trn; | |
89 | 1548 char *drn; |
1549 int fix = 0; | |
125 | 1550 char *memmove = "memmove"; |
95 | 1551 int dreg = get_register(); if (!dreg) error(-1); |
221 | 1552 |
89 | 1553 drn = register_name(dreg); |
221 | 1554 use_int(from); |
1555 use_int(to); | |
1556 frn = register_name(from); | |
1557 trn = register_name(to); | |
89 | 1558 |
1559 /* length <0 means upward direction copy */ | |
1560 switch (length) { | |
1561 case 0: break; | |
1562 case 1: case -1: | |
1563 printf("\tlbz %s,%d(%s)\n",drn,offset,frn); | |
1564 printf("\tstb %s,%d(%s)\n",drn,offset,trn); | |
1565 break; | |
1566 case 2: case -2: | |
1567 printf("\tlhz %s,%d(%s)\n",drn,offset,frn); | |
1568 printf("\tsth %s,%d(%s)\n",drn,offset,trn); | |
1569 break; | |
1570 case 4: case -4: | |
1571 printf("\tlwz %s,%d(%s)\n",drn,offset,frn); | |
1572 printf("\tstw %s,%d(%s)\n",drn,offset,trn); | |
1573 break; | |
1574 default: | |
258
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1575 if (length <0) { |
416 | 1576 if (length >= -MAX_COPY_LEN) { |
258
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1577 for(;length<=-4;length+=4,offset-=4) |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1578 emit_copy(from,to,-4,offset-4,0,det); |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1579 for(;length<=-2;length+=2,offset-=2) |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1580 emit_copy(from,to,-2,offset-2,0,det); |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1581 if(length<0) |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1582 emit_copy(from,to,length,offset-1,0,det); |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1583 break; |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1584 } |
89 | 1585 } else if (length <=MAX_COPY_LEN) { |
1586 for(;length>=4;length-=4,offset+=4) | |
1587 emit_copy(from,to,4,offset,0,det); | |
1588 for(;length>=2;length-=2,offset+=2) | |
1589 emit_copy(from,to,2,offset,0,det); | |
1590 if(length>0) | |
1591 emit_copy(from,to,length,offset,0,det); | |
1592 break; | |
1593 } | |
125 | 1594 clear_ptr_cache(); |
1595 code_save_stacks(); | |
416 | 1596 printf("\tli r5,%d\n",length>0?length:-length); |
125 | 1597 printf("\tmr r4,%s\n",frn); |
1598 printf("\tmr r3,%s\n",trn); | |
417 | 1599 /* offset should be ignored */ |
125 | 1600 /* overrap must be allowed */ |
1601 printf("\tbl L_%s$stub\n",memmove); | |
1602 extern_define(memmove,0,FUNCTION,1); | |
1603 fix=0; | |
207 | 1604 set_ireg(RET_REGISTER,0); |
125 | 1605 if (creg!=to) { |
1606 free_register(to); to = creg; | |
89 | 1607 } |
125 | 1608 break; |
89 | 1609 } |
1610 if (value) { | |
1611 /* creg must point top of the destination data */ | |
1612 /* this code is necessary for the value of assignment or function call */ | |
1613 /* otherwise we don't need this */ | |
1614 if (fix) printf("\taddi %s,%s,%d\n",trn,trn,fix); | |
1615 if(creg!=to) { | |
221 | 1616 free_register(creg); creg=to; ireg=to; |
89 | 1617 } |
1618 } | |
1619 free_register(dreg); | |
1620 } | |
1621 | |
1622 int | |
444 | 1623 push_struct(int e4,int t,int arg) |
89 | 1624 { |
95 | 1625 int length,count; |
119 | 1626 int dreg,sreg; char *drn,*crn,*srn; |
89 | 1627 g_expr(e4); |
221 | 1628 if (!is_int_reg(creg)) error(-1); |
89 | 1629 length=size(t); |
245 | 1630 if(length%SIZE_OF_INT) { |
1631 length += SIZE_OF_INT - (length%SIZE_OF_INT); | |
89 | 1632 } |
95 | 1633 dreg = get_register(); if (!dreg) error(-1); |
89 | 1634 drn = register_name(dreg); |
119 | 1635 crn = register_name(creg); |
125 | 1636 if (length<MAX_COPY_LEN) { |
1637 sreg = get_register(); if (!sreg) error(-1); | |
1638 srn = register_name(sreg); | |
258
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1639 code_lvar(cadr(arg),dreg); |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1640 for(count=0;count<length;count+=SIZE_OF_INT) { |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1641 printf("\tlwz %s,%d(%s)\n",srn,count,crn); |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1642 printf("\tstwu %s,%d(%s)\n",srn,count,drn); |
89 | 1643 } |
258
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1644 free_register(sreg); |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1645 free_register(dreg); |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1646 return length/SIZE_OF_INT; |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1647 } else { |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1648 code_lvar(cadr(arg),dreg); |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1649 /* downward direction copy */ |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1650 emit_copy(creg,dreg,length,0,0,1); |
89 | 1651 } |
258
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1652 free_register(dreg); |
245 | 1653 return length/SIZE_OF_INT; |
89 | 1654 } |
1655 | |
104 | 1656 void |
207 | 1657 set_ireg(int reg,int mode) |
104 | 1658 { |
207 | 1659 if (!is_int_reg(reg)) error(-1); |
104 | 1660 if (reg!=creg) { |
111 | 1661 clear_ptr_cache_reg(reg); |
208 | 1662 if (ireg && reg!=ireg ) { |
1663 free_register(ireg); | |
1664 if (mode) { | |
1665 printf("\tmr %s,%s\n",register_name(reg),register_name(ireg)); | |
1666 } | |
206 | 1667 } |
104 | 1668 free_register(creg); |
536 | 1669 if (creg==lreg) lreg = 0; |
208 | 1670 regs[reg]=USING_REG; |
104 | 1671 } |
206 | 1672 creg = ireg = reg; |
104 | 1673 } |
1674 | |
1675 void | |
1676 set_freg(int reg,int mode) | |
1677 { | |
207 | 1678 if (!is_float_reg(reg)) error(-1); |
147 | 1679 if (reg!=creg) { |
222 | 1680 if (freg && reg!=freg) { |
208 | 1681 free_register(freg); |
1682 if (mode) { | |
1683 printf("\tfmr %s,%s\n",fregister_name(reg),fregister_name(freg)); | |
1684 } | |
147 | 1685 } |
222 | 1686 // if (creg!=ireg) free_register(creg); |
208 | 1687 regs[reg]=USING_REG; |
104 | 1688 } |
206 | 1689 creg = freg = reg; |
195 | 1690 } |
1691 | |
1692 void | |
1693 set_lreg(int reg,int mode) | |
1694 { | |
222 | 1695 if (reg==RET_LREGISTER) { |
1696 regv_l(reg) = RET_LREGISTER_L; | |
1697 regv_h(reg) = RET_LREGISTER_H; | |
1698 } | |
207 | 1699 if (!is_longlong_reg(reg)) error(-1); |
206 | 1700 if (reg!=creg) { |
530 | 1701 if (lreg) { |
1702 if (reg!=lreg) { | |
1703 if (mode) { | |
1704 printf("\tmr %s,%s\n", | |
1705 lregister_name_low(reg),lregister_name_low(lreg)); | |
1706 printf("\tmr %s,%s\n", | |
1707 lregister_name_high(reg),lregister_name_high(lreg)); | |
1708 } | |
1709 free_register(lreg); | |
208 | 1710 } |
530 | 1711 if (lreg==creg) creg=0; |
206 | 1712 } |
530 | 1713 if (creg) free_register(creg); |
207 | 1714 regs[reg]=USING_REG; |
222 | 1715 clear_ptr_cache_reg(regv_l(reg)); |
207 | 1716 regs[regv_l(reg)]=USING_REG; |
222 | 1717 clear_ptr_cache_reg(regv_h(reg)); |
207 | 1718 regs[regv_h(reg)]=USING_REG; |
530 | 1719 creg = lreg = reg; |
206 | 1720 } |
104 | 1721 } |
1722 | |
1723 void | |
217 | 1724 set_lreg_operand(int reg,int mode) |
216 | 1725 { |
326 | 1726 // save_stack,clear_ptr_cache is assumed |
217 | 1727 if (!is_longlong_reg(reg)) { error(-1); return; } |
1728 if (mode) { | |
255 | 1729 if (regv_l(reg)!=3) |
1730 printf("\tmr r3,%s\n", lregister_name_high(reg)); | |
1731 if (regv_l(reg)!=4) | |
1732 printf("\tmr r4,%s\n", lregister_name_low(reg)); | |
1733 } | |
1734 } | |
1735 | |
1736 void | |
1737 set_lreg_operand1(int reg,int mode) | |
1738 { | |
326 | 1739 // save_stack,clear_ptr_cache is assumed |
255 | 1740 if (!is_longlong_reg(reg)) { error(-1); return; } |
1741 if (mode) { | |
217 | 1742 if (regv_l(reg)!=5) |
228 | 1743 printf("\tmr r5,%s\n", lregister_name_high(reg)); |
217 | 1744 if (regv_l(reg)!=6) |
228 | 1745 printf("\tmr r6,%s\n", lregister_name_low(reg)); |
217 | 1746 } |
216 | 1747 } |
1748 | |
1749 void | |
207 | 1750 use_reg(int arg) |
104 | 1751 { |
468 | 1752 // printf("## use reg %d\n",arg); |
208 | 1753 if (arg<0||arg> REAL_MAX_REGISTER+REAL_MAX_FREGISTER+ REAL_MAX_LREGISTER) |
1754 error(-1); | |
223 | 1755 clear_ptr_cache_reg(arg); |
207 | 1756 regs[arg]=USING_REG; |
1757 if (is_longlong_reg(arg)) { | |
228 | 1758 clear_ptr_cache_reg(regv_l(arg)); |
207 | 1759 regs[regv_l(arg)]=USING_REG; |
228 | 1760 clear_ptr_cache_reg(regv_h(arg)); |
207 | 1761 regs[regv_h(arg)]=USING_REG; |
206 | 1762 } |
104 | 1763 } |
1764 | |
105 | 1765 void |
305
117baacd1ed0
stdarg powerpc passed except long long (macro problem)
kono
parents:
304
diff
changeset
|
1766 code_save_input_registers(int dots) |
105 | 1767 { |
119 | 1768 int args; |
1769 NMTBL *n; | |
1770 int reg; | |
1771 int tag; | |
1772 int lvar; | |
1773 int t; | |
1774 /* fnptr->dsp=list4(type,fnptr->dsp,(int)n,0); */ | |
1775 int reg_offset = 0; | |
1776 int offset = 0; | |
305
117baacd1ed0
stdarg powerpc passed except long long (macro problem)
kono
parents:
304
diff
changeset
|
1777 int reg_var = 0; |
119 | 1778 |
1779 for(args = fnptr->dsp;args;args = cadr(args)) { | |
1780 n = (NMTBL *)caddr(args); | |
1781 tag = n->sc; | |
1782 reg = n->dsp; | |
1783 if (!n||n==&null_nptr) error(REG_ERR); | |
1784 if (tag==REGISTER) { | |
1785 /* regs[reg]==INPUT_REG case should be considered */ | |
1786 n->dsp = offset; | |
245 | 1787 offset+=SIZE_OF_INT; |
119 | 1788 t = INT; |
1789 reg += reg_offset; /* for duplicated floating point argument */ | |
305
117baacd1ed0
stdarg powerpc passed except long long (macro problem)
kono
parents:
304
diff
changeset
|
1790 reg_var++; |
119 | 1791 } else if (tag==DREGISTER) { |
145 | 1792 /* regs[reg]==INPUT_REG case should be considered */ |
119 | 1793 n->dsp = offset; |
120 | 1794 t = n->ty; |
245 | 1795 if(t==FLOAT) { offset+=SIZE_OF_FLOAT; reg_offset+=1; } |
1796 else if(t==DOUBLE) { offset+=SIZE_OF_DOUBLE; reg_offset+=2; } | |
120 | 1797 else error(-1); |
305
117baacd1ed0
stdarg powerpc passed except long long (macro problem)
kono
parents:
304
diff
changeset
|
1798 reg_var += 2; |
206 | 1799 } else if (tag==LREGISTER) { |
1800 /* regs[reg]==INPUT_REG case should be considered */ | |
1801 n->dsp = offset; | |
1802 t = n->ty; | |
245 | 1803 offset+=SIZE_OF_LONGLONG; reg_offset+=2; |
305
117baacd1ed0
stdarg powerpc passed except long long (macro problem)
kono
parents:
304
diff
changeset
|
1804 reg_var += 2; |
122 | 1805 } else { |
534 | 1806 // n->dsp = offset; this is no allowed becase of arg reorder |
122 | 1807 offset += size(n->ty); |
119 | 1808 continue; |
122 | 1809 } |
119 | 1810 n->sc = LVAR; |
445 | 1811 lvar = list3(LVAR,n->dsp,0); |
305
117baacd1ed0
stdarg powerpc passed except long long (macro problem)
kono
parents:
304
diff
changeset
|
1812 g_expr_u(assign_expr0( |
445 | 1813 list3(LVAR,n->dsp,0),list3(tag,reg,(int)n),n->ty,t)); |
206 | 1814 if (tag==REGISTER||tag==DREGISTER||tag==FREGISTER||tag==LREGISTER) { |
119 | 1815 free_register(reg); |
1816 } | |
1817 } | |
305
117baacd1ed0
stdarg powerpc passed except long long (macro problem)
kono
parents:
304
diff
changeset
|
1818 if (dots) { |
117baacd1ed0
stdarg powerpc passed except long long (macro problem)
kono
parents:
304
diff
changeset
|
1819 while ((reg = get_input_register_var(reg_var,0,0))) { |
117baacd1ed0
stdarg powerpc passed except long long (macro problem)
kono
parents:
304
diff
changeset
|
1820 g_expr_u(assign_expr0( |
445 | 1821 list3(LVAR,offset,0),reg,INT,INT)); |
305
117baacd1ed0
stdarg powerpc passed except long long (macro problem)
kono
parents:
304
diff
changeset
|
1822 offset+=SIZE_OF_INT; |
117baacd1ed0
stdarg powerpc passed except long long (macro problem)
kono
parents:
304
diff
changeset
|
1823 reg_var++; |
117baacd1ed0
stdarg powerpc passed except long long (macro problem)
kono
parents:
304
diff
changeset
|
1824 } |
117baacd1ed0
stdarg powerpc passed except long long (macro problem)
kono
parents:
304
diff
changeset
|
1825 } |
121 | 1826 my_func_args = offset; |
105 | 1827 } |
1828 | |
449 | 1829 int |
228 | 1830 not_simple_p(int e3) |
223 | 1831 { |
450
eaf9e2746c83
parallel assign for simple expr. (too complex solution)
kono
parents:
449
diff
changeset
|
1832 switch (e3) { |
456 | 1833 case FUNCTION: case CONV: case LCALL: case STASS: |
450
eaf9e2746c83
parallel assign for simple expr. (too complex solution)
kono
parents:
449
diff
changeset
|
1834 case LLSHIFT: case LULSHIFT: case LRSHIFT: case LURSHIFT: |
eaf9e2746c83
parallel assign for simple expr. (too complex solution)
kono
parents:
449
diff
changeset
|
1835 case LDIV: case LUDIV: case LMOD: case LUMOD: case LASSOP: case ALLOCA: |
456 | 1836 case INLINE: |
450
eaf9e2746c83
parallel assign for simple expr. (too complex solution)
kono
parents:
449
diff
changeset
|
1837 return 1; |
eaf9e2746c83
parallel assign for simple expr. (too complex solution)
kono
parents:
449
diff
changeset
|
1838 } |
eaf9e2746c83
parallel assign for simple expr. (too complex solution)
kono
parents:
449
diff
changeset
|
1839 return 0; |
223 | 1840 } |
1841 | |
258
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1842 static int |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1843 simple_arg(int e3) |
108 | 1844 { |
258
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1845 return !contains_p(e3,not_simple_p); |
108 | 1846 } |
1847 | |
119 | 1848 int |
1849 caller_arg_offset_v(int arg) | |
1850 { | |
245 | 1851 return ARG_LVAR_OFFSET+arg*SIZE_OF_INT; |
119 | 1852 } |
111 | 1853 |
233 | 1854 void |
1855 use_input_reg(int reg,int mode) | |
1856 { | |
1857 if (is_int_reg(reg)) { | |
1858 if (ireg&® == ireg) { | |
1859 if (creg==ireg) creg = 0; | |
1860 ireg = 0; | |
1861 } | |
1862 if (lreg) { | |
1863 if (regv_l(lreg)==reg) { | |
1864 regs[lreg]=0; | |
1865 if (regv_h(lreg)>reg&®s[regv_h(lreg)]==USING_REG) { | |
1866 free_register(regv_h(lreg)); | |
1867 } | |
529 | 1868 if (creg==lreg) creg = ireg; |
431 | 1869 free_register(lreg); |
233 | 1870 lreg = 0; |
1871 } else if (regv_h(lreg)==reg) { | |
1872 regs[lreg]=0; | |
1873 if (regv_h(lreg)>reg&®s[regv_l(lreg)]==USING_REG) { | |
1874 free_register(regv_l(lreg)); | |
1875 } | |
529 | 1876 if (creg==lreg) creg = ireg; |
431 | 1877 free_register(lreg); |
233 | 1878 lreg = 0; |
1879 } | |
1880 } | |
1881 } else if (is_longlong_reg(reg)) { | |
1882 use_input_reg(regv_h(reg),0); | |
1883 use_input_reg(regv_l(reg),0); | |
1884 } else if (is_float_reg(reg)) { | |
1885 if (freg&® == freg) { | |
529 | 1886 if (creg==freg) creg = ireg; |
233 | 1887 freg = 0; |
1888 } | |
1889 } | |
1890 if (mode) use_reg(reg); | |
1891 } | |
1892 | |
271 | 1893 static int |
258
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1894 compute_complex_arg(int e3,int reg_arg_list,int arg) { |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1895 int t=caddr(e3); |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1896 int e4 = car(e3); |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1897 reg_arg_list = list2(arg,reg_arg_list); |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1898 g_expr_u(assign_expr0(arg,e4,t,t)); |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1899 if (car(arg)==REGISTER||car(arg)==DREGISTER|| |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1900 car(arg)==FREGISTER||car(arg)==LREGISTER) |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1901 use_input_reg(cadr(arg),1); |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1902 car(e3) = arg; |
271 | 1903 return reg_arg_list; |
258
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1904 } |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1905 |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1906 static void |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1907 increment_function_arg(int e3,int *pnargs,int *preg_arg,int *pfreg_arg) { |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1908 int nargs=0,reg_arg=0,freg_arg=0; |
487 | 1909 int t=type_value(caddr(e3)); |
331 | 1910 if (t>=0&&(car(t)==BIT_FIELD)) { |
487 | 1911 t = type_value(cadr(t)); |
331 | 1912 } |
258
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1913 if(scalar(t)) { |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1914 nargs ++ ; reg_arg++; |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1915 } else if (t==LONGLONG||t==ULONGLONG) { |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1916 nargs ++ ; reg_arg++; |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1917 nargs ++ ; reg_arg++; |
475 | 1918 } else if (t==FLOAT) { |
1919 if (*preg_arg<MAX_INPUT_REGISTER_VAR) { | |
1920 reg_arg += 1; | |
1921 } | |
1922 freg_arg++; | |
1923 nargs += size(t)/SIZE_OF_INT; | |
1924 } else if (t==DOUBLE) { | |
258
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1925 if (*preg_arg<MAX_INPUT_REGISTER_VAR) { |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1926 reg_arg += 2; |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1927 } |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1928 freg_arg++; |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1929 nargs += size(t)/SIZE_OF_INT; |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1930 } else if (t>=0&&(car(t)==STRUCT||car(t)==UNION)) { |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1931 nargs += round4(size(t))/SIZE_OF_INT; |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1932 } else { |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1933 error(TYERR); |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1934 nargs ++ ; |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1935 } |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1936 *pnargs += nargs; |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1937 *preg_arg += reg_arg; |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1938 *pfreg_arg += freg_arg; |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1939 } |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1940 |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1941 #define AS_SAVE 1 |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1942 #define AS_ARG 0 |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1943 |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1944 static int |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1945 get_input_arg(int t,int mode,int nargs,int reg_arg,int freg_arg) |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1946 { |
487 | 1947 t = type_value(t); |
331 | 1948 if (t>=0&&(car(t)==BIT_FIELD)) { |
487 | 1949 t = type_value(cadr(t)); |
331 | 1950 } |
258
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1951 if(scalar(t)) { |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1952 if (mode==AS_SAVE) { |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1953 return get_register_var(0); |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1954 } else if (reg_arg>=MAX_INPUT_REGISTER_VAR) { |
445 | 1955 return list3(LVAR,caller_arg_offset_v(nargs),0); |
258
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1956 } else |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1957 return get_input_register_var(reg_arg,0,0); |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1958 } else if (t==LONGLONG||t==ULONGLONG) { |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1959 if (mode==AS_SAVE) { |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1960 return get_lregister_var(0); |
259 | 1961 } else if (reg_arg+1>=MAX_INPUT_REGISTER_VAR) { |
445 | 1962 return list3(LVAR,caller_arg_offset_v(nargs),0); |
258
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1963 } else |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1964 return get_input_lregister_var(reg_arg,0,0); |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1965 } else if (t==FLOAT) { |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1966 if (mode==AS_SAVE) { |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1967 return get_dregister_var(0,0); |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1968 } else if (freg_arg>=MAX_INPUT_DREGISTER_VAR) { |
445 | 1969 return list3(LVAR,caller_arg_offset_v(nargs),0); |
258
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1970 } else |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1971 return get_input_dregister_var(freg_arg,0,0,0); |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1972 } else if (t==DOUBLE) { |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1973 if (mode==AS_SAVE) { |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1974 return get_dregister_var(0,1); |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1975 } else if (freg_arg>=MAX_INPUT_DREGISTER_VAR) { |
445 | 1976 return list3(LVAR,caller_arg_offset_v(nargs),0); |
258
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1977 } else |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1978 return get_input_dregister_var(freg_arg,0,0,1); |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1979 } else if (t>=0&&(car(t)==STRUCT||car(t)==UNION)) { |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1980 if (mode==AS_SAVE) { |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1981 return get_register_var(0); |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1982 } else |
445 | 1983 return list3(LVAR,caller_arg_offset_v(nargs),0); |
258
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1984 } else { |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1985 error(-1); |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1986 return get_register_var(0); |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1987 } |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1988 } |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
1989 |
108 | 1990 int |
89 | 1991 function(int e1) |
1992 { | |
119 | 1993 int e2,e3,e4,e5,nargs,t,r0,r1; |
104 | 1994 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
|
1995 int dots; |
111 | 1996 int reg_arg_list=0,ret_type,special_lvar; |
127 | 1997 NMTBL *fn = 0; |
108 | 1998 int jmp = 0; |
1999 char *jrn; | |
258
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
2000 int complex_; |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
2001 int pnargs,preg_arg,pfreg_arg; |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
2002 int stargs; |
95 | 2003 |
111 | 2004 special_lvar = -1; |
305
117baacd1ed0
stdarg powerpc passed except long long (macro problem)
kono
parents:
304
diff
changeset
|
2005 ret_type = function_type(cadddr(e1),&dots); |
313 | 2006 if (caddr(cadddr(e1))==0) dots=1; |
108 | 2007 |
285 | 2008 arg_assign = 0; |
108 | 2009 e2 = cadr(e1); |
2010 if (car(e2) == FNAME) { | |
2011 fn=(NMTBL *)cadr(e2); | |
2012 } else { | |
285 | 2013 if (car(e2)==INDIRECT) e2=cadr(e2); // (*func)(i) case |
2014 jmp = get_register_var(0); | |
2015 if (car(jmp)!=REGISTER) error(-1); | |
2016 reg_arg_list = list2(jmp,reg_arg_list); | |
2017 if (!simple_arg(e2)) { | |
2018 g_expr_u(assign_expr0(jmp,e2,INT,INT)); | |
2019 } else | |
2020 arg_assign = list2(assign_expr0(jmp,e2,INT,INT),arg_assign); | |
108 | 2021 } |
258
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
2022 /* first we execute complex argument to avoid interaction with |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
2023 input variables */ |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
2024 stargs = 0; |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
2025 complex_ = 0; |
259 | 2026 nargs = reg_arg = freg_arg = 0; |
258
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
2027 for (e3 = e1 = reverse0(caddr(e1)); e3; e3 = cadr(e3)) { |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
2028 t=caddr(e3); |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
2029 if ((e5= !simple_arg(car(e3)))) { |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
2030 if (complex_) { |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
2031 arg = get_input_arg(caddr(complex_),AS_SAVE, |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
2032 pnargs,preg_arg,pfreg_arg); |
271 | 2033 reg_arg_list = compute_complex_arg(complex_,reg_arg_list,arg); |
258
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
2034 } |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
2035 pnargs=nargs;preg_arg=reg_arg;pfreg_arg=freg_arg; |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
2036 complex_ = e3; |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
2037 } |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
2038 if (t>=0&&(car(t)==STRUCT||car(t)==UNION)) { |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
2039 // The struct should be pushed after complex arguments. |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
2040 if (e5) { // compute address only, complex_ is me now. Clear it. |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
2041 complex_ = 0; |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
2042 e4 = car(e3); |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
2043 if (car(e4)!=RSTRUCT) error(-1); |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
2044 if (!simple_arg(cadr(e4))) { |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
2045 // Calculate complex struct address here. |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
2046 // If simple, leave it. |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
2047 arg = get_register_var(0); |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
2048 g_expr_u(assign_expr0(arg,list2(ADDRESS,car(e3)),INT,INT)); |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
2049 car(e3)=arg; |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
2050 reg_arg_list = list2(arg,reg_arg_list); |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
2051 if (car(arg)==REGISTER) use_input_reg(cadr(arg),1); |
408 | 2052 else car(e3) = rvalue_t(arg,INT); |
258
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
2053 } |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
2054 } |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
2055 stargs = list4(e3,stargs,nargs,reg_arg); |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
2056 } |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
2057 increment_function_arg(e3,&nargs,®_arg,&freg_arg); |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
2058 } |
108 | 2059 |
99 | 2060 /* now all input register vars are free */ |
108 | 2061 code_save_stacks(); |
222 | 2062 // set_lreg(LREG_LREGISTER,0); |
221 | 2063 set_freg(FREG_FREGISTER,0); |
207 | 2064 set_ireg(CREG_REGISTER,0); |
108 | 2065 |
268 | 2066 // Struct arguments need emit_copy. it destructs 3 input registers. |
326 | 2067 // But it returns no value on a register. So calculate it here. |
268 | 2068 // We cannot do this in the previous loop, because the copied struct may be |
326 | 2069 // override by other complex arguments. But before this we have to check |
268 | 2070 // complex_. |
2071 | |
2072 if (stargs) { | |
2073 if (complex_) { | |
2074 arg = get_input_arg(caddr(complex_),AS_SAVE, | |
2075 pnargs,preg_arg,pfreg_arg); | |
271 | 2076 reg_arg_list = compute_complex_arg(complex_,reg_arg_list,arg); |
268 | 2077 } |
2078 for(stargs=reverse0(stargs);stargs;stargs = cadr(stargs)) { | |
2079 e3 = car(stargs); | |
2080 e4 = car(e3); | |
2081 t = caddr(e3); | |
2082 arg = get_input_arg(t,AS_ARG,caddr(stargs),cadddr(stargs),0); | |
444 | 2083 push_struct(e4,t,arg); |
268 | 2084 car(e3)=0; // done |
2085 } | |
2086 } else { | |
2087 // last complex argument can use input register | |
2088 if (complex_) { | |
2089 arg = get_input_arg(caddr(complex_),AS_ARG,pnargs,preg_arg,pfreg_arg); | |
271 | 2090 reg_arg_list = compute_complex_arg(complex_,reg_arg_list,arg); |
268 | 2091 } |
258
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
2092 } |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
2093 |
285 | 2094 nargs = reg_arg = freg_arg = 0; |
268 | 2095 // calc stack arguments first, it may requires extra registers, |
2096 // and we can still use input registers now. | |
259 | 2097 for (e3 = e1; e3; |
2098 increment_function_arg(e3,&nargs,®_arg,&freg_arg), | |
2099 e3 = cadr(e3)) { | |
2100 if (!(e4=car(e3))) continue; | |
2101 t=caddr(e3); | |
2102 arg = get_input_arg(t,AS_ARG,nargs,reg_arg,freg_arg); | |
2103 if (car(arg)!=LVAR) continue; | |
2104 g_expr_u(assign_expr0(arg,e4,t,t)); | |
2105 if (t==LONGLONG||t==ULONGLONG) { | |
2106 if (reg_arg+1==MAX_INPUT_REGISTER_VAR) { | |
2107 // half register, half memory case | |
2108 arg_assign = list2( | |
2109 assign_expr0(r0=get_input_register_var(reg_arg,0,0), | |
2110 arg,INT,INT), | |
2111 arg_assign); | |
2112 use_input_reg(cadr(r0),1); | |
2113 } | |
2114 } | |
2115 car(e3)=0; // done | |
2116 } | |
2117 nargs = reg_arg = freg_arg = 0; | |
258
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
2118 for (e3 = e1; e3; |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
2119 increment_function_arg(e3,&nargs,®_arg,&freg_arg), |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
2120 e3 = cadr(e3)) { |
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
2121 if (!(e4=car(e3))) continue; |
487 | 2122 t=type_value(caddr(e3)); |
258
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
2123 arg = get_input_arg(t,AS_ARG,nargs,reg_arg,freg_arg); |
89 | 2124 if(scalar(t)) { |
99 | 2125 reg_arg_list = list2(arg,reg_arg_list); |
233 | 2126 /* protect from input register free */ |
2127 if (car(arg)==REGISTER) | |
2128 use_input_reg(cadr(arg),1); | |
99 | 2129 g_expr_u(assign_expr0(arg,e4,t,t)); |
202 | 2130 } else if (t==LONGLONG||t==ULONGLONG) { |
259 | 2131 if (reg_arg+1==MAX_INPUT_REGISTER_VAR) { |
227 | 2132 // half register, half memory case |
2133 // put whole long long anyway | |
2134 arg_assign = list2( | |
232 | 2135 assign_expr0(r0=get_input_register_var(reg_arg,0,0), |
227 | 2136 arg,INT,INT), |
2137 arg_assign); | |
233 | 2138 use_input_reg(cadr(r0),1); |
530 | 2139 reg_arg_list = list2(r0,reg_arg_list); |
206 | 2140 } else { |
530 | 2141 if (car(arg)==LREGISTER) { |
258
22949117768f
Complex function argments. Struct is done. Long long is odd.
kono
parents:
257
diff
changeset
|
2142 use_input_reg(cadr(arg),1); |
530 | 2143 } |
206 | 2144 } |
2145 reg_arg_list = list2(arg,reg_arg_list); | |
2146 g_expr_u(assign_expr0(arg,e4,t,t)); | |
89 | 2147 } else if (t==DOUBLE||t==FLOAT) { |
137 | 2148 if (reg_arg<MAX_INPUT_REGISTER_VAR) { |
119 | 2149 /* sigh... |
326 | 2150 printf requires floating value in integer registers |
119 | 2151 */ |
137 | 2152 if (dots) { |
2153 if (car(e4)==DRLVAR) { | |
2154 special_lvar = cadr(e4); | |
445 | 2155 e5 = list3(LVAR,special_lvar,0); |
137 | 2156 } else { |
245 | 2157 special_lvar = new_lvar(SIZE_OF_DOUBLE); |
137 | 2158 g_expr(assign_expr0( |
445 | 2159 (e5=list3(LVAR,special_lvar,0)),e4,DOUBLE,t)); |
137 | 2160 reg_arg_list = list2(e5,reg_arg_list); |
2161 e4 = list2(DREGISTER,freg); | |
2162 /* freg should not change until XXX */ | |
2163 } | |
2164 r0=get_input_register_var(reg_arg,0,0); | |
2165 r1 = reg_arg+1+MIN_TMP_REG; | |
206 | 2166 if (regs[r1]==PTRC_REG) |
2167 clear_ptr_cache_reg(list2(REGISTER,r1)); | |
137 | 2168 /* else if (regs[r1]) error(-1); */ |
2169 r1=get_input_register_var_1(reg_arg+1,0,0); | |
233 | 2170 use_input_reg(cadr(r0),1); /* protect from input register free */ |
2171 use_input_reg(cadr(r1),1); /* protect from input register free */ | |
137 | 2172 reg_arg_list = list2(r0,reg_arg_list); |
2173 reg_arg_list = list2(r1,reg_arg_list); | |
2174 arg_assign = list2( assign_expr0(r0,e5,INT,INT), arg_assign); | |
2175 arg_assign = list2( assign_expr0(r1, | |
445 | 2176 list3(LVAR,special_lvar+SIZE_OF_INT,0), |
137 | 2177 INT,INT), arg_assign); |
111 | 2178 } |
2179 } | |
498 | 2180 if (dots && (freg_arg*8+reg_arg*4)>=32 && freg_arg<MAX_INPUT_DREGISTER_VAR) { |
496 | 2181 /* |
326 | 2182 it requires integer register and floating register and |
496 | 2183 stack value. |
119 | 2184 */ |
2185 arg_assign = list2( | |
445 | 2186 assign_expr0(list3(LVAR,caller_arg_offset_v(nargs),0), |
138 | 2187 get_input_dregister_var(freg_arg,0,0,1),t,t), |
119 | 2188 arg_assign); |
2189 } | |
233 | 2190 reg_arg_list = list2(arg,reg_arg_list); |
208 | 2191 if (car(arg)==DREGISTER) |
233 | 2192 use_input_reg(cadr(arg),1); /* protect from input register free */ |
118 | 2193 g_expr_u(assign_expr0(arg,e4,t,t)); /* XXX */ |
89 | 2194 } |
259 | 2195 // structs are finished |
89 | 2196 } |
116 | 2197 if (max_func_args<nargs) max_func_args=nargs; |
104 | 2198 for(;arg_assign;arg_assign=cadr(arg_assign)) { |
2199 g_expr_u(car(arg_assign)); | |
2200 } | |
96 | 2201 clear_ptr_cache(); |
89 | 2202 if (car(e2) == FNAME) { |
108 | 2203 printf("\tbl\tL_%s$stub\n",fn->nm); |
89 | 2204 } else { |
108 | 2205 jrn = register_name(cadr(jmp)); |
89 | 2206 printf("\tmtctr %s\n",jrn); |
2207 printf("\tbctrl\n"); | |
2208 } | |
99 | 2209 for(;reg_arg_list;reg_arg_list=cadr(reg_arg_list)) { |
108 | 2210 arg = car(reg_arg_list); |
206 | 2211 if (car(arg)==REGISTER||car(arg)==DREGISTER||car(arg)==FREGISTER |
530 | 2212 ||car(arg)==LREGISTER) { |
2213 // if (car(arg)==LREGISTER) | |
2214 // printf("## lreg freeing %d %s %s\n",cadr(arg), lregister_name_high(cadr(arg)), lregister_name_low(cadr(arg))); | |
147 | 2215 free_register(cadr(arg)); |
530 | 2216 } else if (car(arg)==LVAR&&cadr(arg)<0) free_lvar(cadr(arg)); |
99 | 2217 } |
105 | 2218 if (ret_type==DOUBLE||ret_type==FLOAT) { |
104 | 2219 set_freg(RET_FREGISTER,0); |
206 | 2220 } else if (ret_type==ULONGLONG||ret_type==LONGLONG) { |
2221 set_lreg(RET_LREGISTER,0); | |
207 | 2222 use_reg(RET_LREGISTER); |
105 | 2223 } else if (ret_type==VOID) { |
96 | 2224 } else { |
207 | 2225 set_ireg(RET_REGISTER,0); |
96 | 2226 } |
530 | 2227 cleanup_lregister0(); |
105 | 2228 return ret_type; |
89 | 2229 } |
2230 | |
2231 void | |
313 | 2232 code_alloca(int e1,int reg) |
2233 { | |
2234 char *crn,*grn; | |
2235 int g; | |
2236 | |
2237 g_expr(list3(BAND,list3(ADD,e1,list2(CONST,30)),list2(CONST,~15))); | |
2238 use_int(reg); | |
2239 g = get_register(); | |
2240 crn = register_name(reg); | |
2241 grn = register_name(g); | |
2242 // printf("\trlwinm r0,%s,0,0,27\n",crn); | |
2243 printf("\tlwz %s,0(r1)\n",grn); | |
2244 printf("\tneg %s,%s\n",crn,crn); | |
2245 printf("\tstwux %s,r1,%s\n",grn,crn); | |
2246 // printf("\tstw %s,0(r1)\n",grn); | |
2247 if (!max_func_arg_label) max_func_arg_label = fwdlabel(); | |
2248 printf("\taddis r1,r1,ha16(L_%d)\n",max_func_arg_label); | |
2249 printf("\taddi %s,r1,lo16(L_%d)\n",crn,max_func_arg_label); | |
2250 free_register(g); | |
2251 } | |
2252 | |
2253 void | |
89 | 2254 code_frame_pointer(int e3) { |
221 | 2255 use_int(e3); |
128 | 2256 #if R1SAVE |
2257 printf("\tmr r1,%s\n",register_name(e3)); | |
2258 #else | |
126 | 2259 printf("\tmr r30,%s\n",register_name(e3)); |
128 | 2260 #endif |
89 | 2261 } |
2262 | |
2263 | |
2264 void | |
2265 code_fix_frame_pointer(int disp_offset) { | |
128 | 2266 int l = 0; |
2267 printf("\tla r30,"); | |
375 | 2268 printf("lo16(%d)(r30)\n",FUNC_LVAR); |
89 | 2269 } |
2270 | |
2271 void | |
2272 code_jmp(char *s) { | |
128 | 2273 max_reg_var = REG_VAR_BASE-REG_VAR_MIN; |
2274 max_freg_var = FREG_VAR_BASE-FREG_VAR_MIN; | |
89 | 2275 printf("\tb L_%s$stub\n",s); |
283 | 2276 control=0; |
89 | 2277 } |
2278 | |
2279 | |
2280 void | |
2281 code_indirect_jmp(int e2) { | |
128 | 2282 max_reg_var = REG_VAR_BASE-REG_VAR_MIN; |
2283 max_freg_var = FREG_VAR_BASE-FREG_VAR_MIN; | |
221 | 2284 use_int(e2); |
89 | 2285 printf("\tmtctr %s\n",register_name(e2)); |
2286 printf("\tbctr\n"); | |
283 | 2287 control=0; |
89 | 2288 } |
2289 | |
355 | 2290 void |
2291 code_rindirect(int e1, int reg,int offset, int sign,int sz) | |
196 | 2292 { |
221 | 2293 char *crn,*rrn; |
196 | 2294 g_expr(e1); |
221 | 2295 if (!is_int_reg(creg)) error(-1); |
196 | 2296 crn=register_name(creg); |
221 | 2297 use_int(reg); |
2298 rrn=register_name(reg); | |
375 | 2299 if (LARGE_OFFSET(offset)) { |
2300 printf("\taddis %s,%s,ha16(%d)\n",crn,crn,offset); | |
2301 } | |
2302 printf("\t%s %s,lo16(%d)(%s)\n",cload(sz),rrn,offset,crn); | |
355 | 2303 cext(sign,sz,reg); |
89 | 2304 } |
2305 | |
196 | 2306 #if FLOAT_CODE |
2307 int | |
221 | 2308 code_drindirect(int e1, int reg,int offset, int d) |
196 | 2309 { |
2310 char *crn; | |
2311 g_expr(e1); | |
221 | 2312 if (!is_int_reg(creg)) error(-1); |
196 | 2313 crn=register_name(creg); |
221 | 2314 use_float(d,reg); |
375 | 2315 if (LARGE_OFFSET(offset)) { |
2316 printf("\taddis %s,%s,ha16(%d)\n",crn,crn,offset); | |
2317 } | |
2318 printf("\t%s %s,lo16(%d)(%s)\n",fload(d), | |
221 | 2319 fregister_name(reg),offset,crn); |
375 | 2320 |
206 | 2321 return d?DOUBLE:FLOAT; |
196 | 2322 } |
2323 #endif | |
2324 | |
440 | 2325 #if LONGLONG_CODE |
269 | 2326 static void |
2327 lload(int creg,int reg,int offset) | |
2328 { | |
2329 char *crn = register_name(creg); | |
375 | 2330 if (LARGE_OFFSET(offset)) { |
2331 printf("\taddis %s,%s,ha16(%d)\n",crn,crn,offset); | |
2332 } | |
411 | 2333 #if ENDIAN_L==0 |
2334 if (creg!=regv_l(reg)) { | |
2335 printf("\tlwz %s,lo16(%d)(%s)\n",lregister_name_low(reg),offset,crn); | |
2336 printf("\tlwz %s,lo16(%d)(%s)\n",lregister_name_high(reg),offset+SIZE_OF_INT,crn); | |
2337 } else { | |
2338 printf("\tlwz %s,lo16(%d)(%s)\n",lregister_name_high(reg),offset+SIZE_OF_INT,crn); | |
2339 printf("\tlwz %s,lo16(%d)(%s)\n",lregister_name_low(reg),offset,crn); | |
2340 } | |
2341 #else | |
269 | 2342 if (creg!=regv_h(reg)) { |
375 | 2343 printf("\tlwz %s,lo16(%d)(%s)\n",lregister_name_high(reg),offset,crn); |
2344 printf("\tlwz %s,lo16(%d)(%s)\n",lregister_name_low(reg),offset+SIZE_OF_INT,crn); | |
269 | 2345 } else { |
375 | 2346 printf("\tlwz %s,lo16(%d)(%s)\n",lregister_name_low(reg),offset+SIZE_OF_INT,crn); |
2347 printf("\tlwz %s,lo16(%d)(%s)\n",lregister_name_high(reg),offset,crn); | |
269 | 2348 } |
411 | 2349 #endif |
269 | 2350 } |
2351 | |
196 | 2352 int |
221 | 2353 code_lrindirect(int e1, int reg, int offset, int us) |
196 | 2354 { |
2355 char *crn; | |
222 | 2356 int creg0; |
2357 | |
196 | 2358 g_expr(e1); |
221 | 2359 if (!is_int_reg(creg)) error(-1); |
222 | 2360 crn=register_name(creg0=creg); |
221 | 2361 use_longlong(reg); |
269 | 2362 lload(creg0,reg,offset); |
206 | 2363 return us?ULONGLONG:LONGLONG; |
196 | 2364 } |
2365 #endif | |
2366 | |
89 | 2367 void |
103 | 2368 code_assign_gvar(int e2,int creg,int byte) { |
221 | 2369 use_int(creg); |
367 | 2370 code_ldf(cstore(byte),register_name(creg),cadr(e2), |
2371 get_ptr_cache((NMTBL*)caddr(e2))); | |
89 | 2372 } |
2373 | |
2374 void | |
103 | 2375 code_assign_lvar(int e2,int creg,int byte) { |
90 | 2376 char *crn; |
221 | 2377 use_int(creg); |
90 | 2378 crn=register_name(creg); |
119 | 2379 lvar_intro(e2); |
367 | 2380 printf("\t%s %s,",cstore(byte),crn); |
165 | 2381 lvar(e2); |
89 | 2382 } |
2383 | |
2384 void | |
111 | 2385 code_assign_register(int e2,int byte,int creg) { |
221 | 2386 use_int(creg); |
104 | 2387 if (e2!=creg) |
2388 printf("\tmr %s,%s\n",register_name(e2),register_name(creg)); | |
89 | 2389 } |
2390 | |
2391 void | |
118 | 2392 code_assign(int e2,int byte,int creg) { |
233 | 2393 char *drn; |
221 | 2394 char *crn; |
233 | 2395 use_int(e2); |
2396 drn=register_name(e2); | |
221 | 2397 use_int(creg); |
2398 crn=register_name(creg); | |
95 | 2399 |
367 | 2400 printf("\t%s %s,0(%s)\n",cstore(byte),crn,drn); |
89 | 2401 } |
2402 | |
2403 | |
2404 void | |
221 | 2405 code_register_assop(int e2,int reg, int op,int byte) { |
2406 // reg <= reg(e2) op=reg | |
2407 use_int(reg); | |
2408 tosop(op,e2,reg); | |
89 | 2409 } |
2410 | |
2411 void | |
221 | 2412 code_assop(int op,int creg, int byte,int sign) { |
90 | 2413 char *xrn,*crn,*drn; |
89 | 2414 int xreg; |
90 | 2415 int edx = get_register(); if(!edx) error(-1); |
221 | 2416 // (*creg) op = pop() |
2417 | |
2418 use_int(creg); | |
93 | 2419 xrn = register_name(xreg = emit_pop(0)); /* pop e3 value */ |
285 | 2420 #if 1 |
2421 set_ireg(edx,0); | |
2422 ld_indexx(byte,0,creg,ireg,sign); | |
338 | 2423 use_reg(creg); // to clear ptr cache |
285 | 2424 tosop(op,ireg,xreg); |
2425 crn = register_name(ireg); | |
2426 drn = register_name(creg); | |
2427 if (byte==1) { | |
2428 printf("\tstb %s,0(%s)\n",crn,drn); | |
2429 } else if (byte==SIZE_OF_SHORT) { | |
2430 printf("\tsth %s,0(%s)\n",crn,drn); | |
2431 } else { | |
2432 printf("\tstw %s,0(%s)\n",crn,drn); | |
2433 } | |
2434 free_register(creg); | |
2435 emit_pop_free(xreg); | |
2436 #else | |
468 | 2437 printf("## assop\n\tmr %s,%s\n",register_name(edx),register_name(creg)); |
221 | 2438 ld_indexx(byte,0,edx,creg,sign); |
2439 tosop(op,creg,xreg); | |
90 | 2440 crn = register_name(creg); |
2441 drn = register_name(edx); | |
165 | 2442 if (byte==1) { |
108 | 2443 printf("\tstb %s,0(%s)\n",crn,drn); |
245 | 2444 } else if (byte==SIZE_OF_SHORT) { |
165 | 2445 printf("\tsth %s,0(%s)\n",crn,drn); |
90 | 2446 } else { |
108 | 2447 printf("\tstw %s,0(%s)\n",crn,drn); |
90 | 2448 } |
2449 free_register(edx); | |
89 | 2450 emit_pop_free(xreg); |
285 | 2451 #endif |
89 | 2452 } |
2453 | |
2454 void | |
221 | 2455 tosop(int op,int creg,int oreg) |
89 | 2456 { |
221 | 2457 int dx = -1; |
252 | 2458 int ox = -1; |
95 | 2459 char *orn,*crn,*drn; |
221 | 2460 // creg = creg op oreg |
2461 | |
2462 use_int(creg); | |
103 | 2463 if(oreg==-1) { |
2464 error(-1); | |
2465 } else if (oreg<= -REG_LVAR_OFFSET) { | |
252 | 2466 ox = get_register(); if (ox<0) error(-1); |
2467 code_rlvar(oreg+REG_LVAR_OFFSET,ox); | |
2468 oreg = ox; | |
103 | 2469 } |
2470 | |
89 | 2471 switch(op) { |
2472 case LSHIFT: | |
2473 case ULSHIFT: | |
221 | 2474 shift("slw",creg,oreg); |
252 | 2475 if(ox!=-1) free_register(ox); |
89 | 2476 return; |
2477 case RSHIFT: | |
221 | 2478 shift("sraw",creg,oreg); |
252 | 2479 if(ox!=-1) free_register(ox); |
89 | 2480 return; |
2481 case URSHIFT: | |
221 | 2482 shift("srw",creg,oreg); |
252 | 2483 if(ox!=-1) free_register(ox); |
89 | 2484 return; |
2485 } | |
93 | 2486 orn = register_name(oreg); |
89 | 2487 crn = register_name(creg); |
2488 switch(op) { | |
2489 case ADD: | |
114 | 2490 printf("\tadd %s,%s,%s\n",crn,crn,orn); |
89 | 2491 break; |
2492 case SUB: | |
114 | 2493 printf("\tsub %s,%s,%s\n",crn,crn,orn); |
89 | 2494 break; |
112 | 2495 case CMP: |
291 | 2496 inc_cmpflag(); |
280 | 2497 printf("\tcmpw cr%d,%s,%s\n",cmpflag,crn,orn); |
2498 break; | |
2499 case UCMP: | |
291 | 2500 inc_cmpflag(); |
280 | 2501 printf("\tcmplw cr%d,%s,%s\n",cmpflag,crn,orn); |
112 | 2502 break; |
89 | 2503 case BAND: |
114 | 2504 printf("\tand %s,%s,%s\n",crn,crn,orn); |
89 | 2505 break; |
2506 case EOR: | |
114 | 2507 printf("\txor %s,%s,%s\n",crn,crn,orn); |
89 | 2508 break; |
2509 case BOR: | |
114 | 2510 printf("\tor %s,%s,%s\n",crn,crn,orn); |
89 | 2511 break; |
2512 case MUL: | |
116 | 2513 printf("\tmullw %s,%s,%s\n",crn,crn,orn); |
2514 break; | |
89 | 2515 case UMUL: |
114 | 2516 printf("\tmullw %s,%s,%s\n",crn,crn,orn); |
89 | 2517 break; |
2518 case DIV: | |
114 | 2519 printf("\tdivw %s,%s,%s\n",crn,crn,orn); |
90 | 2520 break; |
89 | 2521 case UDIV: |
114 | 2522 printf("\tdivwu %s,%s,%s\n",crn,crn,orn); |
89 | 2523 break; |
2524 case MOD: | |
90 | 2525 dx=get_register(); |
95 | 2526 drn = register_name(dx); |
116 | 2527 printf("\tdivw %s,%s,%s\n",drn,crn,orn); |
2528 printf("\tmullw %s,%s,%s\n",drn,drn,orn); | |
2529 printf("\tsubf %s,%s,%s\n",crn,drn,crn); | |
90 | 2530 break; |
89 | 2531 case UMOD: |
90 | 2532 dx=get_register(); |
95 | 2533 drn = register_name(dx); |
114 | 2534 printf("\tdivwu %s,%s,%s\n",drn,crn,orn); |
116 | 2535 printf("\tmullw %s,%s,%s\n",drn,drn,orn); |
2536 printf("\tsubf %s,%s,%s\n",crn,drn,crn); | |
89 | 2537 break; |
112 | 2538 default: |
2539 error(-1); | |
89 | 2540 } |
221 | 2541 if(dx!=-1) free_register(dx); |
252 | 2542 if(ox!=-1) free_register(ox); |
89 | 2543 } |
2544 | |
189 | 2545 int |
2546 code_const_op_p(int op,int v) | |
2547 { | |
240 | 2548 if (car(v)!=CONST) return 0; |
366 | 2549 if (op==DIV||op==UDIV) return ilog(v); |
2550 if (op==BAND||op==MOD||op==UMOD) return 0; | |
240 | 2551 v = cadr(v); |
214 | 2552 return (-32766<v&&v<32767); |
189 | 2553 } |
2554 | |
211 | 2555 void |
221 | 2556 oprtc(int op,int creg, int v) |
189 | 2557 { |
221 | 2558 char *crn; |
366 | 2559 int l; |
221 | 2560 use_int(creg); |
2561 crn = register_name(creg); | |
240 | 2562 v = cadr(v); |
221 | 2563 |
189 | 2564 switch(op) { |
2565 case LSHIFT: | |
2566 case ULSHIFT: | |
2567 printf("\tslwi %s,%s,%d\n",crn,crn,v); | |
2568 return; | |
366 | 2569 case DIV: |
2570 v = ilog(v); | |
189 | 2571 case RSHIFT: |
2572 printf("\tsrawi %s,%s,%d\n",crn,crn,v); | |
2573 return; | |
366 | 2574 case UDIV: |
2575 v = ilog(v); | |
189 | 2576 case URSHIFT: |
2577 printf("\tsrwi %s,%s,%d\n",crn,crn,v); | |
2578 return; | |
2579 case ADD: | |
2580 printf("\taddi %s,%s,lo16(%d)\n",crn,crn,v); | |
2581 break; | |
2582 case SUB: | |
221 | 2583 printf("\taddi %s,%s,lo16(-%d)\n",crn,crn,v); |
189 | 2584 break; |
2585 case CMP: | |
291 | 2586 inc_cmpflag(); |
280 | 2587 printf("\tcmpwi cr%d,%s,lo16(%d)\n",cmpflag,crn,v); |
189 | 2588 break; |
354 | 2589 case UCMP: |
2590 inc_cmpflag(); | |
2591 printf("\tcmplwi cr%d,%s,lo16(%d)\n",cmpflag,crn,v); | |
2592 break; | |
189 | 2593 case EOR: |
2594 printf("\txori %s,%s,lo16(%d)\n",crn,crn,v); | |
2595 break; | |
2596 case BOR: | |
2597 printf("\tori %s,%s,lo16(%d)\n",crn,crn,v); | |
2598 break; | |
2599 case MUL: | |
2600 case UMUL: | |
366 | 2601 if ((l=ilog(v))) { |
2602 printf("\tslwi %s,%s,%d\n",crn,crn,l); | |
2603 } else | |
2604 printf("\tmulli %s,%s,lo16(%d)\n",crn,crn,v); | |
189 | 2605 break; |
2606 default: | |
2607 error(-1); | |
2608 } | |
2609 } | |
89 | 2610 |
2611 void | |
221 | 2612 shift(char *op, int creg, int reg) |
89 | 2613 { |
221 | 2614 char *crn; |
93 | 2615 char *rrn = register_name(reg); |
221 | 2616 use_int(creg); |
2617 crn = register_name(creg); | |
186 | 2618 printf("\t%s %s,%s,%s\n",op,crn,crn,rrn); |
89 | 2619 } |
2620 | |
2621 void | |
221 | 2622 ld_indexx(int byte, int n, int xreg,int creg, int sign) |
89 | 2623 { |
221 | 2624 char *crn; |
2625 use_int(creg); | |
2626 crn = register_name(creg); | |
246 | 2627 printf("\t%s %s,%d(%s)\n",cload(byte),register_name(creg),n, |
90 | 2628 register_name(xreg)); |
246 | 2629 cext(sign,byte,creg); |
89 | 2630 } |
2631 | |
95 | 2632 int |
2633 code_csvalue() | |
2634 { | |
458 | 2635 return glist2(REGISTER,creg); |
95 | 2636 } |
2637 | |
89 | 2638 void |
287 | 2639 code_cmpdimm(int e, int csreg,int label,int cond) |
89 | 2640 { |
415 | 2641 int reg,regsv; |
89 | 2642 /* used in dosiwtch() */ |
291 | 2643 inc_cmpflag(); |
2644 if (-32767<e&&e<32767) { | |
2645 printf("\tcmpwi cr%d,%s,%d\n",cmpflag,register_name(csreg),e); | |
2646 jcond(label,cond); | |
2647 } else { | |
415 | 2648 regsv = regs[csreg]; regs[csreg]=USING_REG; |
366 | 2649 reg = get_register(); |
415 | 2650 regs[csreg]= regsv; |
405 | 2651 code_const(e,reg); |
366 | 2652 printf("\tcmpw cr%d,%s,%s\n",cmpflag,register_name(csreg),register_name(reg)); |
2653 jcond(label,cond); | |
2654 free_register(reg); | |
291 | 2655 } |
89 | 2656 } |
2657 | |
2658 void | |
2659 code_opening(char *filename) | |
2660 { | |
2661 printf("\t.file \"%s\"\n",filename); | |
108 | 2662 /* printf("\t.version\t\"01.01\"\n"); */ |
89 | 2663 /* printf("gcc2_compiled.:\n"); */ |
2664 printf(".text\n"); | |
2665 } | |
2666 | |
288 | 2667 #define CRBITSIZ 4 |
2668 | |
2669 static int | |
2670 rexpr_bool(int e1,int reg) | |
2671 { | |
2672 int t,flag=-1,eq=-1,neg=-1; | |
2673 char *rn; | |
2674 switch(car(e1)) { | |
2675 case GT: t=INT; flag = 2; break; | |
2676 case UGT: t=0; flag = 2; break; | |
2677 case GE: t=INT; flag = 2; eq=3; break; | |
2678 case UGE: t=0; flag = 2; eq=3; break; | |
2679 case LT: t=INT; flag = 1; break; | |
2680 case ULT: t=0; flag = 1; break; | |
2681 case LE: t=INT; flag = 1; eq=3; break; | |
2682 case ULE: t=0; flag = 1; eq=3; break; | |
2683 case EQ: t=INT; flag = 3; break; | |
289 | 2684 case NEQ: t=INT; flag = 3; neg=3; break; |
288 | 2685 default: return 0; |
2686 } | |
2687 g_expr(list3((t==INT?CMP:UCMP),cadr(e1),caddr(e1))); | |
2688 use_int(reg); | |
2689 rn = register_name(reg); | |
289 | 2690 t = CRBITSIZ*cmpflag; |
288 | 2691 if (eq>0) { |
289 | 2692 printf("\tcror %d,%d,%d\n",t+flag-1,t+eq-1,t+flag-1); |
2693 } | |
2694 if (neg>0) { | |
2695 neg = t+neg-1, | |
2696 printf("\tcrnor %d,%d,%d\n",neg,neg,neg); | |
288 | 2697 } |
2698 printf("\tmfcr %s\n",rn); | |
289 | 2699 printf("\trlwinm %s,%s,%d,1\n",rn,rn,t+flag); |
288 | 2700 return 1; |
2701 } | |
2702 | |
438
626d705471d5
Unexecuted code in conditional. Lazy jmp code generation.
kono
parents:
436
diff
changeset
|
2703 int |
280 | 2704 rexpr(int e1, int l1, int cond,int t) |
89 | 2705 { |
280 | 2706 char *s; |
433 | 2707 switch(car(e1)+BNOT*(!cond)) { |
2708 case GT: s=code_gt(1); break; | |
2709 case UGT: s=code_ugt(1); break; | |
2710 case GE: s=code_ge(1); break; | |
2711 case UGE: s=code_uge(1); break; | |
2712 case LT: s=code_ge(!1); break; | |
2713 case ULT: s=code_uge(!1);break; | |
2714 case LE: s=code_gt(!1); break; | |
2715 case ULE: s=code_ugt(!1);break; | |
2716 case EQ: s=code_eq(1); break; | |
2717 case NEQ: s=code_eq(!1); break; | |
2718 case GT+BNOT: s=code_gt(0); break; | |
2719 case UGT+BNOT: s=code_ugt(0); break; | |
2720 case GE+BNOT: s=code_ge(0); break; | |
2721 case UGE+BNOT: s=code_uge(0); break; | |
2722 case LT+BNOT: s=code_ge(!0); break; | |
2723 case ULT+BNOT: s=code_uge(!0);break; | |
2724 case LE+BNOT: s=code_gt(!0); break; | |
2725 case ULE+BNOT: s=code_ugt(!0);break; | |
2726 case EQ+BNOT: s=code_eq(0); break; | |
2727 case NEQ+BNOT: s=code_eq(!0); break; | |
280 | 2728 default: error(-1); |
2729 } | |
2730 g_expr(list3((t==INT?CMP:UCMP),cadr(e1),caddr(e1))); | |
2731 printf("\tb%s cr%d,L_%d\n",s,cmpflag,l1); | |
438
626d705471d5
Unexecuted code in conditional. Lazy jmp code generation.
kono
parents:
436
diff
changeset
|
2732 return l1; |
89 | 2733 } |
2734 | |
287 | 2735 static void |
89 | 2736 jcond(int l, char cond) |
2737 { | |
297 | 2738 if (cond==LT) { |
2739 printf("\tb%s cr%d,L_%d\n",code_ge(0),cmpflag,l); | |
2740 } else if (cond==1||cond==0) { | |
2741 printf("\tb%s cr%d,L_%d\n",cond?"ne":"eq",cmpflag,l); | |
2742 } else error(-1); | |
89 | 2743 } |
2744 | |
2745 void | |
2746 jmp(int l) | |
2747 { | |
102 | 2748 printf("\tb\tL_%d\n",l); |
89 | 2749 } |
2750 | |
327 | 2751 extern void |
456 | 2752 code_comment(char *s) |
89 | 2753 { |
307 | 2754 printf("## %s",s); |
89 | 2755 } |
2756 | |
2757 void | |
2758 code_enter(char *name) | |
2759 { | |
100
a9e6f2a2946f
Wrote all code for PowerPC and no compile error. Let's fix all bugs...
kono
parents:
99
diff
changeset
|
2760 if (output_mode!=TEXT_EMIT_MODE) |
516 | 2761 text_mode(0); |
100
a9e6f2a2946f
Wrote all code for PowerPC and no compile error. Let's fix all bugs...
kono
parents:
99
diff
changeset
|
2762 else |
108 | 2763 printf("\t.align 2\n"); |
89 | 2764 if (stmode!=STATIC) |
102 | 2765 printf(".globl _%s\n",name); |
126 | 2766 #ifdef DOT_SIZE |
89 | 2767 printf("\t.type\t%s,@function\n",name); |
126 | 2768 #endif |
101 | 2769 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
|
2770 code_disp_label=fwdlabel(); |
417 | 2771 #if 0 |
128 | 2772 printf("\tla r1,lo16(L_%d)(r30)\n",code_disp_label); |
417 | 2773 #else |
2774 printf("\tla r1,lo16(L_%d)(r30)\n",code_disp_label); | |
2775 printf("\taddis r1,r1,ha16(L_%d)\n",code_disp_label); | |
2776 #endif | |
126 | 2777 printf("\tbcl 20,31,L_%d\n",code_base = fwdlabel()); |
2778 fwddef(code_base); | |
2779 printf("\tmflr r31\n"); | |
119 | 2780 max_func_args = 0; |
489 | 2781 clear_ptr_cache(); |
89 | 2782 } |
2783 | |
2784 | |
2785 void | |
2786 code_enter1(int args) | |
2787 { | |
222 | 2788 // set_lreg(LREG_LREGISTER,0); |
207 | 2789 set_ireg(CREG_REGISTER,0); |
106 | 2790 set_freg(FREG_FREGISTER,0); |
89 | 2791 } |
2792 | |
2793 void | |
2794 code_leave(char *name) | |
2795 { | |
128 | 2796 int r1_offsetv; |
245 | 2797 disp&= -SIZE_OF_INT; |
449 | 2798 r1_offsetv = -disp+max_func_args*SIZE_OF_INT +code_disp_offset +8+32; |
128 | 2799 |
2800 printf(".set L_%d,%d\n",code_disp_label,-r1_offsetv); | |
417 | 2801 if (max_func_arg_label) { |
2802 printf(".set L_%d,%d\n",max_func_arg_label,max_func_args*SIZE_OF_INT+24); | |
2803 max_func_arg_label = 0; | |
2804 } | |
89 | 2805 local_table(); |
208 | 2806 // free_all_register(); |
89 | 2807 } |
2808 | |
2809 void | |
2810 enter(char *name) | |
2811 { | |
100
a9e6f2a2946f
Wrote all code for PowerPC and no compile error. Let's fix all bugs...
kono
parents:
99
diff
changeset
|
2812 if (output_mode!=TEXT_EMIT_MODE) |
516 | 2813 text_mode(0); |
100
a9e6f2a2946f
Wrote all code for PowerPC and no compile error. Let's fix all bugs...
kono
parents:
99
diff
changeset
|
2814 else |
108 | 2815 printf("\t.align 2\n"); |
89 | 2816 if (stmode!=STATIC) |
101 | 2817 printf(".globl _%s\n",name); |
108 | 2818 /* |
100
a9e6f2a2946f
Wrote all code for PowerPC and no compile error. Let's fix all bugs...
kono
parents:
99
diff
changeset
|
2819 printf("\t.type\t%s,@function\n",name); |
108 | 2820 */ |
101 | 2821 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
|
2822 code_setup=fwdlabel(); |
a9e6f2a2946f
Wrote all code for PowerPC and no compile error. Let's fix all bugs...
kono
parents:
99
diff
changeset
|
2823 printf("\tmflr r0\n"); |
102 | 2824 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
|
2825 code_base=fwdlabel(); |
111 | 2826 fwddef(code_base); |
116 | 2827 r1_offset_label = fwdlabel(); |
2828 lvar_offset_label = fwdlabel(); | |
375 | 2829 #if 0 |
2830 printf("\taddi r30,r1,lo16(-L_%d)\n",lvar_offset_label); | |
116 | 2831 printf("\tstwu r1,lo16(-L_%d)(r1)\n",r1_offset_label); |
375 | 2832 // printf("\tmr r30,r1\n"); |
2833 #else | |
2834 printf("\taddi r30,r1,lo16(-L_%d)\n",lvar_offset_label); | |
2835 printf("\tlis r31,ha16(-L_%d)\n",r1_offset_label); | |
2836 printf("\taddi r31,r31,lo16(-L_%d)\n",r1_offset_label); | |
2837 printf("\tstwux r1,r1,r31\n"); | |
2838 #endif | |
100
a9e6f2a2946f
Wrote all code for PowerPC and no compile error. Let's fix all bugs...
kono
parents:
99
diff
changeset
|
2839 printf("\tmflr r31\n"); |
116 | 2840 max_func_args = 0; |
489 | 2841 clear_ptr_cache(); |
89 | 2842 } |
2843 | |
2844 void | |
2845 enter1() | |
2846 { | |
516 | 2847 text_mode(0); |
208 | 2848 // set_lreg(LREG_LREGISTER,0); |
207 | 2849 set_ireg(CREG_REGISTER,0); |
106 | 2850 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
|
2851 } |
a9e6f2a2946f
Wrote all code for PowerPC and no compile error. Let's fix all bugs...
kono
parents:
99
diff
changeset
|
2852 |
a9e6f2a2946f
Wrote all code for PowerPC and no compile error. Let's fix all bugs...
kono
parents:
99
diff
changeset
|
2853 int |
a9e6f2a2946f
Wrote all code for PowerPC and no compile error. Let's fix all bugs...
kono
parents:
99
diff
changeset
|
2854 reg_save_offset() |
a9e6f2a2946f
Wrote all code for PowerPC and no compile error. Let's fix all bugs...
kono
parents:
99
diff
changeset
|
2855 { |
108 | 2856 return -( |
245 | 2857 (REAL_MAX_REGISTER-(REG_VAR_BASE-max_reg_var))*SIZE_OF_INT+ |
2858 (REAL_MAX_FREGISTER-(FREG_VAR_BASE-max_freg_var))*SIZE_OF_DOUBLE | |
108 | 2859 ); |
89 | 2860 } |
2861 | |
2862 void | |
450
eaf9e2746c83
parallel assign for simple expr. (too complex solution)
kono
parents:
449
diff
changeset
|
2863 code_label_call(int l) |
eaf9e2746c83
parallel assign for simple expr. (too complex solution)
kono
parents:
449
diff
changeset
|
2864 { |
eaf9e2746c83
parallel assign for simple expr. (too complex solution)
kono
parents:
449
diff
changeset
|
2865 printf("\tbl\tL_%d\n",l); |
eaf9e2746c83
parallel assign for simple expr. (too complex solution)
kono
parents:
449
diff
changeset
|
2866 } |
eaf9e2746c83
parallel assign for simple expr. (too complex solution)
kono
parents:
449
diff
changeset
|
2867 |
eaf9e2746c83
parallel assign for simple expr. (too complex solution)
kono
parents:
449
diff
changeset
|
2868 void |
eaf9e2746c83
parallel assign for simple expr. (too complex solution)
kono
parents:
449
diff
changeset
|
2869 code_ret() |
eaf9e2746c83
parallel assign for simple expr. (too complex solution)
kono
parents:
449
diff
changeset
|
2870 { |
eaf9e2746c83
parallel assign for simple expr. (too complex solution)
kono
parents:
449
diff
changeset
|
2871 printf("\tblr\n"); |
eaf9e2746c83
parallel assign for simple expr. (too complex solution)
kono
parents:
449
diff
changeset
|
2872 } |
eaf9e2746c83
parallel assign for simple expr. (too complex solution)
kono
parents:
449
diff
changeset
|
2873 |
eaf9e2746c83
parallel assign for simple expr. (too complex solution)
kono
parents:
449
diff
changeset
|
2874 void |
89 | 2875 leave(int control, char *name) |
2876 { | |
130 | 2877 int retcont1=0,sz; |
128 | 2878 |
2879 if (max_freg_var>=0 && max_freg_var<=3) max_freg_var=3; | |
2880 reg_save = reg_save_offset(); | |
111 | 2881 |
100
a9e6f2a2946f
Wrote all code for PowerPC and no compile error. Let's fix all bugs...
kono
parents:
99
diff
changeset
|
2882 if (control) { |
108 | 2883 code_set_return_register(1); |
89 | 2884 } |
126 | 2885 if (retcont) { |
2886 if (control) jmp(retlabel); | |
128 | 2887 retcont1 = fwdlabel(); |
126 | 2888 fwddef(retcont); |
2889 if (cadr(fnptr->ty)==FLOAT||cadr(fnptr->ty)==DOUBLE) { | |
2890 printf("\tfmr f1,f31\n"); | |
128 | 2891 } else if (cadr(fnptr->ty)>0&&( |
2892 car(cadr(fnptr->ty))==STRUCT || | |
2893 car(cadr(fnptr->ty))==UNION)) { | |
2894 sz = size(cadr(fnptr->ty)); | |
2895 printf("\tli r7,%d\n",sz); | |
2896 printf("\tsubl r6,r7,r30\n"); | |
245 | 2897 printf("\tlwz r3,lo16(%d)(r30)\n",(my_func_args-1)*SIZE_OF_INT); |
128 | 2898 emit_copy(6,3,sz,0,1,1); |
126 | 2899 } else if (cadr(fnptr->ty)!=VOID) { |
2900 printf("\tmr r3,r29\n"); | |
2901 } | |
128 | 2902 #if !R1SAVE |
2903 printf("\tla r1,lo16(%d)(r30)\n", | |
245 | 2904 -reg_save+my_func_args*SIZE_OF_INT); |
128 | 2905 #endif |
2906 printf("\tb L_%d\n",retcont1); | |
126 | 2907 } |
89 | 2908 fwddef(retlabel); |
100
a9e6f2a2946f
Wrote all code for PowerPC and no compile error. Let's fix all bugs...
kono
parents:
99
diff
changeset
|
2909 printf("\tlwz r1,0(r1)\n"); |
128 | 2910 if (retcont) { |
2911 fwddef(retcont1); | |
2912 } | |
110 | 2913 if (max_freg_var>=0) { |
2914 printf("\tlmw r%d,%d(r1)\n", | |
111 | 2915 REG_VAR_BASE-max_reg_var,reg_save); |
2916 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
|
2917 printf("\tb restFP+%d ; restore f%d-f31\n", |
111 | 2918 freg_save, |
100
a9e6f2a2946f
Wrote all code for PowerPC and no compile error. Let's fix all bugs...
kono
parents:
99
diff
changeset
|
2919 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
|
2920 } else { |
a9e6f2a2946f
Wrote all code for PowerPC and no compile error. Let's fix all bugs...
kono
parents:
99
diff
changeset
|
2921 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
|
2922 printf("\tmtlr r0\n"); |
110 | 2923 printf("\tlmw r%d,%d(r1)\n", |
116 | 2924 REG_VAR_BASE-max_reg_var,reg_save); |
450
eaf9e2746c83
parallel assign for simple expr. (too complex solution)
kono
parents:
449
diff
changeset
|
2925 code_ret(); |
100
a9e6f2a2946f
Wrote all code for PowerPC and no compile error. Let's fix all bugs...
kono
parents:
99
diff
changeset
|
2926 } |
89 | 2927 |
245 | 2928 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
|
2929 fwddef(code_setup); |
110 | 2930 printf("\tstmw r%d,%d(r1)\n", |
116 | 2931 REG_VAR_BASE-max_reg_var,reg_save); |
110 | 2932 printf("\tstw r0,8(r1)\n"); |
2933 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
|
2934 printf("\tb saveFP+%d ; save f%d-f31\n", |
111 | 2935 freg_save, |
100
a9e6f2a2946f
Wrote all code for PowerPC and no compile error. Let's fix all bugs...
kono
parents:
99
diff
changeset
|
2936 FREG_VAR_BASE-max_freg_var); |
110 | 2937 else { |
100
a9e6f2a2946f
Wrote all code for PowerPC and no compile error. Let's fix all bugs...
kono
parents:
99
diff
changeset
|
2938 printf("\tblr\n"); |
110 | 2939 } |
100
a9e6f2a2946f
Wrote all code for PowerPC and no compile error. Let's fix all bugs...
kono
parents:
99
diff
changeset
|
2940 |
116 | 2941 code_offset_set(); |
89 | 2942 local_table(); |
2943 labelno++; | |
208 | 2944 // free_all_register(); |
89 | 2945 } |
2946 | |
2947 | |
2948 void | |
107 | 2949 code_set_return_register(int mode) { |
111 | 2950 if (cadr(fnptr->ty)==DOUBLE||cadr(fnptr->ty)==FLOAT) { |
107 | 2951 set_freg(RET_FREGISTER,mode); |
206 | 2952 } else if (cadr(fnptr->ty)==LONGLONG||cadr(fnptr->ty)==ULONGLONG) { |
2953 set_lreg(RET_LREGISTER,mode); | |
147 | 2954 } else if (cadr(fnptr->ty)==VOID) { |
103 | 2955 } else { |
207 | 2956 set_ireg(RET_REGISTER,mode); |
103 | 2957 } |
89 | 2958 } |
2959 | |
187 | 2960 int |
2961 code_get_fixed_creg(int reg,int type) { | |
2962 return creg; | |
2963 } | |
2964 | |
89 | 2965 void |
187 | 2966 code_set_fixed_creg(int reg,int mode,int type) { |
108 | 2967 if (type==FLOAT||type==DOUBLE) { |
187 | 2968 set_freg(reg,mode); |
206 | 2969 } else if (type==LONGLONG||type==ULONGLONG) { |
195 | 2970 set_lreg(reg,mode); |
210 | 2971 // use_reg(reg); |
108 | 2972 } else { |
207 | 2973 set_ireg(reg,mode); |
108 | 2974 } |
107 | 2975 } |
2976 | |
2977 void | |
89 | 2978 gen_gdecl(char *n, int gpc) |
2979 { | |
102 | 2980 /* |
89 | 2981 if (stmode!=STATIC) |
99 | 2982 printf(".globl _%s\n",n); |
102 | 2983 */ |
89 | 2984 } |
2985 | |
340 | 2986 extern void |
2987 ascii(char *s) | |
2988 { | |
517 | 2989 cstring_mode(); |
340 | 2990 printf("\t.ascii \""); |
2991 while(*s) { | |
2992 if (*s=='\n') | |
2993 printf("%cn",92); | |
2994 else if (*s<' ') | |
2995 printf("%c%03o",92,*s); | |
2996 else if (*s=='\\') | |
2997 printf("\\\\"); | |
2998 else if (*s==34) | |
2999 printf("%c%c",92,34); | |
3000 else | |
3001 printf("%c",*s); | |
3002 s++; | |
3003 } | |
3004 printf("\\0%c\n\t.align 2\n",34); | |
3005 } | |
3006 | |
3007 extern int | |
3008 emit_string_label() { | |
3009 int lb; | |
3010 | |
3011 lb=fwdlabel(); | |
516 | 3012 cstring_mode(); |
340 | 3013 printf("L_%d:\n",lb); |
3014 return lb; | |
3015 } | |
3016 | |
518 | 3017 extern void |
3018 emit_string(char *s,int t) | |
3019 { | |
3020 t = type_value(t); | |
3021 if (car(t)==ARRAY && | |
3022 (type_value(cadr(t))==CHAR||type_value(cadr(t))==UCHAR)) { | |
3023 ascii(s); | |
3024 } else { | |
3025 int l = emit_string_label(); | |
3026 ascii(s); | |
3027 emit_label(l); | |
3028 } | |
3029 return; | |
3030 } | |
3031 | |
415 | 3032 void |
89 | 3033 align(int t) |
3034 { | |
415 | 3035 int d; |
3036 switch(t) { | |
3037 case CHAR: case UCHAR: return; | |
3038 case SHORT: case USHORT: d = data_alignment & 1; break; | |
3039 default: d = data_alignment & 3; | |
3040 } | |
3041 if (d) { | |
3042 printf("\t.align 2\n"); | |
3043 data_alignment = 0; | |
89 | 3044 } |
3045 } | |
3046 | |
516 | 3047 void |
517 | 3048 emit_global(NMTBL *n,int a,int e) |
340 | 3049 { |
517 | 3050 int t = type_value(n->ty); |
3051 if (e>0 && car(e)==STRING && t>0 && car(t)==ARRAY && | |
3052 (type_value(cadr(t))==CHAR||type_value(cadr(t))==UCHAR)) { | |
3053 cstring_mode(); | |
3054 } else | |
3055 data_mode(n->nm); | |
542 | 3056 if (n && n->sc!=STATIC) |
3057 printf("\t.globl\t_%s\n",n->nm); | |
516 | 3058 printf("_%s:\n",n->nm); |
340 | 3059 } |
3060 | |
3061 extern void | |
3062 emit_space(int sp) | |
3063 { | |
3064 data_mode(0); | |
3065 printf("\t.space\t%d\n",sp); | |
3066 } | |
3067 | |
3068 extern void | |
3069 emit_char(int d) | |
89 | 3070 { |
340 | 3071 data_mode(0); |
3072 printf("\t.byte %d\n",d); | |
3073 } | |
3074 | |
3075 extern void | |
3076 emit_short(int d) | |
3077 { | |
3078 data_mode(0); | |
3079 printf("\t.short %d\n",d); | |
3080 } | |
3081 | |
3082 extern void | |
3083 emit_int(int d) | |
3084 { | |
3085 data_mode(0); | |
3086 printf("\t.long %d\n",d); | |
3087 } | |
3088 | |
3089 extern void | |
3090 emit_longlong(int e) | |
3091 { | |
206 | 3092 #if LONGLONG_CODE |
341 | 3093 long long d = lcadr(e); |
340 | 3094 data_mode(0); |
411 | 3095 #if ENDIAN_L==0 |
3096 printf("\t.long\t0x%x,0x%x\n",code_l1(d),code_l2(d)); | |
3097 #else | |
340 | 3098 printf("\t.long\t0x%x,0x%x\n",code_l2(d),code_l1(d)); |
195 | 3099 #endif |
411 | 3100 #endif |
340 | 3101 } |
3102 | |
3103 extern void | |
3104 emit_double(int e) | |
3105 { | |
195 | 3106 #if FLOAT_CODE |
341 | 3107 double d = dcadr(e); |
340 | 3108 data_mode(0); |
411 | 3109 #if ENDIAN_D==0 |
3110 printf("\t.long\t0x%x,0x%x\n",code_d1(d),code_d2(d)); | |
3111 #else | |
340 | 3112 printf("\t.long\t0x%x,0x%x\n",code_d2(d),code_d1(d)); |
339 | 3113 #endif |
411 | 3114 #endif |
340 | 3115 } |
3116 | |
3117 extern void | |
3118 emit_float(int e) | |
3119 { | |
3120 #if FLOAT_CODE | |
341 | 3121 float f = dcadr(e); |
340 | 3122 data_mode(0); |
3123 printf("\t.long\t0x%x\n",*(int *)&f); | |
3124 #endif | |
3125 } | |
3126 | |
3127 extern void | |
367 | 3128 emit_address(char *s,int offset) |
340 | 3129 { |
3130 data_mode(0); | |
367 | 3131 if (offset) |
3132 printf("\t.long _%s+%d\n",s,offset); | |
3133 else | |
3134 printf("\t.long _%s\n",s); | |
340 | 3135 } |
3136 | |
3137 extern void | |
3138 emit_label(int labelno) | |
3139 { | |
3140 data_mode(0); | |
3141 printf("\t.long L_%d\n",labelno); | |
3142 } | |
3143 | |
3144 extern void | |
89 | 3145 emit_data_closing(NMTBL *n) |
3146 { | |
126 | 3147 #ifdef DOT_SIZE |
89 | 3148 int lb; |
126 | 3149 #endif |
89 | 3150 if (mode==GDECL) { |
3151 data_mode(0); | |
126 | 3152 #ifdef DOT_SIZE |
89 | 3153 lb=fwdlabel(); |
102 | 3154 printf("L_%d:\n",lb); |
3155 printf("\t.size\t%s,L_%d-%s\n",n->nm,lb,n->nm); | |
126 | 3156 #endif |
89 | 3157 } |
3158 } | |
3159 | |
3160 void | |
3161 global_table(void) | |
3162 { | |
3163 NMTBL *n; | |
98 | 3164 int init; char *extrn; |
89 | 3165 init=0; |
350 | 3166 for(n = global_list;n!=&null_nptr;n = n->next) { |
109 | 3167 if ((n->sc == GVAR) && n->dsp != -1) { |
89 | 3168 /* n->dsp = -1 means initialized global */ |
3169 if (init==0) { | |
3170 data_mode(0); | |
3171 init=1; | |
3172 } | |
97 | 3173 printf(".comm _%s,%d\n",n->nm,size(n->ty)); |
109 | 3174 } else if ((n->sc==STATIC) && n->dsp != -1) { |
3175 /* n->dsp = -1 means initialized global */ | |
3176 if (init==0) { | |
3177 data_mode(0); | |
3178 init=1; | |
3179 } | |
3180 printf(".lcomm _%s,%d\n",n->nm,size(n->ty)); | |
97 | 3181 } |
3182 } | |
350 | 3183 for(n = global_list;n!=&null_nptr;n = n->next) { |
103 | 3184 if (is_code(n)||is_function(n)) { |
97 | 3185 extrn = n->nm; |
103 | 3186 if (n->sc==EXTRN1) { |
3187 data_mode(0); | |
3188 printf(".picsymbol_stub\n"); | |
97 | 3189 printf("L_%s$stub:\n",extrn); |
3190 printf("\t.indirect_symbol _%s\n",extrn); | |
3191 printf("\tmflr r0\n"); | |
3192 printf("\tbcl 20,31,L0$_%s\n",extrn); | |
3193 printf("L0$_%s:\n",extrn); | |
3194 printf("\tmflr r11\n"); | |
3195 printf("\taddis r11,r11,ha16(L_%s$lazy_ptr-L0$_%s)\n",extrn,extrn); | |
3196 printf("\tmtlr r0\n"); | |
3197 printf("\tlwz r12,lo16(L_%s$lazy_ptr-L0$_%s)(r11)\n",extrn,extrn); | |
3198 printf("\tmtctr r12\n"); | |
3199 printf("\taddi r11,r11,lo16(L_%s$lazy_ptr-L0$_%s)\n",extrn,extrn); | |
3200 printf("\tbctr\n"); | |
3201 printf(".data\n"); | |
3202 printf(".lazy_symbol_pointer\n"); | |
3203 printf("L_%s$lazy_ptr:\n",extrn); | |
3204 printf("\t.indirect_symbol _%s\n",extrn); | |
3205 printf("\t.long dyld_stub_binding_helper\n"); | |
103 | 3206 } else if (n->sc==FUNCTION||n->sc==CODE) { |
516 | 3207 text_mode(0); |
103 | 3208 printf("\t.set L_%s$stub,_%s\n",extrn,extrn); |
109 | 3209 data_mode(0); |
111 | 3210 printf("L_%s$non_lazy_ptr:\n\t.long\t_%s\n",extrn,extrn); |
108 | 3211 } |
97 | 3212 } |
3213 } | |
109 | 3214 init=0; |
350 | 3215 for(n = global_list;n!=&null_nptr;n = n->next) { |
109 | 3216 if (n->sc == GVAR) { |
3217 if (init==0) { | |
119 | 3218 printf(".data\n"); |
109 | 3219 init=1; |
3220 } | |
116 | 3221 printf("L_%s$non_lazy_ptr:\n\t.long\t_%s\n",n->nm,n->nm); |
109 | 3222 } |
3223 } | |
97 | 3224 init = 0; |
350 | 3225 for(n = global_list;n!=&null_nptr;n = n->next) { |
453 | 3226 if ((is_code(n)||is_function(n))&& |
3227 !has_attr(n,FNAME)) // not used as value | |
3228 continue; | |
109 | 3229 if (n->sc==EXTRN1) { |
97 | 3230 if(init==0) { |
119 | 3231 printf(".data\n"); |
97 | 3232 printf(".non_lazy_symbol_pointer\n"); |
3233 init=1; | |
3234 } | |
3235 printf("L_%s$non_lazy_ptr:\n",n->nm); | |
3236 printf("\t.indirect_symbol _%s\n",n->nm); | |
3237 printf("\t.long\t0\n"); | |
89 | 3238 } |
3239 } | |
3240 } | |
3241 | |
3242 void | |
3243 local_table(void) | |
3244 { | |
3245 NMTBL *n; | |
3246 int init; | |
3247 init=0; | |
3248 /* static local variables */ | |
350 | 3249 for(n = local_static_list;n!=&null_nptr;n = n->next) { |
89 | 3250 if (n->sc == GVAR) { |
3251 if (init==0) { | |
3252 data_mode(0); | |
3253 init=1; | |
3254 } | |
156 | 3255 if (n->dsp != -1) /* initialized static */ |
3256 printf(".lcomm _%s,%d\n",n->nm,size(n->ty)); | |
3257 printf("L_%s$non_lazy_ptr:\n\t.long\t_%s\n",n->nm,n->nm); | |
89 | 3258 } |
3259 } | |
3260 } | |
3261 | |
3262 void | |
516 | 3263 cstring_mode(int align) |
3264 { | |
3265 if (output_mode!=RODATA_EMIT_MODE) { | |
3266 printf(".cstring\n\t.align 2\n"); | |
3267 output_mode = RODATA_EMIT_MODE; | |
3268 } | |
3269 } | |
3270 | |
3271 void | |
3272 text_mode(int align) | |
89 | 3273 { |
3274 if (output_mode!=TEXT_EMIT_MODE) { | |
3275 printf(".text\n"); | |
3276 printf("\t.align 2\n"); | |
3277 output_mode = TEXT_EMIT_MODE; | |
3278 } | |
3279 } | |
3280 | |
3281 void | |
3282 data_mode(char *name) | |
3283 { | |
3284 if (output_mode!=DATA_EMIT_MODE) { | |
3285 printf(".data\n"); | |
3286 output_mode = DATA_EMIT_MODE; | |
3287 } | |
108 | 3288 /* |
89 | 3289 if (name) |
3290 printf("\t.type\t%s,@object\n",name); | |
108 | 3291 */ |
89 | 3292 } |
3293 | |
195 | 3294 #if FLOAT_CODE |
3295 | |
89 | 3296 /* floating point */ |
3297 | |
96 | 3298 static int float_one_lib_used=0; |
3299 static char *float_one_lib[] = { | |
3300 ".data", | |
108 | 3301 /* ".literal8", */ |
96 | 3302 " .align 3", |
3303 "__float_one:", | |
3304 " .long 1065353216", | |
3305 ".text", | |
109 | 3306 /* ".set L__float_one$non_lazy_ptr,__float_one", */ |
96 | 3307 0 |
3308 }; | |
97 | 3309 static int float_zero_lib_used=0; |
3310 static char *float_zero_lib[] = { | |
3311 ".data", | |
108 | 3312 /* ".literal8", */ |
97 | 3313 " .align 3", |
3314 "__float_zero:", | |
3315 " .long 0", | |
3316 ".text", | |
109 | 3317 /* ".set L__float_zero$non_lazy_ptr,__float_zero", */ |
97 | 3318 0 |
3319 }; | |
3320 | |
89 | 3321 char * |
3322 fstore(int d) | |
3323 { | |
90 | 3324 return (d?"stfd":"stfs"); |
89 | 3325 } |
3326 | |
3327 char * | |
3328 fload(int d) | |
3329 { | |
90 | 3330 return d?"lfd":"lfs"; |
89 | 3331 } |
3332 | |
95 | 3333 void |
287 | 3334 code_cmp_dregister(int e2,int d,int label,int cond) |
95 | 3335 { |
99 | 3336 char *frn,*rrn,*grn; |
3337 int greg,r; | |
138 | 3338 grn = register_name(greg = get_dregister(d)); |
221 | 3339 use_float(d,e2); |
132 | 3340 frn = register_name(e2); |
99 | 3341 float_zero_lib_used=1; |
109 | 3342 r = get_ptr_cache(&float_zero); |
99 | 3343 rrn = register_name(r); |
108 | 3344 printf("\tlfs %s,0(%s)\n",grn,rrn); |
291 | 3345 inc_cmpflag(); |
280 | 3346 printf("\tfcmpu cr%d,%s,%s\n",cmpflag,grn,frn); |
147 | 3347 free_register(greg); |
287 | 3348 jcond(label,cond); |
99 | 3349 return; |
95 | 3350 } |
3351 | |
3352 void | |
138 | 3353 code_dregister(int e2,int freg,int d) |
95 | 3354 { |
221 | 3355 use_float(d,freg); |
147 | 3356 if (freg!=e2) { |
3357 if (is_int_reg(e2)) error(-1); | |
108 | 3358 printf("\tfmr %s,%s\n",fregister_name(freg),fregister_name(e2)); |
147 | 3359 } |
95 | 3360 } |
3361 | |
211 | 3362 void |
3363 code_dassign_gvar(int e2,int freg,int d) | |
89 | 3364 { |
221 | 3365 use_float(d,freg); |
367 | 3366 code_ldf(fstore(d),fregister_name(freg),cadr(e2), |
3367 get_ptr_cache((NMTBL*)caddr(e2))); | |
89 | 3368 } |
3369 | |
211 | 3370 void |
3371 code_dassign_lvar(int e2,int freg,int d) | |
89 | 3372 { |
221 | 3373 use_float(d,freg); |
119 | 3374 lvar_intro(e2); |
3375 printf("\t%s %s,",fstore(d),fregister_name(freg)); | |
3376 lvar(e2); | |
89 | 3377 } |
3378 | |
211 | 3379 void |
3380 code_dassign(int e2,int freg,int d) | |
89 | 3381 { |
221 | 3382 use_float(d,freg); |
108 | 3383 printf("\t%s %s,0(%s)\n",fstore(d),fregister_name(freg),register_name(e2)); |
89 | 3384 } |
3385 | |
111 | 3386 void |
138 | 3387 code_dassign_dregister(int e2,int d,int freg) { |
221 | 3388 use_float(d,freg); |
147 | 3389 if (e2!=freg) { |
111 | 3390 printf("\tfmr %s,%s\n",fregister_name(e2),fregister_name(freg)); |
147 | 3391 } |
111 | 3392 } |
3393 | |
89 | 3394 static double d0 = 1.0; |
3395 | |
3396 int | |
3397 code_d1(double d) | |
3398 { | |
3399 int *i = (int *)&d0; int *j = (int *)&d; | |
99 | 3400 return (i[1] == 0x3ff00000)?j[0]:j[1]; |
89 | 3401 } |
3402 | |
3403 int | |
3404 code_d2(double d) | |
3405 { | |
3406 int *i = (int *)&d0; int *j = (int *)&d; | |
99 | 3407 return (i[1] == 0x3ff00000)?j[1]:j[0]; |
89 | 3408 } |
3409 | |
133 | 3410 int |
3411 code_f(double d) | |
3412 { | |
3413 float f = d; | |
3414 int *j = (int *)&f; | |
3415 return *j; | |
3416 } | |
3417 | |
211 | 3418 void |
3419 | |
138 | 3420 code_dconst(int e2,int freg,int d) |
89 | 3421 { |
3422 int lb; | |
138 | 3423 double value = dcadr(e2); |
90 | 3424 int r; |
97 | 3425 char *rrn,*frn; |
221 | 3426 |
3427 use_float(d,freg); | |
97 | 3428 frn = fregister_name(freg); |
138 | 3429 if (value==0.0) { |
97 | 3430 float_zero_lib_used=1; |
109 | 3431 r = get_ptr_cache(&float_zero); |
98 | 3432 rrn = register_name(r); |
108 | 3433 printf("\tlfs %s,0(%s)\n",frn,rrn); |
97 | 3434 return; |
89 | 3435 } |
138 | 3436 if (value==1.0) { |
97 | 3437 float_one_lib_used=1; |
109 | 3438 r = get_ptr_cache(&float_one); |
98 | 3439 rrn = register_name(r); |
108 | 3440 printf("\tlfs %s,0(%s)\n",frn,rrn); |
97 | 3441 return; |
89 | 3442 } |
97 | 3443 rrn = register_name((r=get_register())); |
230 | 3444 use_reg(r); // to clear ptr cache |
108 | 3445 printf(" \t.data\n\t.align 3\n"); |
89 | 3446 lb=fwdlabel(); |
102 | 3447 printf("L_%d:\n",lb); |
138 | 3448 if (d) { |
411 | 3449 #if ENDIAN_D==0 |
3450 printf("\t.long\t0x%x,0x%x\n",code_d1(value),code_d2(value)); | |
3451 #else | |
138 | 3452 printf("\t.long\t0x%x,0x%x\n",code_d2(value),code_d1(value)); |
411 | 3453 #endif |
133 | 3454 } else { |
138 | 3455 printf("\t.long\t0x%x\n",code_f(value)); |
133 | 3456 } |
89 | 3457 if (output_mode==TEXT_EMIT_MODE) { |
3458 printf(".text\n"); | |
3459 } else { | |
516 | 3460 text_mode(0); |
89 | 3461 } |
102 | 3462 printf("\taddis %s,r31,ha16(L_%d-L_%d)\n",rrn,lb,code_base); |
3463 printf("\tla %s,lo16(L_%d-L_%d)(%s)\n",rrn,lb,code_base,rrn); | |
138 | 3464 if (d) { |
133 | 3465 printf("\tlfd %s,0(%s)\n",frn,rrn); |
3466 } else { | |
3467 printf("\tlfs %s,0(%s)\n",frn,rrn); | |
3468 } | |
90 | 3469 free_register(r); |
89 | 3470 } |
3471 | |
133 | 3472 |
211 | 3473 void |
3474 code_dneg(int freg,int d) | |
89 | 3475 { |
221 | 3476 char *frn; |
3477 use_float(d,freg); | |
3478 frn = fregister_name(freg); | |
95 | 3479 printf("\tfneg %s,%s\n",frn,frn); |
89 | 3480 } |
3481 | |
211 | 3482 void |
221 | 3483 code_d2i() |
89 | 3484 { |
147 | 3485 char *frn; |
3486 char *crn; | |
245 | 3487 int e2 = new_lvar(SIZE_OF_DOUBLE); |
147 | 3488 |
221 | 3489 use_double0(); |
3490 frn = fregister_name(freg); | |
3491 use_int0(); | |
147 | 3492 crn = register_name(creg); |
3493 | |
119 | 3494 free_lvar(e2); |
93 | 3495 printf("\tfctiwz %s,%s\n",frn,frn); |
119 | 3496 lvar_intro(e2); |
3497 printf("\tstfd %s,",frn); lvar(e2); | |
245 | 3498 lvar_intro(e2+SIZE_OF_DOUBLE-SIZE_OF_INT); |
3499 printf("\tlwz %s,",crn); lvar(e2+SIZE_OF_DOUBLE-SIZE_OF_INT); | |
89 | 3500 } |
3501 | |
91 | 3502 static int i2d_lib_used=0; |
3503 static char *i2d_lib[] = { | |
3504 ".data", | |
108 | 3505 /* ".literal8", */ |
91 | 3506 " .align 3", |
3507 "__i2dLC0:", | |
3508 " .long 1127219200", | |
3509 " .long -2147483648", | |
3510 ".text", | |
3511 " .align 2", | |
111 | 3512 "i2d_:", |
91 | 3513 " mflr r0", |
3514 " bcl 20,31,__i2dL1$pb", | |
3515 "__i2dL1$pb:", | |
3516 " mflr r10", | |
3517 " mtlr r0", | |
3518 " xoris r3,r3,0x8000", | |
375 | 3519 " stw r3,-28(r1)", |
91 | 3520 " lis r0,0x4330", |
375 | 3521 " stw r0,-32(r1)", |
3522 " lfd f0,-32(r1)", | |
91 | 3523 " addis r9,r10,ha16(__i2dLC0-__i2dL1$pb)", |
3524 " lfd f1,lo16(__i2dLC0-__i2dL1$pb)(r9)", | |
3525 " fsub f1,f0,f1", | |
3526 " blr", | |
3527 0 | |
3528 }; | |
3529 | |
211 | 3530 void |
221 | 3531 code_i2d() |
89 | 3532 { |
95 | 3533 i2d_lib_used = 1; |
113 | 3534 clear_ptr_cache(); |
3535 code_save_stacks(); | |
207 | 3536 set_ireg(RET_REGISTER,1); |
91 | 3537 printf("\tbl i2d_\n"); |
104 | 3538 set_freg(RET_FREGISTER,0); |
89 | 3539 } |
3540 | |
91 | 3541 static int d2u_lib_used=0; |
3542 static char *d2u_lib[] = { | |
108 | 3543 /* ".literal8", */ |
91 | 3544 " .align 3", |
3545 "__d2uLC0:", | |
3546 " .long 1105199104", | |
3547 " .long 0", | |
3548 ".text", | |
3549 " .align 2", | |
111 | 3550 "d2u_:", |
91 | 3551 " mflr r0", |
3552 " bcl 20,31,__d2uL1$pb", | |
3553 "__d2uL1$pb:", | |
3554 " mflr r10", | |
3555 " mtlr r0", | |
3556 " addis r9,r10,ha16(__d2uLC0-__d2uL1$pb)", | |
3557 " lfd f0,lo16(__d2uLC0-__d2uL1$pb)(r9)", | |
3558 " fcmpu cr0,f1,f0", | |
3559 " cror 2,1,2", | |
3560 " beq- cr0,__d2uL2", | |
3561 " fctiwz f0,f1", | |
375 | 3562 " stfd f0,-32(r1)", |
3563 " lwz r3,-28(r1)", | |
91 | 3564 " blr", |
3565 "__d2uL2:", | |
3566 " addis r9,r10,ha16(__d2uLC0-__d2uL1$pb)", | |
3567 " lfd f0,lo16(__d2uLC0-__d2uL1$pb)(r9)", | |
3568 " fsub f0,f1,f0", | |
3569 " fctiwz f0,f0", | |
375 | 3570 " stfd f0,-24(r1)", |
3571 " lwz r3,-20(r1)", | |
91 | 3572 " xoris r3,r3,0x8000", |
3573 " blr", | |
3574 0 | |
3575 }; | |
3576 | |
211 | 3577 void |
221 | 3578 code_d2u() |
89 | 3579 { |
113 | 3580 code_save_stacks(); |
3581 clear_ptr_cache(); | |
91 | 3582 d2u_lib_used=1; |
104 | 3583 set_freg(RET_FREGISTER,1); |
111 | 3584 printf("\tbl d2u_\n"); |
207 | 3585 set_ireg(RET_REGISTER,0); |
91 | 3586 } |
90 | 3587 |
91 | 3588 static int u2d_lib_used=0; |
3589 static char *u2d_lib[] = { | |
3590 ".data", | |
108 | 3591 /* ".literal8", */ |
91 | 3592 " .align 3", |
3593 "__u2dLC1:", | |
3594 " .long 1127219200", | |
3595 " .long 0", | |
3596 ".text", | |
3597 " .align 2", | |
111 | 3598 "u2d_:", |
91 | 3599 " mflr r0", |
3600 " bcl 20,31,__u2dL2$pb", | |
3601 "__u2dL2$pb:", | |
3602 " mflr r10", | |
3603 " mtlr r0", | |
375 | 3604 " stw r3,-28(r1)", |
91 | 3605 " lis r0,0x4330", |
375 | 3606 " stw r0,-32(r1)", |
3607 " lfd f0,-32(r1)", | |
91 | 3608 " addis r9,r10,ha16(__u2dLC1-__u2dL2$pb)", |
3609 " lfd f1,lo16(__u2dLC1-__u2dL2$pb)(r9)", | |
3610 " fsub f1,f0,f1", | |
3611 " blr", | |
3612 0 | |
3613 }; | |
89 | 3614 |
211 | 3615 void |
221 | 3616 code_u2d() |
89 | 3617 { |
113 | 3618 code_save_stacks(); |
3619 clear_ptr_cache(); | |
147 | 3620 u2d_lib_used = 1; |
207 | 3621 set_ireg(RET_REGISTER,1); |
111 | 3622 printf("\tbl u2d_\n"); |
228 | 3623 set_freg(RET_FREGISTER,0); |
89 | 3624 } |
3625 | |
211 | 3626 void |
221 | 3627 code_d2f() { } |
211 | 3628 void |
221 | 3629 code_f2d() { } |
211 | 3630 void |
221 | 3631 code_f2i() { code_d2i(); } |
211 | 3632 void |
221 | 3633 code_f2u() { code_d2u(); } |
211 | 3634 void |
221 | 3635 code_i2f() { code_i2d(); } |
211 | 3636 void |
221 | 3637 code_u2f() { code_u2d(); } |
211 | 3638 |
3639 void | |
3640 code_drgvar(int e2,int d,int freg) | |
89 | 3641 { |
221 | 3642 use_float(d,freg); |
367 | 3643 code_ldf(fload(d),fregister_name(freg),cadr(e2), |
3644 get_ptr_cache((NMTBL*)caddr(e2))); | |
89 | 3645 } |
3646 | |
3647 | |
211 | 3648 void |
3649 code_drlvar(int e2,int d,int freg) | |
89 | 3650 { |
221 | 3651 use_float(d,freg); |
119 | 3652 lvar_intro(e2); |
3653 printf("\t%s %s,",fload(d),fregister_name(freg)); lvar(e2); | |
89 | 3654 } |
3655 | |
211 | 3656 void |
287 | 3657 code_cmp_drgvar(int e2,int reg,int d,int label,int cond) |
89 | 3658 { |
221 | 3659 char *frn; |
138 | 3660 int g=get_dregister(d); |
97 | 3661 char *grn=fregister_name(g); |
221 | 3662 |
3663 use_float(d,reg); | |
3664 frn=fregister_name(reg); | |
3665 | |
367 | 3666 code_ldf(fload(1),grn,cadr(e2), |
3667 get_ptr_cache((NMTBL*)caddr(e2))); | |
291 | 3668 inc_cmpflag(); |
280 | 3669 printf("\tfcmpu cr%d,%s,%s\n",cmpflag,frn,grn); |
147 | 3670 free_register(g); |
287 | 3671 jcond(label,cond); |
89 | 3672 } |
3673 | |
211 | 3674 void |
287 | 3675 code_cmp_drlvar(int e2,int reg,int d,int label,int cond) |
89 | 3676 { |
221 | 3677 char *frn; |
138 | 3678 int g=get_dregister(d); |
97 | 3679 char *grn=fregister_name(g); |
108 | 3680 |
221 | 3681 use_float(d,reg); |
3682 frn=fregister_name(reg); | |
3683 | |
119 | 3684 lvar_intro(e2); |
3685 printf("\t%s %s,",fload(1),grn); lvar(e2); | |
291 | 3686 inc_cmpflag(); |
280 | 3687 printf("\tfcmpu cr%d,%s,%s\n",cmpflag,frn,grn); |
147 | 3688 free_register(g); |
287 | 3689 jcond(label,cond); |
89 | 3690 } |
3691 | |
211 | 3692 void |
273 | 3693 dtosop(int op,int reg,int oreg) |
89 | 3694 { |
127 | 3695 char *opn=""; |
221 | 3696 char *frn; |
273 | 3697 char *grn; |
3698 int ox = -1; | |
221 | 3699 |
3700 use_float(1,reg); | |
273 | 3701 if(oreg==-1) { |
3702 error(-1); | |
3703 } else if (oreg<= -REG_LVAR_OFFSET) { | |
3704 ox = get_dregister(1); if (ox<0) error(-1); | |
3705 use_reg(ox); | |
3706 code_drlvar(oreg+REG_LVAR_OFFSET,1,ox); | |
3707 oreg = ox; | |
3708 } | |
3709 grn=fregister_name(oreg); | |
221 | 3710 frn=fregister_name(reg); |
89 | 3711 switch(op) { |
133 | 3712 case FADD: |
91 | 3713 case DADD: opn="fadd"; break; |
133 | 3714 case FSUB: |
101 | 3715 case DSUB: opn="fsub"; break; |
133 | 3716 case FDIV: |
101 | 3717 case DDIV: opn="fdiv"; break; |
133 | 3718 case FMUL: |
101 | 3719 case DMUL: opn="fmul"; break; |
133 | 3720 case FCMP: |
91 | 3721 case DCMP: |
291 | 3722 inc_cmpflag(); |
288 | 3723 printf("\tfcmpu cr%d,%s,%s\n",cmpflag,frn,grn); |
273 | 3724 if (ox!=-1) free_register(ox); |
101 | 3725 return; |
133 | 3726 case FCMPGE: |
91 | 3727 case DCMPGE: |
291 | 3728 inc_cmpflag(); |
288 | 3729 printf("\tfcmpu cr%d,%s,%s\n",cmpflag,frn,grn); |
273 | 3730 if (ox!=-1) free_register(ox); |
101 | 3731 return; |
133 | 3732 default: |
3733 error(-1); return; | |
89 | 3734 } |
91 | 3735 printf("\t%s %s,%s,%s\n",opn,frn,frn,grn); |
273 | 3736 if (ox!=-1) free_register(ox); |
89 | 3737 } |
3738 | |
3739 void | |
221 | 3740 code_dassop(int op,int reg,int d) { |
91 | 3741 /* we have lvalue in creg, applied floating value is in freg */ |
221 | 3742 // (*creg) op = pop() |
138 | 3743 int xreg=emit_dpop(d); |
221 | 3744 char *crn; |
209 | 3745 char *frn; |
221 | 3746 |
3747 crn=register_name(ireg); | |
3748 use_float(d,reg); | |
3749 frn =fregister_name(reg); | |
209 | 3750 |
108 | 3751 printf("\t%s %s,0(%s)\n",fload(d),frn,crn); |
221 | 3752 dtosop(op,reg,xreg); |
108 | 3753 printf("\t%s %s,0(%s)\n",fstore(d),frn,crn); |
138 | 3754 emit_dpop_free(xreg,d); |
89 | 3755 } |
3756 | |
219 | 3757 void |
3758 code_register_dassop(int reg,int op,int d) { | |
221 | 3759 // reg op= dpop() |
219 | 3760 int xreg=emit_dpop(d); |
221 | 3761 dtosop(op,reg,xreg); |
3762 emit_dpop_free(xreg,d); | |
219 | 3763 } |
91 | 3764 |
273 | 3765 static int |
3766 code_dload_1(int d) | |
3767 { | |
3768 int r,g; | |
3769 char *drn,*grn; | |
3770 // load 1 | |
3771 float_one_lib_used=1; | |
3772 r = get_ptr_cache(&float_one); | |
3773 drn=register_name(r); | |
3774 grn=fregister_name(g=get_dregister(d)); | |
3775 printf("\tlfs %s,0(%s)\n",grn,drn); | |
3776 return g; | |
3777 } | |
3778 | |
89 | 3779 void |
107 | 3780 code_dpreinc(int e1,int e2,int d,int reg) { |
273 | 3781 char *frn,*crn,*grn; |
91 | 3782 int g; |
3783 | |
144 | 3784 if (car(e2)==DREGISTER||car(e2)==FREGISTER) { |
221 | 3785 crn=register_name(cadr(e2)); |
273 | 3786 grn = fregister_name(g = code_dload_1(d)); |
3787 if (reg==USE_CREG) { | |
3788 reg=get_dregister(d); if (!reg) error(-1); | |
3789 set_freg(reg,0); | |
3790 } | |
3791 frn=fregister_name(reg); | |
3792 printf("\t%s %s,%s,%s\n",(caddr(e1)>0)?"fadd":"fsub",crn,crn,grn); | |
3793 if (use && reg!=cadr(e2)) | |
3794 printf("\tfmr %s,%s\n",frn,crn); | |
221 | 3795 } else { |
3796 g_expr(e2); | |
3797 if (!is_int_reg(creg)) error(-1); | |
3798 crn=register_name(ireg); | |
273 | 3799 if (reg==USE_CREG) { |
3800 reg=get_dregister(d); if (!reg) error(-1); | |
3801 set_freg(reg,0); | |
3802 } | |
3803 frn=fregister_name(reg); | |
3804 grn = fregister_name(g = code_dload_1(d)); | |
221 | 3805 printf("\t%s %s,0(%s)\n",fload(d),frn,crn); |
3806 printf("\t%s %s,%s,%s\n",(caddr(e1)>0)?"fadd":"fsub",frn,frn,grn); | |
3807 printf("\t%s %s,0(%s)\n",fstore(d),frn,crn); | |
3808 } | |
147 | 3809 free_register(g); |
89 | 3810 } |
3811 | |
3812 void | |
107 | 3813 code_dpostinc(int e1,int e2,int d,int reg) { |
273 | 3814 char *frn,*crn,*grn; |
91 | 3815 int g; |
3816 | |
144 | 3817 if (car(e2)==DREGISTER||car(e2)==FREGISTER) { |
221 | 3818 crn=register_name(cadr(e2)); |
273 | 3819 grn = fregister_name(g = code_dload_1(d)); |
3820 if (reg==USE_CREG) { | |
3821 reg=get_dregister(d); if (!reg) error(-1); | |
3822 set_freg(reg,0); | |
3823 } | |
3824 frn=fregister_name(reg); | |
3825 if (use && reg!=cadr(e2)) | |
3826 printf("\tfmr %s,%s\n",frn,crn); | |
3827 printf("\t%s %s,%s,%s\n",(caddr(e1)>0)?"fadd":"fsub",crn,crn,grn); | |
221 | 3828 } else { |
3829 g_expr(e2); | |
3830 if (!is_int_reg(creg)) error(-1); | |
273 | 3831 crn=register_name(ireg); |
3832 if (reg==USE_CREG) { | |
3833 reg=get_dregister(d); if (!reg) error(-1); | |
3834 set_freg(reg,0); | |
3835 } | |
3836 frn=fregister_name(reg); | |
3837 grn = fregister_name(g = code_dload_1(d)); | |
221 | 3838 printf("\t%s %s,0(%s)\n",fload(d),frn,crn); |
3839 printf("\t%s %s,%s,%s\n",(caddr(e1)>0)?"fadd":"fsub",grn,frn,grn); | |
3840 printf("\t%s %s,0(%s)\n",fstore(d),grn,crn); | |
3841 } | |
147 | 3842 free_register(g); |
89 | 3843 } |
3844 | |
288 | 3845 static int |
3846 drexpr_bool(int e1,int reg) | |
3847 { | |
289 | 3848 int flag=-1,eq=-1,neg=-1,t; |
288 | 3849 char *rn; |
3850 switch(car(e1)) { | |
3851 case DOP+GT: case FOP+GT: flag = 2; break; | |
3852 case DOP+GE: case FOP+GE: flag = 2; eq=3; break; | |
3853 case DOP+LT: case FOP+LT: flag = 1; break; | |
3854 case DOP+LE: case FOP+LE: flag = 1; eq=3; break; | |
3855 case DOP+EQ: case FOP+EQ: flag = 3; break; | |
289 | 3856 case DOP+NEQ: case FOP+NEQ: flag = 3; neg=3; break; |
288 | 3857 default: return 0; |
3858 } | |
3859 g_expr(list3(DCMP,cadr(e1),caddr(e1))); | |
3860 use_int(reg); | |
3861 rn = register_name(reg); | |
289 | 3862 t = CRBITSIZ*cmpflag; |
288 | 3863 if (eq>0) { |
289 | 3864 printf("\tcror %d,%d,%d\n",t+flag-1,t+eq-1,t+flag-1); |
3865 } | |
3866 if (neg>0) { | |
3867 neg = t+neg-1, | |
3868 printf("\tcrnor %d,%d,%d\n",neg,neg,neg); | |
288 | 3869 } |
3870 printf("\tmfcr %s\n",rn); | |
289 | 3871 printf("\trlwinm %s,%s,%d,1\n",rn,rn,t+flag); |
288 | 3872 return 1; |
3873 } | |
3874 | |
438
626d705471d5
Unexecuted code in conditional. Lazy jmp code generation.
kono
parents:
436
diff
changeset
|
3875 int |
229 | 3876 drexpr(int e1, int e2,int l1, int op,int cond) |
3877 { | |
231 | 3878 if (!cond) { |
229 | 3879 switch(op) { |
3880 case FOP+GT: | |
438
626d705471d5
Unexecuted code in conditional. Lazy jmp code generation.
kono
parents:
436
diff
changeset
|
3881 return drexpr(e2,e1,l1,FOP+GE,1); |
229 | 3882 case FOP+GE: |
438
626d705471d5
Unexecuted code in conditional. Lazy jmp code generation.
kono
parents:
436
diff
changeset
|
3883 return drexpr(e2,e1,l1,FOP+GT,1); |
229 | 3884 case FOP+EQ: |
3885 op=FOP+NEQ; break; | |
3886 case FOP+NEQ: | |
3887 op=FOP+EQ; break; | |
3888 case DOP+GT: | |
438
626d705471d5
Unexecuted code in conditional. Lazy jmp code generation.
kono
parents:
436
diff
changeset
|
3889 return drexpr(e2,e1,l1,DOP+GE,1); |
229 | 3890 case DOP+GE: |
438
626d705471d5
Unexecuted code in conditional. Lazy jmp code generation.
kono
parents:
436
diff
changeset
|
3891 return drexpr(e2,e1,l1,DOP+GT,1); |
229 | 3892 case DOP+EQ: |
3893 op=DOP+NEQ; break; | |
3894 case DOP+NEQ: | |
3895 op=DOP+EQ; break; | |
3896 } | |
3897 } | |
234 | 3898 g_expr(list3(DCMP, e1,e2)); |
89 | 3899 switch(op) { |
288 | 3900 case DOP+GT: case FOP+GT: |
3901 printf("\tbgt\tcr%d,L_%d\n",cmpflag,l1); | |
3902 break; | |
3903 case DOP+GE: case FOP+GE: | |
3904 printf("\tbge\tcr%d,L_%d\n",cmpflag,l1); | |
229 | 3905 break; |
288 | 3906 case DOP+EQ: case FOP+EQ: |
3907 printf("\tbeq\tcr%d,L_%d\n",cmpflag,l1); | |
89 | 3908 break; |
288 | 3909 case DOP+NEQ: case FOP+NEQ: |
3910 printf("\tbne\tcr%d,L_%d\n",cmpflag,l1); | |
89 | 3911 break; |
3912 } | |
438
626d705471d5
Unexecuted code in conditional. Lazy jmp code generation.
kono
parents:
436
diff
changeset
|
3913 return l1; |
89 | 3914 } |
3915 | |
138 | 3916 int emit_dpop(int d) |
89 | 3917 { |
114 | 3918 int xreg,reg; |
97 | 3919 xreg=pop_fregister(); |
3920 if (xreg<= -REG_LVAR_OFFSET) { | |
138 | 3921 reg = get_dregister(d); |
119 | 3922 code_drlvar(REG_LVAR_OFFSET+xreg,1,reg); |
117 | 3923 free_lvar(REG_LVAR_OFFSET+xreg); |
205 | 3924 xreg=reg; |
96 | 3925 } |
3926 return xreg; | |
89 | 3927 } |
3928 | |
211 | 3929 void |
3930 emit_dpop_free(int e1,int d) | |
89 | 3931 { |
147 | 3932 free_register(e1); |
89 | 3933 } |
3934 | |
211 | 3935 void |
3936 emit_dpush(int d) | |
89 | 3937 { |
97 | 3938 int new_reg; |
221 | 3939 if (!is_float_reg(creg)) error(-1); |
102 | 3940 if (freg_sp>MAX_MAX) error(-1); |
221 | 3941 new_reg = get_dregister(1); /* ���Ф˼��� */ |
97 | 3942 freg_stack[freg_sp++] = freg; /* push ���뤫���˥쥸������Ȥ� */ |
147 | 3943 creg = freg = new_reg; |
89 | 3944 } |
3945 | |
195 | 3946 #endif |
3947 | |
3948 #if LONGLONG_CODE | |
3949 | |
3950 | |
3951 /* 64bit int part */ | |
219 | 3952 static void |
530 | 3953 lmove(int to,int from) // to <= from |
219 | 3954 { |
227 | 3955 int tmp; |
3956 if (regv_h(to)==regv_l(from)&&(regv_l(to)==regv_h(from))) { | |
3957 tmp = get_register(); | |
228 | 3958 printf("\tmr %s,%s\n",register_name(tmp),lregister_name_low(from)); |
227 | 3959 printf("\tmr %s,%s\n",lregister_name_high(to),lregister_name_high(from)); |
3960 printf("\tmr %s,%s\n",lregister_name_low(to),register_name(tmp)); | |
3961 free_register(tmp); | |
3962 } else if (regv_h(to)==regv_l(from)) { | |
226 | 3963 printf("\tmr %s,%s\n",lregister_name_low(to),lregister_name_low(from)); |
3964 printf("\tmr %s,%s\n",lregister_name_high(to),lregister_name_high(from)); | |
3965 } else { | |
3966 printf("\tmr %s,%s\n",lregister_name_high(to),lregister_name_high(from)); | |
3967 printf("\tmr %s,%s\n",lregister_name_low(to),lregister_name_low(from)); | |
3968 } | |
219 | 3969 } |
195 | 3970 |
211 | 3971 static void |
280 | 3972 pcond(char *s,int cmpflag,int l1) |
3973 { | |
3974 printf("\tb%s cr%d,L_%d\n",s,cmpflag,l1); | |
3975 } | |
3976 | |
3977 static int | |
3978 lcmp(int op,int cond) | |
210 | 3979 { |
280 | 3980 if (op==LOP+UGT||op==LOP+UGE) { |
3981 return UCMP; | |
3982 } else if (op==LOP+LE||op==LOP+GE) { | |
3983 return CMP; | |
3984 } else { | |
3985 return CMP; | |
3986 } | |
210 | 3987 } |
3988 | |
438
626d705471d5
Unexecuted code in conditional. Lazy jmp code generation.
kono
parents:
436
diff
changeset
|
3989 int |
229 | 3990 lrexpr(int e1, int e2,int l1, int op,int cond) |
195 | 3991 { |
221 | 3992 int reg; |
210 | 3993 int e3; |
280 | 3994 int l2; |
3995 int op1,cr0,cr1; | |
3996 | |
210 | 3997 g_expr(e1); |
3998 emit_lpush(); | |
3999 g_expr(e2); | |
4000 e3 = emit_lpop(); | |
221 | 4001 if (!is_longlong_reg(creg)) error(-1); |
4002 reg = lreg; | |
280 | 4003 op1 = lcmp(op,cond); |
4004 tosop(op1,regv_h(e3),regv_h(reg)); | |
4005 cr0 = cmpflag; | |
291 | 4006 tosop(op1,regv_l(e3),regv_l(reg)); |
280 | 4007 cr1 = cmpflag; |
4008 | |
4009 l2 = fwdlabel(); | |
4010 // cond==0 jump on false condtion ( if(x) => rexpr(.. cond=0 ...) ) | |
433 | 4011 switch(op+(!cond)*BNOT) { |
210 | 4012 case LOP+GT: |
4013 case LOP+GE: | |
433 | 4014 pcond(code_gt(1),cr0,1?l1:l2); |
4015 pcond(code_eq(0),cr0,1?l2:l1); | |
280 | 4016 break; |
4017 case LOP+UGT: | |
4018 case LOP+UGE: | |
433 | 4019 pcond(code_ugt(1),cr0,1?l1:l2); |
4020 pcond(code_eq(0), cr0,1?l2:l1); | |
280 | 4021 break; |
210 | 4022 case LOP+EQ: |
433 | 4023 pcond(code_eq(0),cr0,(1?l2:l1)); |
280 | 4024 pcond(code_eq(cond),cr1,l1); |
4025 break; | |
210 | 4026 case LOP+NEQ: |
433 | 4027 pcond(code_eq(0),cr0,(1?l1:l2)); |
4028 pcond(code_eq(!1),cr1,l1); | |
4029 break; | |
4030 case LOP+GT+BNOT: | |
4031 case LOP+GE+BNOT: | |
4032 pcond(code_gt(1),cr0,0?l1:l2); | |
4033 pcond(code_eq(0),cr0,0?l2:l1); | |
4034 break; | |
4035 case LOP+UGT+BNOT: | |
4036 case LOP+UGE+BNOT: | |
4037 pcond(code_ugt(1),cr0,0?l1:l2); | |
4038 pcond(code_eq(0), cr0,0?l2:l1); | |
4039 break; | |
4040 case LOP+EQ+BNOT: | |
4041 pcond(code_eq(0),cr0,(0?l2:l1)); | |
4042 pcond(code_eq(0),cr1,l1); | |
4043 break; | |
4044 case LOP+NEQ+BNOT: | |
4045 pcond(code_eq(0),cr0,(0?l1:l2)); | |
4046 pcond(code_eq(!0),cr1,l1); | |
280 | 4047 break; |
210 | 4048 default: |
4049 error(-1); | |
4050 } | |
433 | 4051 switch(op+BNOT*(!cond)) { |
4052 case LOP+GT: pcond(code_gt(1), cr1,l1); break; | |
4053 case LOP+GE: pcond(code_ge(1), cr1,l1); break; | |
4054 case LOP+UGT: pcond(code_ugt(1), cr1,l1); break; | |
4055 case LOP+UGE: pcond(code_uge(1), cr1,l1); break; | |
4056 case LOP+GT+BNOT: pcond(code_gt(0), cr1,l1); break; | |
4057 case LOP+GE+BNOT: pcond(code_ge(0), cr1,l1); break; | |
4058 case LOP+UGT+BNOT: pcond(code_ugt(0), cr1,l1); break; | |
4059 case LOP+UGE+BNOT: pcond(code_uge(0), cr1,l1); break; | |
280 | 4060 } |
4061 fwddef(l2); | |
4062 emit_lpop_free(e3); | |
438
626d705471d5
Unexecuted code in conditional. Lazy jmp code generation.
kono
parents:
436
diff
changeset
|
4063 return l1; |
280 | 4064 } |
195 | 4065 |
211 | 4066 int |
4067 emit_lpop() | |
195 | 4068 { |
210 | 4069 int xreg,reg; |
237 | 4070 xreg=lreg_stack[--lreg_sp]; |
210 | 4071 if (xreg<= -REG_LVAR_OFFSET) { |
4072 reg = get_lregister(); | |
4073 code_lrlvar(REG_LVAR_OFFSET+xreg,reg); | |
4074 free_lvar(REG_LVAR_OFFSET+xreg); | |
4075 xreg = reg; | |
4076 } | |
4077 return xreg; | |
195 | 4078 } |
4079 | |
211 | 4080 void |
4081 code_lregister(int e2,int reg) | |
195 | 4082 { |
221 | 4083 use_longlong(reg); |
4084 if (reg!=e2) { | |
4085 lmove(reg,e2); | |
211 | 4086 } |
195 | 4087 } |
4088 | |
211 | 4089 void |
287 | 4090 code_cmp_lregister(int reg,int label,int cond) |
195 | 4091 { |
221 | 4092 use_longlong(reg); |
211 | 4093 printf("\tor %s,%s,%s\n", |
4094 lregister_name_low(reg), | |
4095 lregister_name_low(reg), | |
4096 lregister_name_high(reg)); | |
291 | 4097 inc_cmpflag(); |
280 | 4098 printf("\tcmpwi cr%d,%s,0\n",cmpflag,lregister_name_low(reg)); |
287 | 4099 jcond(label,cond); |
195 | 4100 } |
4101 | |
211 | 4102 void |
287 | 4103 code_cmp_lrgvar(int e1,int creg,int label,int cond) |
195 | 4104 { |
221 | 4105 use_longlong(creg); |
211 | 4106 code_lrgvar(e1,creg); |
287 | 4107 code_cmp_lregister(creg,label,cond); |
211 | 4108 } |
4109 | |
4110 void | |
287 | 4111 code_cmp_lrlvar(int e1,int creg,int label,int cond) |
211 | 4112 { |
221 | 4113 use_longlong(creg); |
211 | 4114 code_lrlvar(e1,creg); |
287 | 4115 code_cmp_lregister(creg,label,cond); |
195 | 4116 } |
4117 | |
211 | 4118 void |
4119 code_lassign(int e2,int creg) | |
195 | 4120 { |
211 | 4121 char *drn = register_name(e2); |
221 | 4122 char *crn_h; |
4123 char *crn_l; | |
4124 | |
4125 use_longlong(creg); | |
4126 crn_h = lregister_name_high(creg); | |
4127 crn_l = lregister_name_low(creg); | |
411 | 4128 #if ENDIAN_L==0 |
4129 printf("\tstw %s,0(%s)\n",crn_l,drn); | |
4130 printf("\tstw %s,%d(%s)\n",crn_h,SIZE_OF_INT,drn); | |
4131 #else | |
271 | 4132 printf("\tstw %s,0(%s)\n",crn_h,drn); |
4133 printf("\tstw %s,%d(%s)\n",crn_l,SIZE_OF_INT,drn); | |
411 | 4134 #endif |
195 | 4135 } |
4136 | |
211 | 4137 void |
4138 code_lassign_gvar(int e2,int creg) | |
195 | 4139 { |
211 | 4140 int r; |
367 | 4141 use_longlong(creg); |
4142 r = get_ptr_cache((NMTBL*)caddr(e2)); | |
411 | 4143 #if ENDIAN_L==0 |
4144 code_ldf(cstore(0),lregister_name_low(creg),cadr(e2),r); | |
4145 code_ldf(cstore(0),lregister_name_high(creg),cadr(e2)+SIZE_OF_INT,r); | |
4146 #else | |
367 | 4147 code_ldf(cstore(0),lregister_name_high(creg),cadr(e2),r); |
4148 code_ldf(cstore(0),lregister_name_low(creg),cadr(e2)+SIZE_OF_INT,r); | |
411 | 4149 #endif |
195 | 4150 } |
4151 | |
211 | 4152 void |
4153 code_lassign_lvar(int e2,int creg) | |
195 | 4154 { |
221 | 4155 char *crn_h; |
4156 char *crn_l; | |
4157 | |
4158 use_longlong(creg); | |
4159 crn_h = lregister_name_high(creg); | |
4160 crn_l = lregister_name_low(creg); | |
211 | 4161 lvar_intro(e2); |
411 | 4162 #if ENDIAN_L==0 |
4163 printf("\tstw %s,",crn_l);lvar(e2); | |
4164 printf("\tstw %s,",crn_h);lvar(e2+SIZE_OF_INT); | |
4165 #else | |
211 | 4166 printf("\tstw %s,",crn_h);lvar(e2); |
245 | 4167 printf("\tstw %s,",crn_l);lvar(e2+SIZE_OF_INT); |
411 | 4168 #endif |
195 | 4169 } |
4170 | |
211 | 4171 void |
4172 code_lassign_lregister(int e2,int reg) | |
195 | 4173 { |
221 | 4174 use_longlong(reg); |
219 | 4175 if (e2!=reg) { |
4176 lmove(e2,reg); | |
211 | 4177 } |
195 | 4178 } |
4179 | |
207 | 4180 static long long ll0 = 1LL; |
206 | 4181 |
4182 static int | |
4183 code_l1(long long d) | |
4184 { | |
207 | 4185 int *i = (int *)&ll0; int *j = (int *)&d; |
206 | 4186 return (i[1] == 1)?j[1]:j[0]; |
4187 } | |
4188 | |
4189 static int | |
4190 code_l2(long long d) | |
4191 { | |
207 | 4192 int *i = (int *)&ll0; int *j = (int *)&d; |
206 | 4193 return (i[1] == 1)?j[0]:j[1]; |
4194 } | |
4195 | |
211 | 4196 void |
4197 code_lconst(int e1,int creg) | |
4198 { | |
221 | 4199 use_longlong(creg); |
411 | 4200 #if ENDIAN_L==0 |
4201 code_const(code_l1(lcadr(e1)),regv_h(creg)); | |
4202 code_const(code_l2(lcadr(e1)),regv_l(creg)); | |
4203 #else | |
211 | 4204 code_const(code_l1(lcadr(e1)),regv_l(creg)); |
4205 code_const(code_l2(lcadr(e1)),regv_h(creg)); | |
411 | 4206 #endif |
211 | 4207 } |
4208 | |
4209 void | |
4210 code_lneg(int creg) | |
195 | 4211 { |
221 | 4212 use_longlong(creg); |
211 | 4213 printf("\tsubfic %s,%s,0\n", |
4214 lregister_name_low(creg),lregister_name_low(creg)); | |
221 | 4215 printf("\tsubfze %s,%s\n", |
211 | 4216 lregister_name_high(creg),lregister_name_high(creg)); |
195 | 4217 } |
4218 | |
211 | 4219 void |
221 | 4220 code_lrgvar(int e1,int creg) |
211 | 4221 { |
4222 int r; | |
221 | 4223 char *crn_h; |
4224 char *crn_l; | |
4225 use_longlong(creg); | |
4226 crn_h = lregister_name_high(creg); | |
4227 crn_l = lregister_name_low(creg); | |
367 | 4228 r = get_ptr_cache((NMTBL*)caddr(e1)); |
411 | 4229 #if ENDIAN_L==0 |
4230 code_ldf(cload(0),crn_l,cadr(e1),r); | |
4231 code_ldf(cload(0),crn_h,cadr(e1)+SIZE_OF_INT,r); | |
4232 #else | |
367 | 4233 code_ldf(cload(0),crn_h,cadr(e1),r); |
4234 code_ldf(cload(0),crn_l,cadr(e1)+SIZE_OF_INT,r); | |
411 | 4235 #endif |
211 | 4236 } |
4237 | |
4238 void | |
4239 code_lrlvar(int e1,int creg) | |
195 | 4240 { |
221 | 4241 char *crn_h; |
4242 char *crn_l; | |
4243 use_longlong(creg); | |
4244 crn_h = lregister_name_high(creg); | |
4245 crn_l = lregister_name_low(creg); | |
211 | 4246 lvar_intro(e1); |
411 | 4247 #if ENDIAN_L==0 |
4248 printf("\tlwz %s,",crn_l); lvar(e1); | |
4249 printf("\tlwz %s,",crn_h); lvar(e1+SIZE_OF_INT); | |
4250 #else | |
211 | 4251 printf("\tlwz %s,",crn_h); lvar(e1); |
245 | 4252 printf("\tlwz %s,",crn_l); lvar(e1+SIZE_OF_INT); |
411 | 4253 #endif |
195 | 4254 } |
4255 | |
221 | 4256 #if 0 |
216 | 4257 static int lumod_lib_used=0; |
217 | 4258 static char *lumod_lib[] = { |
216 | 4259 }; |
4260 | |
4261 static int lmod_lib_used=0; | |
217 | 4262 static char *lmod_lib[] = { |
216 | 4263 }; |
4264 | |
4265 static int ludiv_lib_used=0; | |
217 | 4266 static char *ludiv_lib[] = { |
216 | 4267 }; |
4268 | |
4269 static int ldiv_lib_used=0; | |
217 | 4270 static char *ldiv_lib[] = { |
216 | 4271 }; |
221 | 4272 #endif |
216 | 4273 |
4274 static int lsrd_lib_used=0; | |
217 | 4275 static char *lsrd_lib[] = { |
4276 ".text", | |
4277 " .align 2", | |
4278 "lsrd__:", | |
4279 " mr. r5,r5", | |
4280 " beqlr", | |
4281 " subfic r2,r5,32", | |
4282 " stw r3,-32(r1)", | |
4283 " stw r4,-28(r1)", | |
4284 " cmpwi cr7,r2,0", | |
4285 " bgt+ cr7,L__lsrd1", | |
4286 " neg r0,r2", | |
4287 " lwz r2,-32(r1)", | |
4288 " li r9,0", | |
4289 " srw r2,r2,r0", | |
4290 " stw r9,-48(r1)", | |
4291 " b L__lsrd2", | |
4292 "L__lsrd1: lwz r0,-32(r1)", | |
4293 " slw r9,r0,r2", | |
4294 " lwz r2,-28(r1)", | |
4295 " srw r0,r0,r5", | |
4296 " srw r2,r2,r5", | |
4297 " stw r0,-48(r1)", | |
4298 " or r2,r2,r9", | |
4299 "L__lsrd2: stw r2,-44(r1)", | |
4300 " lwz r3,-48(r1)", | |
4301 " lwz r4,-44(r1)", | |
4302 " blr", | |
219 | 4303 0 |
217 | 4304 }; |
4305 | |
4306 static int asld_lib_used=0; | |
4307 static char *asld_lib[] = { | |
4308 ".text", | |
4309 " .align 2", | |
4310 "asld__:", | |
4311 " mr. r5,r5", | |
4312 " beqlr", | |
4313 " subfic r2,r5,32", | |
4314 " stw r3,-32(r1)", | |
4315 " stw r4,-28(r1)", | |
4316 " cmpwi cr7,r2,0", | |
4317 " bgt+ cr7,L__asld1", | |
4318 " neg r0,r2", | |
4319 " lwz r2,-28(r1)", | |
4320 " li r9,0", | |
4321 " slw r2,r2,r0", | |
4322 " stw r9,-44(r1)", | |
4323 " b L__asld2", | |
4324 "L__asld1: lwz r0,-28(r1)", | |
4325 " srw r9,r0,r2", | |
4326 " lwz r2,-32(r1)", | |
4327 " slw r0,r0,r5", | |
4328 " slw r2,r2,r5", | |
4329 " stw r0,-44(r1)", | |
4330 " or r2,r2,r9", | |
4331 "L__asld2: stw r2,-48(r1)", | |
4332 " lwz r3,-48(r1)", | |
4333 " lwz r4,-44(r1)", | |
4334 " blr", | |
219 | 4335 0 |
216 | 4336 }; |
4337 | |
4338 static int asrd_lib_used=0; | |
217 | 4339 static char *asrd_lib[] = { |
4340 ".text", | |
4341 " .align 2", | |
4342 "asrd__:", | |
4343 " mr. r5,r5", | |
4344 " beqlr", | |
4345 " subfic r2,r5,32", | |
4346 " stw r3,-32(r1)", | |
4347 " stw r4,-28(r1)", | |
4348 " cmpwi cr7,r2,0", | |
4349 " bgt+ cr7,L__asrd1", | |
4350 " lwz r0,-32(r1)", | |
4351 " neg r2,r2", | |
4352 " sraw r2,r0,r2", | |
4353 " srawi r0,r0,31", | |
4354 " b L__asrd2", | |
4355 "L__asrd1: lwz r0,-32(r1)", | |
4356 " slw r9,r0,r2", | |
4357 " lwz r2,-28(r1)", | |
4358 " sraw r0,r0,r5", | |
4359 " srw r2,r2,r5", | |
4360 " or r2,r2,r9", | |
4361 "L__asrd2: stw r0,-48(r1)", | |
4362 " stw r2,-44(r1)", | |
4363 " lwz r3,-48(r1)", | |
4364 " lwz r4,-44(r1)", | |
4365 " blr", | |
219 | 4366 0 |
216 | 4367 }; |
4368 | |
217 | 4369 static void |
4370 extern_conv(char *conv) | |
4371 { | |
4372 code_save_stacks(); | |
4373 clear_ptr_cache(); | |
4374 extern_define(conv,0,FUNCTION,1); | |
4375 printf("\tbl L_%s$stub\n",conv); | |
4376 } | |
4377 | |
216 | 4378 #if FLOAT_CODE |
218 | 4379 #if 0 |
217 | 4380 static int d2ll_lib_used=0; |
4381 static char *d2ll_lib[] = { | |
216 | 4382 }; |
4383 | |
4384 static int d2ull_lib_used=0; | |
217 | 4385 static char *d2ull_lib[] = { |
216 | 4386 }; |
4387 | |
4388 static int f2ll_lib_used=0; | |
217 | 4389 static char *f2ll_lib[] = { |
216 | 4390 }; |
4391 | |
4392 static int f2ull_lib_used=0; | |
217 | 4393 static char *f2ull_lib[] = { |
216 | 4394 }; |
4395 | |
4396 static int ll2d_lib_used=0; | |
217 | 4397 static char *ll2d_lib[] = { |
216 | 4398 }; |
4399 | |
4400 static int ll2f_lib_used=0; | |
217 | 4401 static char *ll2f_lib[] = { |
216 | 4402 }; |
218 | 4403 #endif |
216 | 4404 |
4405 #endif | |
4406 | |
4407 static void | |
255 | 4408 code_asld_lib(int reg,int oreg) |
211 | 4409 { |
4410 code_save_stacks(); | |
4411 clear_ptr_cache(); | |
4412 asld_lib_used = 1; | |
255 | 4413 set_lreg_operand(reg,1); |
4414 set_lreg(RET_LREGISTER,0); | |
228 | 4415 if (regv_l(oreg)!=5) { |
4416 printf("\tmr r5,%s\n", lregister_name_low(oreg)); | |
4417 } | |
221 | 4418 printf("\tbl asld__\n"); |
195 | 4419 } |
4420 | |
216 | 4421 static void |
255 | 4422 code_asrd_lib(int reg,int oreg) // ___ashrdi3$stub |
216 | 4423 { |
4424 code_save_stacks(); | |
4425 clear_ptr_cache(); | |
4426 asrd_lib_used = 1; | |
255 | 4427 set_lreg_operand(reg,1); |
4428 set_lreg(RET_LREGISTER,0); | |
228 | 4429 if (regv_l(oreg)!=5) { |
4430 printf("\tmr r5,%s\n", lregister_name_low(oreg)); | |
4431 } | |
221 | 4432 printf("\tbl asrd__\n"); |
216 | 4433 } |
4434 | |
4435 static void | |
255 | 4436 code_lsrd_lib(int reg,int oreg) // ___lshrdi3$stub |
216 | 4437 { |
4438 code_save_stacks(); | |
4439 clear_ptr_cache(); | |
4440 lsrd_lib_used = 1; | |
255 | 4441 set_lreg_operand(reg,1); |
4442 set_lreg(RET_LREGISTER,0); | |
231 | 4443 if (regv_l(oreg)!=5) { |
4444 printf("\tmr r5,%s\n", lregister_name_low(oreg)); | |
4445 } | |
221 | 4446 printf("\tbl lsrd__\n"); |
216 | 4447 } |
4448 | |
4449 static void | |
255 | 4450 code_ldiv_lib(int reg,int oreg) // ___divdi3$stub |
216 | 4451 { |
223 | 4452 code_save_stacks(); |
4453 clear_ptr_cache(); | |
255 | 4454 set_lreg_operand(reg,1); |
4455 set_lreg(RET_LREGISTER,0); | |
4456 set_lreg_operand1(oreg,1); | |
217 | 4457 extern_conv("__divdi3"); |
216 | 4458 } |
4459 | |
4460 static void | |
255 | 4461 code_ludiv_lib(int reg,int oreg) // ___udivdi3$stub |
216 | 4462 { |
223 | 4463 code_save_stacks(); |
4464 clear_ptr_cache(); | |
255 | 4465 set_lreg_operand(reg,1); |
4466 set_lreg(RET_LREGISTER,0); | |
4467 set_lreg_operand1(oreg,1); | |
217 | 4468 extern_conv("__udivdi3"); |
216 | 4469 } |
4470 | |
4471 static void | |
255 | 4472 code_lmod_lib(int reg,int oreg) // ___moddi3$stub |
216 | 4473 { |
223 | 4474 code_save_stacks(); |
4475 clear_ptr_cache(); | |
255 | 4476 set_lreg_operand(reg,1); |
4477 set_lreg(RET_LREGISTER,0); | |
4478 set_lreg_operand1(oreg,1); | |
217 | 4479 extern_conv("__moddi3"); |
216 | 4480 } |
4481 | |
4482 static void | |
255 | 4483 code_lumod_lib(int reg,int oreg) // ___umoddi3$stub |
216 | 4484 { |
223 | 4485 code_save_stacks(); |
4486 clear_ptr_cache(); | |
255 | 4487 set_lreg(RET_LREGISTER,0); |
4488 set_lreg_operand(reg,1); | |
4489 set_lreg_operand1(oreg,1); | |
217 | 4490 extern_conv("__umoddi3"); |
216 | 4491 } |
4492 | |
530 | 4493 #define check_lreg(reg) if (reg!=lreg) { lmove(reg,lreg); /* reg<=lreg */ } |
4494 | |
4495 // reg = reg op oreg | |
221 | 4496 |
211 | 4497 void |
221 | 4498 ltosop(int op,int reg,int oreg) |
195 | 4499 { |
221 | 4500 int dx = -1; |
252 | 4501 int ox = -1; |
531 | 4502 int creg_mode = (reg==USE_CREG); |
211 | 4503 char *orn_h,*crn_h,*drn_h; |
4504 char *orn_l,*crn_l,*drn_l; | |
221 | 4505 // creg = creg op oreg |
4506 | |
4507 use_longlong(reg); | |
211 | 4508 if(oreg==-1) { |
4509 error(-1); | |
4510 } else if (oreg<= -REG_LVAR_OFFSET) { | |
252 | 4511 ox = get_lregister(); if (ox<0) error(-1); |
4512 use_reg(ox); | |
273 | 4513 code_lrlvar(oreg+REG_LVAR_OFFSET,ox); |
252 | 4514 oreg = ox; |
211 | 4515 } |
4516 | |
4517 switch(op) { | |
4518 case LLSHIFT: | |
4519 case LULSHIFT: | |
255 | 4520 code_asld_lib(reg,oreg); // ___ashldi3$stub |
221 | 4521 check_lreg(reg); |
252 | 4522 if(ox!=-1) free_register(ox); |
211 | 4523 return; |
4524 case LRSHIFT: | |
255 | 4525 code_asrd_lib(reg,oreg); // ___ashrdi3$stub |
221 | 4526 check_lreg(reg); |
252 | 4527 if(ox!=-1) free_register(ox); |
211 | 4528 return; |
4529 case LURSHIFT: | |
255 | 4530 code_lsrd_lib(reg,oreg); // ___lshrdi3$stub |
221 | 4531 check_lreg(reg); |
252 | 4532 if(ox!=-1) free_register(ox); |
211 | 4533 return; |
4534 } | |
4535 orn_h = lregister_name_high(oreg); | |
4536 orn_l = lregister_name_low(oreg); | |
221 | 4537 crn_h = lregister_name_high(reg); |
4538 crn_l = lregister_name_low(reg); | |
211 | 4539 switch(op) { |
219 | 4540 case LADD: |
211 | 4541 printf("\taddc %s,%s,%s\n",crn_l,crn_l,orn_l); |
4542 printf("\tadde %s,%s,%s\n",crn_h,crn_h,orn_h); | |
4543 break; | |
219 | 4544 case LSUB: |
228 | 4545 printf("\tsubfc %s,%s,%s\n",crn_l,orn_l,crn_l); |
4546 printf("\tsubfe %s,%s,%s\n",crn_h,orn_h,crn_h); | |
211 | 4547 break; |
4548 case LCMP: | |
4549 error(-1); | |
4550 break; | |
219 | 4551 case LBAND: |
211 | 4552 printf("\tand %s,%s,%s\n",crn_l,crn_l,orn_l); |
4553 printf("\tand %s,%s,%s\n",crn_h,crn_h,orn_h); | |
4554 break; | |
219 | 4555 case LEOR: |
211 | 4556 printf("\txor %s,%s,%s\n",crn_l,crn_l,orn_l); |
4557 printf("\txor %s,%s,%s\n",crn_h,crn_h,orn_h); | |
4558 break; | |
219 | 4559 case LBOR: |
211 | 4560 printf("\tor %s,%s,%s\n",crn_l,crn_l,orn_l); |
4561 printf("\tor %s,%s,%s\n",crn_h,crn_h,orn_h); | |
4562 break; | |
219 | 4563 case LMUL: |
4564 case LUMUL: | |
273 | 4565 // code_save_stacks(); |
4566 // clear_ptr_cache(); | |
530 | 4567 dx=get_lregister(); if (dx<0) error(-1); |
223 | 4568 use_reg(dx); |
211 | 4569 drn_l = lregister_name_low(dx); |
4570 drn_h = lregister_name_high(dx); | |
4571 /* | |
4572 drn_l = l32( crn_l * orn_l); | |
4573 drn_h = h32( crn_l * orn_l); | |
4574 orn_l = l32( crn_h * orn_l); | |
4575 drn_h = drn_h + orn_l; | |
4576 crn_l = l32( crn_l * orn_h); | |
4577 crn_h = drn_h + crn_l; | |
4578 crn_l = drn_l; | |
4579 */ | |
4580 printf("\tmulhwu %s,%s,%s\n",drn_h,crn_l,orn_l); | |
228 | 4581 printf("\tmullw %s,%s,%s\n", drn_l,crn_l,orn_l); |
4582 printf("\tmullw %s,%s,%s\n", orn_l,crn_h,orn_l); | |
4583 printf("\tadd %s,%s,%s\n", drn_h,drn_h,orn_l); | |
4584 printf("\tmullw %s,%s,%s\n", crn_l,orn_h,crn_l); | |
4585 printf("\tadd %s,%s,%s\n", crn_h,drn_h,crn_l); | |
4586 printf("\tmr %s,%s\n", crn_l,drn_l); | |
211 | 4587 break; |
219 | 4588 case LDIV: |
255 | 4589 code_ldiv_lib(reg,oreg); // ___divdi3$stub |
531 | 4590 if (!creg_mode) check_lreg(reg); |
211 | 4591 break; |
219 | 4592 case LUDIV: |
255 | 4593 code_ludiv_lib(reg,oreg); // ___udivdi3$stub |
531 | 4594 if (!creg_mode) check_lreg(reg); |
211 | 4595 break; |
219 | 4596 case LMOD: |
255 | 4597 code_lmod_lib(reg,oreg); // ___moddi3$stub |
531 | 4598 if (!creg_mode) check_lreg(reg); |
211 | 4599 break; |
219 | 4600 case LUMOD: |
255 | 4601 code_lumod_lib(reg,oreg); // ___umoddi3$stub |
531 | 4602 if (!creg_mode) check_lreg(reg); |
211 | 4603 break; |
4604 default: | |
4605 error(-1); | |
4606 } | |
530 | 4607 if(ox!=-1) free_register(ox); |
221 | 4608 if(dx!=-1) free_register(dx); |
195 | 4609 } |
4610 | |
216 | 4611 int |
4612 code_lconst_op_p(int op,int e) | |
214 | 4613 { |
215 | 4614 int v; |
4615 if (car(e)==LCONST) { | |
222 | 4616 if (!(-32766<lcadr(e)&&lcadr(e)<32767)) return 0; |
287 | 4617 v = lcadr(e); |
215 | 4618 } else if (car(e)==CONST) { |
222 | 4619 if (!(-32766<cadr(e)&&cadr(e)<32767)) return 0; |
287 | 4620 v = cadr(e); |
222 | 4621 } else return 0; |
215 | 4622 |
214 | 4623 switch(op) { |
436 | 4624 case LMUL: case LUMUL: case LUDIV: |
4625 // case LDIV: | |
4626 return ilog(v); | |
231 | 4627 case LLSHIFT: |
4628 case LULSHIFT: | |
4629 case LRSHIFT: | |
4630 case LURSHIFT: | |
435 | 4631 return (0<=v&&v<=64); |
219 | 4632 case LADD: |
4633 case LSUB: | |
215 | 4634 return 1; |
219 | 4635 case LBOR: |
215 | 4636 return (v>0); |
214 | 4637 default: |
4638 return 0; | |
4639 } | |
4640 } | |
4641 | |
216 | 4642 void |
221 | 4643 loprtc(int op,int creg,int e) |
213 | 4644 { |
221 | 4645 char *crn_h; |
4646 char *crn_l; | |
215 | 4647 char *grn; |
214 | 4648 int v; |
215 | 4649 int greg; |
4650 | |
221 | 4651 use_longlong(creg); |
4652 crn_h = lregister_name_high(creg); | |
4653 crn_l = lregister_name_low(creg); | |
4654 | |
222 | 4655 if (car(e)==LCONST) v = lcadr(e); |
4656 else if (car(e)==CONST) v = cadr(e); | |
213 | 4657 |
4658 switch(op) { | |
436 | 4659 case LMUL: case LUMUL: |
4660 v=ilog(v); | |
219 | 4661 case LLSHIFT: |
4662 case LULSHIFT: | |
435 | 4663 if (v==0) return; |
4664 if (v==32) { | |
4665 code_register(regv_l(creg),regv_h(creg)); | |
4666 code_const(0,regv_l(creg)); | |
4667 return; | |
4668 } else if (v>31) { | |
4669 printf("\tslwi %s,%s,%d\n",crn_h,crn_l,v-32); | |
4670 code_const(0,regv_l(creg)); | |
4671 return; | |
4672 } | |
215 | 4673 greg = get_register(); |
435 | 4674 grn = register_name(greg); |
223 | 4675 use_reg(greg); |
231 | 4676 printf("\tsrwi %s,%s,%d\n",grn,crn_l,32-v); |
4677 printf("\tslwi %s,%s,%d\n",crn_h,crn_h,v); | |
4678 printf("\tor %s,%s,%s\n",crn_h,grn,crn_h); | |
215 | 4679 printf("\tslwi %s,%s,%d\n",crn_l,crn_l,v); |
4680 free_register(greg); | |
213 | 4681 return; |
436 | 4682 case LDIV: |
4683 v=ilog(v); | |
219 | 4684 case LRSHIFT: |
435 | 4685 if (v==0) return; |
4686 if (v==32) { | |
4687 code_register(regv_h(creg),regv_l(creg)); | |
4688 printf("\tsrawi %s,%s,31\n",crn_h,crn_l); | |
4689 return; | |
4690 } else if (v>31) { | |
4691 printf("\tsrawi %s,%s,%d\n",crn_l,crn_h,v-32); | |
4692 printf("\tsrawi %s,%s,31\n",crn_h,crn_l); | |
4693 return; | |
4694 } | |
215 | 4695 greg = get_register(); |
223 | 4696 use_reg(greg); |
215 | 4697 grn = register_name(greg); |
4698 printf("\tsrwi %s,%s,%d\n",grn,crn_l,v); | |
231 | 4699 printf("\tinsrwi %s,%s,%d,0\n",grn,crn_h,v); |
215 | 4700 printf("\tsrawi %s,%s,%d\n",crn_h,crn_h,v); |
4701 printf("\tmr %s,%s\n",crn_l,grn); | |
4702 free_register(greg); | |
213 | 4703 return; |
436 | 4704 case LUDIV: |
4705 v=ilog(v); | |
219 | 4706 case LURSHIFT: |
435 | 4707 if (v==0) return; |
4708 if (v==32) { | |
4709 code_register(regv_h(creg),regv_l(creg)); | |
4710 code_const(0,regv_h(creg)); | |
4711 return; | |
4712 } else if (v>31) { | |
4713 printf("\tsrwi %s,%s,%d\n",crn_l,crn_h,v-32); | |
4714 code_const(0,regv_h(creg)); | |
4715 return; | |
4716 } | |
215 | 4717 greg = get_register(); |
223 | 4718 use_reg(greg); |
215 | 4719 grn = register_name(greg); |
231 | 4720 printf("\tslwi %s,%s,%d\n",grn,crn_h,32-v); |
215 | 4721 printf("\tsrwi %s,%s,%d\n",crn_l,crn_l,v); |
231 | 4722 printf("\tor %s,%s,%s\n",crn_l,grn,crn_l); |
4723 printf("\tsrwi %s,%s,%d\n",crn_h,crn_h,v); | |
215 | 4724 free_register(greg); |
4725 return; | |
231 | 4726 case LSUB: |
4727 v = -v; | |
219 | 4728 case LADD: |
231 | 4729 printf("\taddic %s,%s,%d\n",crn_l,crn_l,v); |
4730 if (v<0) | |
4731 printf("\taddme %s,%s\n",crn_h,crn_h); | |
4732 else | |
4733 printf("\taddze %s,%s\n",crn_h,crn_h); | |
213 | 4734 break; |
219 | 4735 case LBOR: |
215 | 4736 printf("\tori %s,%s,lo16(%d)\n",crn_l,crn_l,v); |
213 | 4737 break; |
4738 default: | |
4739 error(-1); | |
4740 } | |
4741 } | |
4742 | |
4743 | |
211 | 4744 void |
4745 emit_lpop_free(int xreg) | |
195 | 4746 { |
211 | 4747 if (xreg>=0) |
4748 free_register(xreg); | |
195 | 4749 } |
4750 | |
211 | 4751 void |
4752 emit_lpush() | |
4753 { | |
4754 int new_reg; | |
212 | 4755 if (!is_longlong_reg(creg)) error(-1); |
211 | 4756 if (lreg_sp>MAX_MAX) error(-1); |
221 | 4757 new_reg = get_lregister(); /* ���Ф˼���(?) */ |
211 | 4758 lreg_stack[lreg_sp++] = creg; /* push ���뤫���˥쥸������Ȥ� */ |
4759 lreg = creg = new_reg; | |
4760 } | |
4761 | |
4762 void | |
239 | 4763 code_i2ll(int reg) |
195 | 4764 { |
215 | 4765 char *crn,*crn_h,*crn_l; |
239 | 4766 int reg0; |
4767 crn = register_name(reg0 = ireg); | |
4768 use_longlong(reg); | |
221 | 4769 crn_h = lregister_name_high(lreg); |
4770 crn_l = lregister_name_low(lreg); | |
239 | 4771 if (reg0!=regv_l(lreg)) |
215 | 4772 printf("\tmr %s,%s\n",crn_l,crn); |
4773 printf("\tsrawi %s,%s,31\n",crn_h,crn_l); | |
195 | 4774 } |
4775 | |
211 | 4776 void |
239 | 4777 code_i2ull(int reg) |
195 | 4778 { |
239 | 4779 code_i2ll(reg); |
195 | 4780 } |
4781 | |
211 | 4782 void |
239 | 4783 code_u2ll(int reg) |
195 | 4784 { |
215 | 4785 char *crn,*crn_h,*crn_l; |
239 | 4786 int reg0; |
4787 crn = register_name(reg0 = ireg); | |
4788 use_longlong(reg); | |
221 | 4789 crn_h = lregister_name_high(lreg); |
4790 crn_l = lregister_name_low(lreg); | |
239 | 4791 if (reg0!=regv_l(lreg)) |
215 | 4792 printf("\tmr %s,%s\n",crn_l,crn); |
4793 printf("\tli %s,0\n",crn_h); | |
195 | 4794 } |
4795 | |
211 | 4796 void |
4797 code_u2ull(int creg) | |
195 | 4798 { |
215 | 4799 code_u2ll(creg); |
195 | 4800 } |
4801 | |
211 | 4802 void |
239 | 4803 code_ll2i(int reg) |
195 | 4804 { |
219 | 4805 char *crn_l; |
239 | 4806 int reg0; |
4807 crn_l = lregister_name_low(reg0=lreg); | |
4808 use_int(reg); | |
4809 if (ireg!=regv_l(reg0)) | |
221 | 4810 printf("\tmr %s,%s\n",register_name(ireg),crn_l); |
195 | 4811 } |
4812 | |
211 | 4813 void |
4814 code_ll2u(int creg) | |
195 | 4815 { |
215 | 4816 code_ll2i(creg); |
195 | 4817 } |
4818 | |
211 | 4819 void |
4820 code_ull2i(int creg) | |
195 | 4821 { |
215 | 4822 code_ll2i(creg); |
195 | 4823 } |
4824 | |
211 | 4825 void |
4826 code_ull2u(int creg) | |
195 | 4827 { |
215 | 4828 code_ll2i(creg); |
195 | 4829 } |
4830 | |
4831 #if FLOAT_CODE | |
216 | 4832 |
211 | 4833 void |
239 | 4834 code_d2ll(int reg) |
195 | 4835 { |
215 | 4836 // fixdfdi$stub |
218 | 4837 set_freg(RET_FREGISTER,1); |
221 | 4838 extern_conv("__fixdfdi"); |
216 | 4839 set_lreg(RET_LREGISTER,0); |
239 | 4840 if (reg!=USE_CREG&®!=RET_LREGISTER) |
4841 use_longlong(reg); | |
195 | 4842 } |
4843 | |
211 | 4844 void |
239 | 4845 code_d2ull(int reg) |
195 | 4846 { |
218 | 4847 set_freg(RET_FREGISTER,1); |
221 | 4848 extern_conv("__fixunsdfdi"); |
216 | 4849 set_lreg(RET_LREGISTER,0); |
239 | 4850 if (reg!=USE_CREG&®!=RET_LREGISTER) |
4851 use_longlong(reg); | |
195 | 4852 } |
4853 | |
211 | 4854 void |
239 | 4855 code_f2ll(int reg) |
195 | 4856 { |
218 | 4857 set_freg(RET_FREGISTER,1); |
221 | 4858 extern_conv("__fixdfdi"); |
216 | 4859 set_lreg(RET_LREGISTER,0); |
239 | 4860 if (reg!=USE_CREG&®!=RET_LREGISTER) |
4861 use_longlong(reg); | |
195 | 4862 } |
4863 | |
211 | 4864 void |
239 | 4865 code_f2ull(int reg) |
195 | 4866 { |
218 | 4867 set_freg(RET_FREGISTER,1); |
221 | 4868 extern_conv("__fixsfdi"); |
216 | 4869 set_lreg(RET_LREGISTER,0); |
239 | 4870 if (reg!=USE_CREG&®!=RET_LREGISTER) |
4871 use_longlong(reg); | |
195 | 4872 } |
4873 | |
211 | 4874 void |
239 | 4875 code_ll2d(int reg) |
195 | 4876 { |
216 | 4877 set_lreg(RET_LREGISTER,1); |
221 | 4878 extern_conv("__floatdidf"); |
218 | 4879 set_freg(RET_FREGISTER,0); |
239 | 4880 if (reg!=USE_CREG&®!=RET_FREGISTER) |
4881 use_float(1,reg); | |
195 | 4882 } |
4883 | |
217 | 4884 |
211 | 4885 void |
239 | 4886 code_ll2f(int reg) |
195 | 4887 { |
216 | 4888 set_lreg(RET_LREGISTER,1); |
221 | 4889 extern_conv("__floatdisf"); |
218 | 4890 set_freg(RET_FREGISTER,0); |
239 | 4891 if (reg!=USE_CREG&®!=RET_FREGISTER) |
4892 use_float(0,reg); | |
195 | 4893 } |
4894 | |
211 | 4895 void |
4896 code_ull2d(int creg) | |
195 | 4897 { |
215 | 4898 code_ll2d(creg); |
195 | 4899 } |
4900 | |
211 | 4901 void |
4902 code_ull2f(int creg) | |
195 | 4903 { |
215 | 4904 code_ll2f(creg); |
195 | 4905 } |
4906 | |
4907 #endif | |
4908 | |
273 | 4909 static void |
4910 ladd(int creg,int reg,int dir) // creg=reg+dir | |
221 | 4911 { |
273 | 4912 printf("\taddic %s,%s,%d\n", |
4913 lregister_name_low(creg),lregister_name_low(reg), dir); | |
4914 printf("\tadd%s %s,%s\n", dir>0?"ze":"me", | |
4915 lregister_name_high(creg),lregister_name_high(reg)); | |
221 | 4916 } |
195 | 4917 |
211 | 4918 void |
4919 code_lpreinc(int e1,int e2,int reg) | |
195 | 4920 { |
222 | 4921 int dreg,xreg; |
211 | 4922 int dir=caddr(e1); |
4923 if (car(e2)==LREGISTER) { | |
221 | 4924 use_longlong(reg); |
273 | 4925 ladd(cadr(e2),cadr(e2),dir); |
4926 if (reg!=cadr(e2)) { | |
4927 lmove(reg,cadr(e2)); | |
211 | 4928 } |
4929 return; | |
4930 } | |
4931 g_expr(e2); | |
221 | 4932 if(!is_int_reg(creg)) error(-1); |
222 | 4933 emit_push(); |
221 | 4934 if (reg==USE_CREG) { |
4935 dreg=get_lregister(); if (!dreg) error(-1); | |
4936 set_lreg(dreg,0); // free old lreg==creg | |
4937 } else { | |
269 | 4938 dreg = reg; |
221 | 4939 } |
222 | 4940 xreg = emit_pop(0); |
269 | 4941 lload(xreg,dreg,0); |
273 | 4942 ladd(dreg,dreg,dir); |
269 | 4943 code_lassign(xreg,dreg); |
222 | 4944 emit_pop_free(xreg); |
195 | 4945 } |
4946 | |
211 | 4947 void |
4948 code_lpostinc(int e1,int e2,int reg) | |
195 | 4949 { |
222 | 4950 int dreg,nreg,xreg; |
211 | 4951 int dir=caddr(e1); |
4952 if (car(e2)==LREGISTER) { | |
221 | 4953 use_longlong(reg); |
273 | 4954 if (reg!=cadr(e2)) |
4955 lmove(reg,cadr(e2)); | |
4956 ladd(cadr(e2),cadr(e2),dir); | |
211 | 4957 return; |
4958 } | |
4959 g_expr(e2); | |
221 | 4960 if(!is_int_reg(creg)) error(-1); |
222 | 4961 emit_push(); |
221 | 4962 nreg=get_lregister(); if (!nreg) error(-1); |
4963 if (reg==USE_CREG) { | |
4964 dreg=get_lregister(); if (!dreg) error(-1); | |
4965 set_lreg(dreg,0); // free old lreg==creg | |
4966 } else { | |
269 | 4967 dreg = reg; |
221 | 4968 } |
222 | 4969 xreg = emit_pop(0); |
269 | 4970 lload(xreg,dreg,0); |
273 | 4971 ladd(nreg,dreg,dir); |
269 | 4972 code_lassign(xreg,nreg); |
222 | 4973 emit_pop_free(xreg); |
211 | 4974 free_register(nreg); |
195 | 4975 } |
4976 | |
211 | 4977 void |
221 | 4978 code_lassop(int op,int reg) |
195 | 4979 { |
211 | 4980 int xreg; |
4981 int edx,edx0=-1; | |
221 | 4982 |
4983 // (*creg) op = pop() | |
211 | 4984 xreg = emit_lpop(0); /* pop e3 value */ |
4985 if (!is_int_reg(creg)) error(-1); | |
221 | 4986 edx = ireg; |
223 | 4987 emit_push(); |
221 | 4988 use_longlong(reg); |
4989 if (regv_l(lreg)==edx || regv_h(lreg)==edx) { | |
285 | 4990 // this can't happen |
211 | 4991 edx0 = get_register(); if(!edx0) error(-1); |
468 | 4992 printf("## lassop\n\tmr %s,%s\n",register_name(edx0),register_name(edx)); |
211 | 4993 edx = edx0; |
4994 } | |
269 | 4995 lload(edx0=edx,reg,0); |
221 | 4996 ltosop(op,reg,xreg); |
269 | 4997 use_reg(reg); |
223 | 4998 edx = emit_pop(0); |
269 | 4999 code_lassign(edx,reg); |
5000 if (edx0!=-1) | |
5001 free_register(edx0); | |
5002 emit_pop_free(edx); | |
211 | 5003 emit_lpop_free(xreg); |
195 | 5004 } |
5005 | |
219 | 5006 void |
5007 code_register_lassop(int reg,int op) { | |
221 | 5008 // reg op = pop() |
219 | 5009 int xreg=emit_lpop(); |
221 | 5010 ltosop(op,reg,xreg); |
5011 emit_lpop_free(xreg); | |
219 | 5012 } |
5013 | |
195 | 5014 |
5015 #endif | |
5016 | |
95 | 5017 void |
5018 code_save_stacks() | |
5019 { | |
103 | 5020 int i,reg; |
101 | 5021 for(i=0;i<reg_sp;i++) { |
103 | 5022 if ((reg=reg_stack[i])>=0) { |
101 | 5023 code_assign_lvar( |
245 | 5024 (reg_stack[i]=new_lvar(SIZE_OF_INT)),reg,0); |
101 | 5025 reg_stack[i]= reg_stack[i]-REG_LVAR_OFFSET; |
368 | 5026 free_register(reg); |
101 | 5027 } |
5028 } | |
195 | 5029 #if FLOAT_CODE |
101 | 5030 for(i=0;i<freg_sp;i++) { |
103 | 5031 if ((reg=freg_stack[i])>=0) { |
101 | 5032 code_dassign_lvar( |
245 | 5033 (freg_stack[i]=new_lvar(SIZE_OF_DOUBLE)),reg,1); |
101 | 5034 freg_stack[i]= freg_stack[i]-REG_LVAR_OFFSET; |
368 | 5035 free_register(reg); |
101 | 5036 } |
5037 } | |
195 | 5038 #endif |
212 | 5039 #if LONGLONG_CODE |
5040 for(i=0;i<lreg_sp;i++) { | |
5041 if ((reg=lreg_stack[i])>=0) { | |
223 | 5042 code_lassign_lvar( |
245 | 5043 (lreg_stack[i]=new_lvar(SIZE_OF_LONGLONG)),reg); |
212 | 5044 lreg_stack[i]= lreg_stack[i]-REG_LVAR_OFFSET; |
368 | 5045 free_register(reg); |
212 | 5046 } |
5047 } | |
5048 #endif | |
96 | 5049 } |
5050 | |
5051 void | |
5052 emit_lib(char *p[]) | |
95 | 5053 { |
98 | 5054 while(*p) { |
5055 printf("%s\n",*p++); | |
96 | 5056 } |
5057 } | |
5058 | |
5059 void | |
5060 code_closing() | |
5061 { | |
195 | 5062 #if FLOAT_CODE |
96 | 5063 if (d2u_lib_used) emit_lib(d2u_lib); |
5064 if (u2d_lib_used) emit_lib(u2d_lib); | |
5065 if (float_one_lib_used) emit_lib(float_one_lib); | |
98 | 5066 if (float_zero_lib_used) emit_lib(float_zero_lib); |
96 | 5067 if (i2d_lib_used) emit_lib(i2d_lib); |
195 | 5068 #endif |
213 | 5069 #if LONGLONG_CODE |
218 | 5070 if (asld_lib_used) emit_lib(asld_lib); |
221 | 5071 if (lsrd_lib_used) emit_lib(lsrd_lib); |
5072 if (asrd_lib_used) emit_lib(asrd_lib); | |
5073 #if 0 | |
216 | 5074 if (lumod_lib_used) emit_lib(lumod_lib); |
5075 if (lmod_lib_used) emit_lib(lmod_lib); | |
5076 if (ludiv_lib_used) emit_lib(ludiv_lib); | |
5077 if (ldiv_lib_used) emit_lib(ldiv_lib); | |
221 | 5078 #endif |
213 | 5079 #if FLOAT_CODE |
218 | 5080 #if 0 |
216 | 5081 if (dl2ll_lib_used) emit_lib(dl2ll_lib); |
5082 if (d2ull_lib_used) emit_lib(d2ull_lib); | |
5083 if (f2ll_lib_used) emit_lib(f2ll_lib); | |
5084 if (f2ull_lib_used) emit_lib(f2ull_lib); | |
5085 if (ll2d_lib_used) emit_lib(ll2d_lib); | |
5086 if (ll2f_lib_used) emit_lib(ll2f_lib); | |
213 | 5087 #endif |
5088 #endif | |
218 | 5089 #endif |
97 | 5090 global_table(); |
108 | 5091 /* printf("\t.ident \"Micro-C compiled\"\n"); */ |
95 | 5092 } |
5093 | |
300 | 5094 #if CASE_CODE |
5095 | |
5096 int | |
382 | 5097 code_table_jump_p(int delta) { return 1; } |
300 | 5098 |
5099 void | |
302 | 5100 code_table_jump(int l,int csvalue,int delta,int max,int min,int dlabel) |
300 | 5101 { |
302 | 5102 int t,s,u=-1; |
5103 char *crn = register_name(csvalue); // can be t,s,u | |
300 | 5104 char *trn = register_name(t=get_register()); |
5105 char *srn = register_name(s=get_register()); | |
302 | 5106 char *urn; |
300 | 5107 |
5108 inc_cmpflag(); | |
5109 if (min>32767||min<-32765) { | |
302 | 5110 if (t==csvalue) { |
5111 code_const(min,s); | |
5112 printf("\tsub\t%s,%s,%s\n",trn,crn,srn); | |
5113 } else { | |
5114 code_const(min,t); | |
5115 printf("\tsub\t%s,%s,%s\n",trn,crn,trn); | |
5116 } | |
300 | 5117 } else { |
5118 printf("\taddi\t%s,%s,lo16(%d)\n",trn,crn,-min); | |
5119 } | |
302 | 5120 printf("\tcmplwi cr%d,%s,%d\n",cmpflag,trn,max-min); |
5121 printf("\tbgt-\tcr%d,L_%d\n",cmpflag,dlabel); | |
300 | 5122 inc_cmpflag(); |
5123 switch(delta) { | |
5124 case 1: printf("\tslwi %s,%s,2\n",trn,trn); break; | |
302 | 5125 case 2: |
5126 printf("\tli %s,1\n",srn); | |
5127 printf("\tand %s,%s,%s\n",srn,srn,trn); | |
5128 printf("\tcmplwi cr%d,%s,0\n",cmpflag,srn); | |
5129 printf("\tbne\tcr%d,L_%d\n",cmpflag,dlabel); | |
5130 printf("\tslwi %s,%s,1\n",trn,trn); | |
5131 break; | |
5132 case 4: | |
5133 printf("\tli %s,3\n",srn); | |
5134 printf("\tand %s,%s,%s\n",srn,srn,trn); | |
5135 printf("\tcmplwi cr%d,%s,0\n",cmpflag,srn); | |
5136 printf("\tbne\tcr%d,L_%d\n",cmpflag,dlabel); | |
5137 break; | |
300 | 5138 default: |
302 | 5139 urn = register_name(u=get_register()); |
5140 printf("\tli %s,%d\n",srn,delta); | |
5141 printf("\tdivwu %s,%s,%s\n",urn,trn,srn); | |
5142 printf("\tmullw %s,%s,%s\n",srn,urn,srn); | |
5143 printf("\tsubf %s,%s,%s\n",srn,trn,srn); | |
5144 printf("\tcmplwi cr%d,%s,0\n",cmpflag,srn); | |
5145 printf("\tbne\tcr%d,L_%d\n",cmpflag,dlabel); | |
5146 printf("\tslwi %s,%s,2\n",trn,urn); | |
300 | 5147 } |
5148 printf("\taddis %s,r31,ha16(L_%d-L_%d)\n", | |
5149 srn,l,code_base); | |
5150 printf("\tla %s,lo16(L_%d-L_%d)(%s)\n", | |
5151 srn,l,code_base,srn); | |
5152 printf("\tadd %s,%s,%s\n",trn,srn,trn); | |
5153 printf("\tlwz r0,0(%s)\n",trn); | |
5154 printf("\tadd r0,r0,%s\n",srn); | |
5155 printf("\tmtctr r0\n"); | |
5156 printf("\tbctr\n"); | |
5157 | |
5158 free_register(s); | |
5159 free_register(t); | |
302 | 5160 if (u!=-1) free_register(u); |
300 | 5161 } |
5162 | |
5163 void | |
5164 code_table_open(int l) | |
5165 { | |
5166 printf("\t.p2align 2\n"); | |
5167 fwddef(l); | |
5168 } | |
5169 | |
5170 void | |
5171 code_table_value(int label,int table_top) | |
5172 { | |
5173 printf("\t.long L_%d-L_%d\n",label,table_top); | |
5174 } | |
5175 | |
5176 void | |
5177 code_table_close() | |
5178 { | |
5179 } | |
5180 | |
5181 #endif | |
5182 | |
316 | 5183 #if ASM_CODE |
5184 | |
318 | 5185 /* |
320 | 5186 print an operand |
318 | 5187 */ |
5188 | |
5189 static void | |
320 | 5190 emit_asm_operand(int rstr) |
318 | 5191 { |
5192 if (car(rstr)==REGISTER) { | |
5193 printf("%s",register_name(cadr(rstr))); | |
5194 } else if (car(rstr)==CONST) { | |
5195 printf("%d",cadr(rstr)); | |
319 | 5196 } else if (car(rstr)==FNAME) { |
5197 printf("%s",(char*)cadr(rstr)); | |
318 | 5198 } else if (car(rstr)==STRING) { |
319 | 5199 printf("L_%d",cadr(rstr)); |
318 | 5200 } else { |
5201 error(-1); | |
5202 } | |
5203 } | |
5204 | |
320 | 5205 /* |
5206 prepare asm operands | |
5207 | |
5208 char *constraints sgtring | |
326 | 5209 int oeprand expr |
320 | 5210 int mode (ASM_INPUT,ASM_OUTPUT) |
5211 int replacement list | |
5212 int output operands count | |
5213 int output operands replacement list | |
5214 | |
5215 retrun replacement list | |
5216 list3( operands, next, clobber ) | |
5217 0 can be shared in input/output | |
5218 1 can't be used in input | |
5219 */ | |
5220 | |
327 | 5221 extern int |
5222 code_asm_operand(char *p,int e1,int mode,int repl,int n,int repl0) | |
318 | 5223 { |
5224 int r; | |
5225 int c; | |
5226 int val; | |
5227 int clobber = 0; | |
5228 | |
527 | 5229 printf("## constraint %s\n",p); |
5230 retry: | |
5231 switch((c=*p)) { | |
5232 case '?': | |
5233 case '!': | |
5234 case '+': | |
5235 case '%': | |
5236 case '#': | |
5237 case '*': | |
5238 case '=': | |
318 | 5239 // output register |
5240 p++; | |
527 | 5241 goto retry; |
5242 case '&': | |
318 | 5243 // earlyclobber |
5244 p++; | |
5245 clobber = 1; | |
527 | 5246 goto retry; |
5247 case 'b': // address base register (what?) | |
5248 case 'r': | |
318 | 5249 if (mode==ASM_INPUT) { |
5250 for(;repl0;repl0 = cadr(repl0)) { | |
5251 if (car(car(repl0))==REGISTER && caddr(repl0)==0) { | |
5252 r = cadr(car(repl0)); | |
5253 caddr(repl0) = ASM_USED; | |
5254 break; | |
5255 } | |
5256 } | |
5257 r = get_register(); | |
5258 } else { | |
5259 r = get_register(); | |
5260 } | |
5261 repl = list3(list2(REGISTER,r),repl,clobber); | |
527 | 5262 break; |
5263 case 'm': | |
319 | 5264 repl = list3(list2(0,0),repl,clobber); |
527 | 5265 break; |
5266 case 'i': | |
368 | 5267 if (car(e1)==GVAR) { |
5268 e1=list3(FNAME,(int)(((NMTBL *)caddr(e1))->nm),0); | |
5269 } else if (car(e1)==FNAME) { | |
319 | 5270 e1=list3(FNAME,(int)(((NMTBL *)cadr(e1))->nm),0); |
5271 } else if (car(e1)==STRING) { | |
5272 val = emit_string_label(); | |
5273 ascii((char*)cadr(e1)); | |
5274 e1=list3(STRING,val,0); | |
5275 } else if (car(e1)==CONST) { | |
5276 } else error(-1); | |
318 | 5277 repl = list3(e1,repl,clobber); |
527 | 5278 break; |
5279 case '0': case '1': case '2': case '3': case '4': | |
5280 case '5': case '6': case '7': case '8': case '9': | |
318 | 5281 val = 0; |
5282 do { val = val*10 + c-'0'; } while (digit(c=*p++)); | |
5283 if (val>MAX_ASM_REG) error(-1); // too large register | |
5284 if (n-val<0) error(-1); | |
5285 repl = list3(car(nth(n-val-1,repl0)),repl,clobber); | |
527 | 5286 break; |
5287 default: | |
5288 printf("### unknown asm constraint %c\n",c); | |
5289 } | |
318 | 5290 return repl; |
5291 } | |
5292 | |
320 | 5293 void |
327 | 5294 code_free_asm_operand(int repl) |
318 | 5295 { |
5296 for(;repl;repl=cadr(repl)) { | |
5297 if (car(car(repl))==REGISTER) | |
5298 free_register(cadr(car(repl))); | |
5299 } | |
5300 } | |
5301 | |
320 | 5302 |
5303 extern void | |
327 | 5304 code_asm(char *asm_str,int repl) |
316 | 5305 { |
320 | 5306 int c,i,rstr,val; |
318 | 5307 char *p; |
320 | 5308 int reg[MAX_ASM_REG]; |
5309 | |
516 | 5310 text_mode(0); |
320 | 5311 c = *asm_str; |
5312 if (c!='\t'&&c!=' ') printf("\t"); | |
5313 for(i=0;repl && i<MAX_ASM_REG;i++) { | |
5314 reg[i] = car(repl); | |
5315 repl = cadr(repl); | |
5316 } | |
5317 p = asm_str; | |
5318 while((c = *p++)) { | |
5319 if (c=='%') { | |
5320 c = *p++; | |
5321 if (!c) { break; | |
5322 } else if (c=='%') { | |
5323 printf("%%"); continue; | |
5324 } else if (!digit(c)) { | |
5325 printf("%%%c",c); continue; | |
5326 } | |
5327 val = 0; | |
5328 do { val = val*10 + c-'0'; } while (digit(c=*p++)) ; | |
5329 p--; | |
5330 if (val>MAX_ASM_REG) error(-1); // too large register | |
5331 rstr = reg[val]; | |
5332 emit_asm_operand(rstr); | |
5333 } else { | |
5334 printf("%c",c); | |
318 | 5335 } |
5336 } | |
320 | 5337 printf("\n"); |
316 | 5338 } |
5339 | |
5340 #endif | |
5341 | |
5342 | |
329 | 5343 #if BIT_FIELD_CODE |
5344 | |
5345 /* bit field alignment calcuration */ | |
5346 | |
5347 static void | |
426 | 5348 set_bitsz(int type,int *pbitpos,int *pbitsize, |
5349 int *psign,int *pbitsz,int *palign,int *pl) | |
329 | 5350 { |
5351 int sign=0,bitsz; | |
331 | 5352 int align,l=0; |
426 | 5353 *pbitpos = cadr(caddr(type)); |
5354 *pbitsize = caddr(caddr(type)); | |
420 | 5355 switch(cadr(type)) { /* value type */ |
329 | 5356 case INT: sign=1; bitsz=32; align=4;break; |
5357 case UNSIGNED: bitsz=32; align=4;break; | |
335 | 5358 case CHAR: sign=1; bitsz= 8; align=1;break; |
5359 case UCHAR: bitsz= 8; align=1;break; | |
329 | 5360 case SHORT: sign=1; bitsz=16; align=2;break; |
5361 case USHORT: sign=1; bitsz=16; align=2;break; | |
5362 case LONGLONG: sign=1; bitsz=64; align=4;l=1; break; | |
5363 case ULONGLONG: bitsz=64; align=4;l=1; break; | |
5364 default: error(-1); | |
5365 } | |
5366 *psign = sign; | |
5367 *pbitsz = bitsz; | |
5368 *palign = align; | |
5369 *pl = l; | |
5370 } | |
5371 | |
5372 /* | |
5373 bit field alignment calcuration | |
5374 this is architecture depenedent | |
5375 */ | |
5376 | |
5377 extern int | |
5378 code_bit_field_disp(int type,int *poffset,int *bfd,int *sz) | |
5379 { | |
331 | 5380 int sign,bitsz,align; |
329 | 5381 int i; |
5382 int bitpos = *bfd; | |
426 | 5383 int bitpos0; |
5384 int bitsize; | |
329 | 5385 int offset = *poffset; |
5386 int l; | |
426 | 5387 set_bitsz(type,&bitpos0,&bitsize,&sign,&bitsz,&align,&l); |
329 | 5388 |
5389 if (bitsize>bitsz) { error(BTERR); bitsize = i; } | |
5390 | |
5391 /* bfd means previous bit field bit offset */ | |
5392 if (bitpos) { | |
5393 /* previous field is bit field and spaces may remain */ | |
5394 /* calc previsous offset */ | |
5395 | |
5396 i= offset-(bitpos+7)/8; | |
5397 | |
335 | 5398 for(l = bitpos;l>0;l -= 8,i++) { |
336 | 5399 if ((i & (align-1))==0 && l+bitsize <= bitsz) { |
335 | 5400 /* alignment is correct and space remains */ |
5401 *poffset=offset=i; | |
5402 i = l+bitsize; | |
423 | 5403 *bfd = (i==bitsz)?0:i; |
335 | 5404 *sz = (i+7)/8; |
527 | 5405 // printf("## bitpos=%d bitsize=%d bitsz=%d offset=%d\n",l,bitsize,bitsz,*poffset); |
335 | 5406 return l; |
5407 } | |
5408 } | |
329 | 5409 } |
5410 | |
5411 /* first bit-field */ | |
5412 | |
5413 if ((i=(offset & (align-1)))) { | |
335 | 5414 *poffset = (offset += (align-i)); |
329 | 5415 } |
5416 bitpos = 0; | |
426 | 5417 *bfd = (bitsize==bitsz)?0:bitsize; |
329 | 5418 *sz = (bitsize+7)/8; |
5419 | |
527 | 5420 // printf("## bitpos=%d bitsize=%d bitsz=%d offset=%d\n",bitpos,bitsize,bitsz,*poffset); |
329 | 5421 return bitpos; |
5422 } | |
5423 | |
5424 /* bit field value */ | |
5425 | |
5426 extern void | |
426 | 5427 code_bit_field(int type,int adr, int reg) |
329 | 5428 { |
331 | 5429 int sign,bitsz,l,align; |
426 | 5430 int bitsize,bitpos; |
5431 int i,size; | |
5432 set_bitsz(type,&bitpos,&bitsize,&sign,&bitsz,&align,&l); | |
5433 size = bitsz/8; | |
527 | 5434 // printf("## %d: bitpos=%d bitsize=%d bitsz=%d\n",lineno,bitpos,bitsize,bitsz); |
329 | 5435 /* this implementation returns -1 for int i:1; */ |
5436 if (l==1) { | |
440 | 5437 #if LONGLONG_CODE |
431 | 5438 // use_int(adr); |
329 | 5439 use_longlong(reg); |
426 | 5440 lload(adr,reg,0); |
329 | 5441 /* shift left */ |
331 | 5442 if (bitpos) |
335 | 5443 loprtc(LLSHIFT,reg,list2(CONST,bitpos)); |
329 | 5444 /* shift right */ |
5445 if ((i=bitsz-bitsize)) | |
335 | 5446 loprtc(sign?LRSHIFT:LURSHIFT,reg,list2(CONST,i)); |
440 | 5447 #endif |
329 | 5448 } else { |
431 | 5449 // use_int(adr); |
329 | 5450 use_int(reg); |
426 | 5451 printf("\t%s %s,lo16(%d)(%s)\n",cload(size), |
5452 register_name(reg),0,register_name(adr)); | |
5453 cext(sign,size,reg); | |
329 | 5454 /* shift left */ |
336 | 5455 if ((i=bitpos+(32-bitsz))) |
5456 oprtc(LSHIFT,reg,list2(CONST,i)); | |
329 | 5457 /* shift right */ |
336 | 5458 if ((i=bitsz-bitsize+(32-bitsz))) |
335 | 5459 oprtc(sign?RSHIFT:URSHIFT,reg,list2(CONST,i)); |
329 | 5460 } |
5461 } | |
5462 | |
5463 /* bit field replacement */ | |
5464 | |
330 | 5465 static void |
331 | 5466 make_mask_and_or(int mask,int tmp,char *trn,char *crn,char *lrn) |
330 | 5467 { |
527 | 5468 // printf("## mask 0x%08x ~0x%08x\n",mask,~mask); |
330 | 5469 code_const(~mask,tmp); |
5470 printf("\tor %s,%s,%s\n",trn,crn,trn); | |
5471 /* do conjunction */ | |
5472 printf("\tand %s,%s,%s\n",lrn,trn,lrn); | |
5473 /* make or-mask */ | |
5474 code_const(mask,tmp); | |
5475 printf("\tand %s,%s,%s\n",trn,crn,trn); | |
5476 /* do disjunction */ | |
336 | 5477 printf("\tor %s,%s,%s\n",crn,trn,lrn); |
330 | 5478 } |
5479 | |
329 | 5480 extern void |
431 | 5481 code_bit_replace(int adr,int value,int type) |
329 | 5482 { |
331 | 5483 int sign,bitsz,l,align; |
426 | 5484 int bitsize,bitpos; |
330 | 5485 int mask = 0; |
5486 int tmp = -1; | |
331 | 5487 int i; |
426 | 5488 int lvalue; |
330 | 5489 char *crn,*lrn,*trn; |
426 | 5490 int size; |
5491 set_bitsz(type,&bitpos,&bitsize,&sign,&bitsz,&align,&l); | |
5492 size = bitsz/8; | |
467 | 5493 // printf("## %d: bitpos=%d bitsize=%d bitsz=%d\n",lineno,bitpos,bitsize,bitsz); |
329 | 5494 if (l) { |
440 | 5495 #if LONGLONG_CODE |
431 | 5496 // use_int(adr); |
426 | 5497 lvalue = get_lregister(); |
431 | 5498 lload(adr,lvalue,0); |
330 | 5499 use_longlong(value); |
5500 crn = lregister_name_low(value); | |
5501 lrn = lregister_name_low(lvalue); | |
329 | 5502 /* shift left */ |
330 | 5503 if ((i=bitsz-bitsize-bitpos)) |
335 | 5504 loprtc(LLSHIFT,value,list2(CONST,i)); |
330 | 5505 trn = register_name(tmp = get_register()); |
336 | 5506 if (bitpos+bitsize>=32) { |
330 | 5507 /* make and-mask lower */ |
336 | 5508 mask = make_mask(bitpos>=32?bitpos-32:0,bitpos+bitsize-32-1); |
330 | 5509 make_mask_and_or(mask,tmp,trn,crn,lrn); |
5510 } | |
5511 crn = lregister_name_high(value); | |
5512 lrn = lregister_name_high(lvalue); | |
5513 if (bitpos<32) { | |
5514 /* make and-mask upper */ | |
336 | 5515 mask = make_mask(bitpos,bitpos+bitsize>=32?31:bitpos+bitsize-1); |
330 | 5516 make_mask_and_or(mask,tmp,trn,crn,lrn); |
5517 } | |
431 | 5518 code_lassign(adr,value); |
426 | 5519 free_register(lvalue); |
431 | 5520 // free_register(adr); |
440 | 5521 #endif |
329 | 5522 } else { |
431 | 5523 // use_int(adr); |
330 | 5524 use_int(value); |
426 | 5525 lvalue = get_register(); |
5526 printf("\t%s %s,lo16(%d)(%s)\n",cload(size), | |
431 | 5527 register_name(lvalue),0,register_name(adr)); |
426 | 5528 cext(sign,size,lvalue); |
330 | 5529 crn = register_name(value); |
5530 lrn = register_name(lvalue); | |
5531 /* shift left */ | |
5532 if ((i=bitsz-bitsize-bitpos)) | |
335 | 5533 oprtc(LSHIFT,value,list2(CONST,i)); |
330 | 5534 trn = register_name(tmp = get_register()); |
329 | 5535 /* make and-mask */ |
336 | 5536 mask = make_mask(bitpos+(32-bitsz),bitpos+bitsize-1+(32-bitsz)); |
330 | 5537 make_mask_and_or(mask,tmp,trn,crn,lrn); |
426 | 5538 free_register(lvalue); |
431 | 5539 code_assign(adr,size,value); |
329 | 5540 } |
330 | 5541 if (tmp!=-1) free_register(tmp); |
426 | 5542 if (use) { |
431 | 5543 code_bit_field(type,adr,USE_CREG); |
426 | 5544 } |
329 | 5545 } |
5546 | |
365 | 5547 static void |
5548 make_mask_and_or_const(int mask,char *crn,int c) | |
5549 { | |
5550 char *trn; | |
5551 int tmp = -1; | |
527 | 5552 // printf("## mask 0x%08x ~0x%08x\n",mask,~mask); |
365 | 5553 if ((~mask|c)!=-1) { |
5554 trn = register_name(tmp=get_register()); | |
5555 code_const((~mask|c),tmp); | |
5556 /* do conjunction */ | |
5557 printf("\tand %s,%s,%s\n",crn,trn,crn); | |
5558 } | |
5559 /* make or-mask */ | |
5560 c = mask&c; | |
5561 if (c!=0) { | |
5562 /* do disjunction */ | |
5563 if (!((mask&c)&0xffff0000)) { | |
5564 printf("\tori %s,%s,lo16(%d)\n",crn,crn,c); | |
5565 } else { | |
5566 trn = register_name(tmp=get_register()); | |
5567 code_const(c,tmp); | |
5568 printf("\tor %s,%s,%s\n",crn,trn,crn); | |
5569 } | |
5570 } | |
5571 if (tmp!=-1) free_register(tmp); | |
5572 } | |
5573 | |
5574 extern void | |
431 | 5575 code_bit_replace_const(int value,int adr,int type) |
365 | 5576 { |
5577 int sign,bitsz,l,align; | |
426 | 5578 int bitsize,bitpos,size; |
365 | 5579 int mask = 0; |
5580 int i; | |
5581 int c; | |
426 | 5582 int lvalue; |
365 | 5583 #if LONGLONG_CODE |
5584 long long lc; | |
5585 #endif | |
5586 char *crn; | |
426 | 5587 set_bitsz(type,&bitpos,&bitsize,&sign,&bitsz,&align,&l); |
5588 size = bitsz/8; | |
467 | 5589 // printf("## %d: bitpos=%d bitsize=%d bitsz=%d\n",lineno,bitpos,bitsize,bitsz); |
365 | 5590 if (l) { |
5591 #if LONGLONG_CODE | |
431 | 5592 use_int(adr); |
426 | 5593 lvalue = get_lregister(); |
431 | 5594 lload(adr,lvalue,0); |
365 | 5595 crn = lregister_name_low(lvalue); |
5596 /* shift left */ | |
5597 lc = lcadr(value); | |
5598 if ((i=bitsz-bitsize-bitpos)) | |
5599 lc <<= i; | |
5600 if (bitpos+bitsize>=32) { | |
5601 /* make and-mask lower */ | |
5602 mask = make_mask(bitpos>=32?bitpos-32:0,bitpos+bitsize-32-1); | |
5603 make_mask_and_or_const(mask,crn,(int)lc); | |
5604 } | |
5605 crn = lregister_name_high(lvalue); | |
5606 if (bitpos<32) { | |
5607 /* make and-mask upper */ | |
5608 mask = make_mask(bitpos,bitpos+bitsize>=32?31:bitpos+bitsize-1); | |
5609 make_mask_and_or_const(mask,crn,(int)(lc>>32)); | |
5610 } | |
431 | 5611 code_lassign(adr,lvalue); |
426 | 5612 free_register(lvalue); |
365 | 5613 #endif |
5614 } else { | |
431 | 5615 use_int(adr); |
426 | 5616 lvalue = get_register(); |
5617 printf("\t%s %s,lo16(%d)(%s)\n",cload(size), | |
431 | 5618 register_name(lvalue),0,register_name(adr)); |
426 | 5619 cext(sign,size,lvalue); |
365 | 5620 crn = register_name(lvalue); |
5621 /* shift left */ | |
5622 c = cadr(value); | |
5623 if ((i=bitsz-bitsize-bitpos)) | |
5624 c <<= i; | |
5625 /* make and-mask */ | |
5626 mask = make_mask(bitpos+(32-bitsz),bitpos+bitsize-1+(32-bitsz)); | |
5627 make_mask_and_or_const(mask,crn,c); | |
431 | 5628 code_assign(adr,size,lvalue); |
426 | 5629 free_register(lvalue); |
5630 } | |
5631 if (use) { | |
431 | 5632 code_bit_field(type,adr,USE_CREG); |
365 | 5633 } |
5634 } | |
5635 | |
329 | 5636 #endif |
5637 | |
89 | 5638 /* end */ |