|
61
|
1 /* Micro-C Generic Code Generatation Part */
|
|
|
2 /* $Id$ */
|
|
|
3
|
|
|
4 #define EXTERN extern
|
|
|
5 #include "mc.h"
|
|
|
6 #include "mc-codegen.h"
|
|
|
7 #include "mc-code.h"
|
|
|
8
|
|
|
9 int creg; /* current register */
|
|
83
|
10
|
|
|
11 int use; /* generated value will be used */
|
|
81
|
12
|
|
61
|
13 /*
|
|
|
14 creg currrent virtual register
|
|
|
15 */
|
|
|
16
|
|
105
|
17 static void remove0(int *parent,int e) ;
|
|
|
18 /* static void remove0_all(int *parent,int e) ; */
|
|
|
19 static int is_same_type(int e1,int e2);
|
|
|
20 static void jump(int e1, int env);
|
|
|
21 static void machinop(int e1);
|
|
|
22 static void sassign(int e1);
|
|
|
23 static void assign(int e1);
|
|
|
24 static void assop(int e1);
|
|
|
25 static int g_expr0(int e1);
|
|
|
26 static int register_to_lvar(int e);
|
|
61
|
27
|
|
195
|
28 #if FLOAT_CODE
|
|
|
29
|
|
|
30 /* floating point */
|
|
|
31
|
|
|
32 static void dassop(int e1);
|
|
|
33 static void dmachinop(int e1,int d);
|
|
|
34 static void dassign(int e1);
|
|
|
35
|
|
|
36 #endif
|
|
|
37 #if LONGLONG_CODE
|
|
|
38 static void lassop(int e1);
|
|
|
39 static void lmachinop(int e1);
|
|
|
40 static void lassign(int e1);
|
|
|
41 #endif
|
|
|
42
|
|
|
43
|
|
102
|
44 void
|
|
|
45 codegen_init()
|
|
|
46 {
|
|
|
47 code_init();
|
|
|
48 }
|
|
|
49
|
|
137
|
50 void
|
|
|
51 arg_register(NMTBL *fnptr)
|
|
|
52 {
|
|
|
53 code_arg_register(fnptr);
|
|
|
54 }
|
|
|
55
|
|
94
|
56 int
|
|
83
|
57 gexpr(int e1,int use0)
|
|
61
|
58 {
|
|
94
|
59 if (chk) return INT;
|
|
61
|
60 gexpr_init();
|
|
83
|
61 use = use0;
|
|
61
|
62 #if 0
|
|
|
63 if(lineno==2862) {
|
|
94
|
64 return g_expr0(e1); /*break here*/
|
|
61
|
65 }
|
|
|
66 #endif
|
|
94
|
67 return g_expr0(e1);
|
|
61
|
68 }
|
|
|
69
|
|
|
70 int
|
|
83
|
71 g_expr_u(int e1)
|
|
|
72 {
|
|
94
|
73 int t;
|
|
83
|
74 int suse = use; use=0;
|
|
94
|
75 t=g_expr0(e1);
|
|
147
|
76 code_gexpr(e1);
|
|
|
77
|
|
83
|
78 use=suse;
|
|
94
|
79 return t;
|
|
83
|
80 }
|
|
|
81
|
|
94
|
82 int
|
|
61
|
83 g_expr(int e1)
|
|
|
84 {
|
|
94
|
85 int t;
|
|
83
|
86 int suse = use; use=1;
|
|
94
|
87 t=g_expr0(e1);
|
|
147
|
88 code_gexpr(e1);
|
|
|
89
|
|
83
|
90 use=suse;
|
|
94
|
91 return t;
|
|
83
|
92 }
|
|
|
93
|
|
94
|
94 int
|
|
83
|
95 g_expr0(int e1)
|
|
|
96 {
|
|
191
|
97 int e2,e3,t,d,t1;
|
|
61
|
98 NMTBL *n;
|
|
|
99
|
|
147
|
100 code_gexpr(e1);
|
|
|
101
|
|
61
|
102 e2 = cadr(e1);
|
|
|
103 switch (car(e1)){
|
|
|
104 case GVAR:
|
|
147
|
105 creg=use_int(creg);
|
|
107
|
106 code_gvar(e1,creg);
|
|
94
|
107 return ADDRESS;
|
|
61
|
108 case RGVAR:
|
|
147
|
109 creg=use_int(creg);
|
|
107
|
110 code_rgvar(e1,creg);
|
|
94
|
111 return INT;
|
|
61
|
112 case CRGVAR:
|
|
147
|
113 creg=use_int(creg);
|
|
165
|
114 code_crgvar(e1,creg,1,1);
|
|
94
|
115 return CHAR;
|
|
162
|
116 case CURGVAR:
|
|
|
117 creg=use_int(creg);
|
|
165
|
118 code_crgvar(e1,creg,0,1);
|
|
|
119 return UCHAR;
|
|
|
120 case SRGVAR:
|
|
|
121 creg=use_int(creg);
|
|
|
122 code_crgvar(e1,creg,1,size_of_short);
|
|
|
123 return CHAR;
|
|
|
124 case SURGVAR:
|
|
|
125 creg=use_int(creg);
|
|
|
126 code_crgvar(e1,creg,0,size_of_short);
|
|
162
|
127 return UCHAR;
|
|
61
|
128 case LVAR:
|
|
147
|
129 creg=use_int(creg);
|
|
119
|
130 code_lvar(e2,creg);
|
|
94
|
131 return ADDRESS;
|
|
61
|
132 case REGISTER:
|
|
147
|
133 creg=use_int(creg);
|
|
107
|
134 code_register(e2,creg);
|
|
94
|
135 return INT;
|
|
195
|
136 #if FLOAT_CODE
|
|
94
|
137 case DREGISTER:
|
|
147
|
138 creg=use_double(creg);
|
|
|
139 code_dregister(e2,creg,1);
|
|
94
|
140 return DOUBLE;
|
|
137
|
141 case FREGISTER:
|
|
147
|
142 creg=use_float(creg);
|
|
|
143 code_dregister(e2,creg,0);
|
|
137
|
144 return FLOAT;
|
|
195
|
145 #endif
|
|
61
|
146 case RLVAR:
|
|
147
|
147 creg=use_int(creg);
|
|
119
|
148 code_rlvar(e2,creg);
|
|
94
|
149 return INT;
|
|
61
|
150 case CRLVAR:
|
|
147
|
151 creg=use_int(creg);
|
|
165
|
152 code_crlvar(e2,creg,1,1);
|
|
94
|
153 return CHAR;
|
|
162
|
154 case CURLVAR:
|
|
|
155 creg=use_int(creg);
|
|
165
|
156 code_crlvar(e2,creg,0,1);
|
|
|
157 return UCHAR;
|
|
|
158 case SRLVAR:
|
|
|
159 creg=use_int(creg);
|
|
|
160 code_crlvar(e2,creg,1,size_of_short);
|
|
|
161 return CHAR;
|
|
|
162 case SURLVAR:
|
|
|
163 creg=use_int(creg);
|
|
|
164 code_crlvar(e2,creg,0,size_of_short);
|
|
162
|
165 return UCHAR;
|
|
195
|
166 #if FLOAT_CODE
|
|
81
|
167 case FRLVAR:
|
|
147
|
168 creg=use_float(creg);
|
|
|
169 code_drlvar(e2,0,creg);
|
|
94
|
170 return FLOAT;
|
|
81
|
171 case FRGVAR:
|
|
147
|
172 creg=use_float(creg);
|
|
|
173 code_drgvar(e1,0,creg);
|
|
94
|
174 return FLOAT;
|
|
81
|
175 case DRLVAR:
|
|
147
|
176 creg=use_double(creg);
|
|
|
177 code_drlvar(e2,1,creg);
|
|
94
|
178 return DOUBLE;
|
|
81
|
179 case DRGVAR:
|
|
147
|
180 creg=use_double(creg);
|
|
|
181 code_drgvar(e1,1,creg);
|
|
94
|
182 return DOUBLE;
|
|
195
|
183 #endif
|
|
202
|
184 #if LONGLONG_CODE
|
|
|
185 case LRLVAR:
|
|
|
186 creg=use_longlong(creg);
|
|
|
187 code_lrlvar(e2,creg);
|
|
|
188 return LONGLONG;
|
|
|
189 case LRGVAR:
|
|
|
190 creg=use_longlong(creg);
|
|
|
191 code_lrgvar(e1,creg);
|
|
|
192 return LONGLONG;
|
|
|
193 case LURLVAR:
|
|
|
194 creg=use_longlong(creg);
|
|
|
195 code_lrlvar(e2,creg);
|
|
|
196 return ULONGLONG;
|
|
|
197 case LURGVAR:
|
|
|
198 creg=use_longlong(creg);
|
|
|
199 code_lrgvar(e1,creg);
|
|
|
200 return ULONGLONG;
|
|
|
201 #endif
|
|
61
|
202 case FNAME:
|
|
147
|
203 creg=use_int(creg);
|
|
109
|
204 code_fname((NMTBL *)(e2),creg);
|
|
94
|
205 return ADDRESS;
|
|
61
|
206 case CONST: /* ÂåÆþ¤¹¤ëÃͤ¬0¤Ç¤âÆÃÊ̤ʽèÍý¤Ï¤·¤Ê¤¤ */
|
|
147
|
207 creg=use_int(creg);
|
|
107
|
208 code_const(e2,creg);
|
|
94
|
209 return INT;
|
|
195
|
210 #if FLOAT_CODE
|
|
81
|
211 case DCONST:
|
|
147
|
212 creg=use_double(creg);
|
|
|
213 code_dconst(e1,creg,1);
|
|
94
|
214 return DOUBLE;
|
|
133
|
215 case FCONST:
|
|
147
|
216 creg=use_float(creg);
|
|
|
217 code_dconst(e1,creg,0);
|
|
133
|
218 return FLOAT;
|
|
195
|
219 #endif
|
|
202
|
220 #if FLOAT_CODE
|
|
|
221 case LCONST:
|
|
|
222 creg=use_longlong(creg);
|
|
|
223 code_lconst(e1,creg);
|
|
|
224 return LONGLONG;
|
|
|
225 #endif
|
|
61
|
226 case STRING:
|
|
147
|
227 creg=use_int(creg);
|
|
107
|
228 code_string(e1,creg);
|
|
94
|
229 return ADDRESS;
|
|
61
|
230 case FUNCTION:
|
|
94
|
231 t = function(e1);
|
|
|
232 return t;
|
|
61
|
233 case CODE:
|
|
|
234 jump(e2,caddr(e1));
|
|
94
|
235 return VOID;
|
|
61
|
236 case INDIRECT:
|
|
94
|
237 return g_expr0(e2);
|
|
196
|
238 case RINDIRECT:
|
|
|
239 return code_rindirect(e2,caddr(e1),0);
|
|
|
240 case URINDIRECT:
|
|
|
241 return code_rindirect(e2,caddr(e1),1);
|
|
|
242 case CRINDIRECT:
|
|
|
243 return code_crindirect(e2,caddr(e1),0);
|
|
|
244 case CURINDIRECT:
|
|
|
245 return code_crindirect(e2,caddr(e1),1);
|
|
|
246 case SRINDIRECT:
|
|
|
247 return code_srindirect(e2,caddr(e1),0);
|
|
|
248 case SURINDIRECT:
|
|
|
249 return code_srindirect(e2,caddr(e1),1);
|
|
195
|
250 #if FLOAT_CODE
|
|
197
|
251 case FRINDIRECT:
|
|
|
252 return code_drindirect(e2,caddr(e1),0);
|
|
196
|
253 case DRINDIRECT:
|
|
|
254 return code_drindirect(e2,caddr(e1),1);
|
|
195
|
255 #endif
|
|
196
|
256 #if LONGLONG_CODE
|
|
|
257 case LRINDIRECT:
|
|
|
258 return code_lrindirect(e2,caddr(e1),0);
|
|
|
259 case LURINDIRECT:
|
|
|
260 return code_lrindirect(e2,caddr(e1),1);
|
|
|
261 #endif
|
|
61
|
262 case ADDRESS:
|
|
138
|
263 if (car(e2)==REGISTER||car(e2)==DREGISTER||car(e2)==FREGISTER)
|
|
|
264 return register_to_lvar(e2); /* too late? */
|
|
105
|
265 else
|
|
|
266 return g_expr0(e2);
|
|
61
|
267 case MINUS: /* ¥ì¥¸¥¹¥¿¤ËÂФ·¡¢negl¤ò¼Â¹Ô¤¹¤ì¤Ð¼Â¸½²Äǽ */
|
|
107
|
268 g_expr0(e2); code_neg(creg);
|
|
94
|
269 return INT;
|
|
195
|
270 #if FLOAT_CODE
|
|
81
|
271 case DMINUS:
|
|
147
|
272 g_expr0(e2); code_dneg(creg,1);
|
|
94
|
273 return DOUBLE;
|
|
133
|
274 case FMINUS:
|
|
147
|
275 g_expr0(e2); code_dneg(creg,0);
|
|
133
|
276 return FLOAT;
|
|
195
|
277 #endif
|
|
108
|
278 case CONV:
|
|
|
279 g_expr0(e2);
|
|
|
280 switch(caddr(e1)) {
|
|
195
|
281 #if FLOAT_CODE
|
|
147
|
282 case I2D: code_i2d(creg); return DOUBLE;
|
|
|
283 case D2I: code_d2i(creg); return INT;
|
|
|
284 case U2D: code_u2d(creg); return DOUBLE;
|
|
|
285 case F2U: code_f2u(creg); return UNSIGNED;
|
|
|
286 case I2F: code_i2f(creg); return FLOAT;
|
|
|
287 case F2I: code_f2i(creg); return INT;
|
|
|
288 case U2F: code_u2f(creg); return FLOAT;
|
|
|
289 case D2U: code_d2u(creg); return UNSIGNED;
|
|
|
290 case D2F: code_d2f(creg); return FLOAT;
|
|
|
291 case F2D: code_f2d(creg); return DOUBLE;
|
|
195
|
292 #endif
|
|
|
293 #if LONGLONG_CODE
|
|
|
294 case I2LL: code_i2ll(creg); return LONGLONG;
|
|
|
295 case I2ULL: code_i2ull(creg); return ULONGLONG;
|
|
|
296 case U2LL: code_u2ll(creg); return LONGLONG;
|
|
|
297 case U2ULL: code_u2ull(creg); return ULONGLONG;
|
|
|
298 case LL2I: code_ll2i(creg); return INT;
|
|
|
299 case LL2U: code_ll2u(creg); return UNSIGNED;
|
|
|
300 case ULL2I: code_ull2i(creg); return INT;
|
|
|
301 case ULL2U: code_ull2u(creg); return UNSIGNED;
|
|
|
302 #if FLOAT_CODE
|
|
|
303 case D2LL: code_d2ll(creg); return LONGLONG;
|
|
|
304 case D2ULL: code_d2ull(creg); return ULONGLONG;
|
|
|
305 case F2LL: code_f2ll(creg); return LONGLONG;
|
|
|
306 case F2ULL: code_f2ull(creg); return ULONGLONG;
|
|
|
307 case LL2D: code_ll2d(creg); return DOUBLE;
|
|
|
308 case LL2F: code_ll2f(creg); return FLOAT;
|
|
|
309 case ULL2D: code_ull2d(creg); return DOUBLE;
|
|
|
310 case ULL2F: code_ull2f(creg); return FLOAT;
|
|
|
311 case ULL2LL: code_ull2ll(creg); return LONGLONG;
|
|
|
312 case ULL2ULL: code_ull2ull(creg); return ULONGLONG;
|
|
|
313 #endif
|
|
|
314 #endif
|
|
|
315
|
|
108
|
316 default:
|
|
|
317 error(-1); return INT;
|
|
|
318 }
|
|
61
|
319 case BNOT: /* ~ */
|
|
107
|
320 g_expr0(e2); code_not(creg);
|
|
94
|
321 return INT;
|
|
61
|
322 case LNOT: /* ! */
|
|
107
|
323 g_expr0(e2); code_lnot(creg);
|
|
94
|
324 return INT;
|
|
61
|
325 case PREINC:
|
|
147
|
326 creg=use_int(creg);
|
|
168
|
327 code_preinc(e1,e2,caddr(e1),1,cadddr(e1),creg);
|
|
|
328 return INT;
|
|
|
329 case UPREINC:
|
|
|
330 creg=use_int(creg);
|
|
|
331 code_preinc(e1,e2,caddr(e1),0,cadddr(e1),creg);
|
|
94
|
332 return INT;
|
|
61
|
333 case POSTINC:
|
|
147
|
334 creg=use_int(creg);
|
|
168
|
335 code_postinc(e1,e2,caddr(e1),1,cadddr(e1),creg);
|
|
|
336 return INT;
|
|
|
337 case UPOSTINC:
|
|
|
338 creg=use_int(creg);
|
|
|
339 code_postinc(e1,e2,caddr(e1),0,cadddr(e1),creg);
|
|
94
|
340 return INT;
|
|
195
|
341 #if FLOAT_CODE
|
|
147
|
342 case DPREINC: /* ++d */
|
|
|
343 creg=use_double(creg);
|
|
|
344 code_dpreinc(e1,e2,1,creg);
|
|
94
|
345 return DOUBLE;
|
|
147
|
346 case DPOSTINC: /* d++ */
|
|
|
347 creg=use_double(creg);
|
|
|
348 code_dpostinc(e1,e2,1,creg);
|
|
94
|
349 return DOUBLE;
|
|
147
|
350 case FPREINC: /* ++f */
|
|
|
351 creg=use_float(creg);
|
|
|
352 code_dpreinc(e1,e2,0,creg);
|
|
94
|
353 return FLOAT;
|
|
147
|
354 case FPOSTINC: /* f++ */
|
|
|
355 creg=use_float(creg);
|
|
|
356 code_dpostinc(e1,e2,0,creg);
|
|
94
|
357 return FLOAT;
|
|
195
|
358 #endif
|
|
|
359 #if LONGLONG_CODE
|
|
|
360 case LPREINC: /* ++d */
|
|
|
361 creg=use_longlong(creg);
|
|
|
362 code_lpreinc(e1,e2,creg);
|
|
|
363 return DOUBLE;
|
|
|
364 case LPOSTINC: /* d++ */
|
|
|
365 creg=use_longlong(creg);
|
|
|
366 code_lpostinc(e1,e2,creg);
|
|
|
367 return DOUBLE;
|
|
|
368 #endif
|
|
61
|
369 case MUL: case UMUL:
|
|
|
370 case DIV: case UDIV:
|
|
|
371 case MOD: case UMOD:
|
|
|
372 case LSHIFT: case ULSHIFT: case RSHIFT: case URSHIFT:
|
|
94
|
373 case ADD: case SUB: case BAND: case EOR: case BOR: case CMP:
|
|
147
|
374 creg=use_int(creg);
|
|
61
|
375 machinop(e1);
|
|
94
|
376 return INT;
|
|
195
|
377 #if FLOAT_CODE
|
|
81
|
378 case DMUL: case DDIV:
|
|
|
379 case DADD: case DSUB:
|
|
91
|
380 case DCMP: case DCMPGE:
|
|
147
|
381 creg=use_double(creg);
|
|
133
|
382 dmachinop(e1,1);
|
|
94
|
383 return DOUBLE;
|
|
133
|
384 case FMUL: case FDIV:
|
|
|
385 case FADD: case FSUB:
|
|
|
386 case FCMP: case FCMPGE:
|
|
147
|
387 creg=use_float(creg);
|
|
133
|
388 dmachinop(e1,0);
|
|
|
389 return FLOAT;
|
|
108
|
390 case DCOND:
|
|
133
|
391 case FCOND:
|
|
195
|
392 #endif
|
|
|
393 #if LONGLONG_CODE
|
|
|
394 case LMUL: case LUMUL:
|
|
|
395 case LDIV: case LUDIV:
|
|
|
396 case LMOD: case LUMOD:
|
|
|
397 case LLSHIFT: case LULSHIFT: case LRSHIFT: case LURSHIFT:
|
|
|
398 case LADD: case LSUB: case LBAND: case LEOR: case LBOR: case LCMP:
|
|
|
399 creg=use_longlong(creg);
|
|
|
400 lmachinop(e1);
|
|
|
401 return INT;
|
|
|
402 #endif
|
|
|
403 case COND: /* a?0:1 should consider non-brach instruction */
|
|
|
404 d = (car(e1)==LCOND?LONGLONG:
|
|
|
405 car(e1)==COND?INT:car(e1)==DCOND?DOUBLE:FLOAT);
|
|
108
|
406 e2=fwdlabel();
|
|
|
407 b_expr(cadr(e1),0,e2,0);
|
|
187
|
408 g_expr0(caddr(e1));
|
|
|
409 t = code_get_fixed_creg(creg,d);
|
|
108
|
410 jmp(e3=fwdlabel());
|
|
|
411 fwddef(e2);
|
|
191
|
412 t1=g_expr0(cadddr(e1));
|
|
187
|
413 code_set_fixed_creg(t,1,d);
|
|
61
|
414 fwddef(e3);
|
|
191
|
415 return t1;
|
|
164
|
416 case STASS:
|
|
61
|
417 sassign(e1);
|
|
94
|
418 return RSTRUCT;
|
|
165
|
419 case ASS: case CASS: case SASS:
|
|
61
|
420 assign(e1);
|
|
94
|
421 return INT;
|
|
162
|
422 case ASSOP: case CASSOP: case CUASSOP:
|
|
61
|
423 assop(e1);
|
|
94
|
424 return INT;
|
|
195
|
425 #if FLOAT_CODE
|
|
|
426 case FASS: case DASS:
|
|
|
427 dassign(e1);
|
|
|
428 return DOUBLE;
|
|
81
|
429 case DASSOP: case FASSOP:
|
|
|
430 dassop(e1);
|
|
94
|
431 return DOUBLE;
|
|
195
|
432 #endif
|
|
|
433 #if LONGLONG_CODE
|
|
|
434 case LASS:
|
|
|
435 lassign(e1);
|
|
|
436 return LONGLONG;
|
|
|
437 case LASSOP: case LUASSOP:
|
|
|
438 lassop(e1);
|
|
|
439 return LONGLONG ;
|
|
|
440 #endif
|
|
61
|
441 case RSTRUCT:
|
|
83
|
442 g_expr0(e2);
|
|
94
|
443 return RSTRUCT;
|
|
61
|
444 case COMMA:
|
|
83
|
445 g_expr_u(e2);
|
|
94
|
446 return g_expr0(caddr(e1));
|
|
61
|
447 case RETURN:
|
|
147
|
448 creg = use_int(creg);
|
|
61
|
449 n = (NMTBL *)e2;
|
|
|
450 if (retcont==0)
|
|
|
451 retcont=fwdlabel();
|
|
|
452 code_return(creg);
|
|
94
|
453 return VOID;
|
|
61
|
454 case ENVIRONMENT:
|
|
147
|
455 creg = use_int(creg);
|
|
61
|
456 code_environment(creg);
|
|
94
|
457 return ADDRESS;
|
|
61
|
458 default:
|
|
116
|
459 code_bool(e1); /* type? */
|
|
94
|
460 return INT;
|
|
61
|
461 }
|
|
|
462 }
|
|
|
463
|
|
94
|
464 #define dual_ops(op) \
|
|
|
465 (op==GT|| op==UGT|| op==GE|| op==UGE|| op==LT|| \
|
|
|
466 op==ULT|| op==LE|| op==ULE|| \
|
|
|
467 op==DOP+GT|| op==DOP+GE|| op==DOP+LT|| op==DOP+LE || \
|
|
135
|
468 op==FOP+GT|| op==FOP+GE|| op==FOP+LT|| op==FOP+LE || \
|
|
|
469 op==FOP+EQ|| op==FOP+NEQ || \
|
|
|
470 op==EQ|| op==NEQ|| op==DOP+EQ|| op==DOP+NEQ)
|
|
94
|
471
|
|
|
472 int
|
|
|
473 rop_dual(op)
|
|
|
474 {
|
|
195
|
475 switch(op) {
|
|
|
476 case GT: return LT;
|
|
|
477 case UGT: return ULT;
|
|
|
478 case GE: return LE;
|
|
|
479 case UGE: return ULE;
|
|
|
480 case LT: return GT;
|
|
|
481 case ULT: return UGT;
|
|
|
482 case LE: return GE;
|
|
|
483 case ULE: return UGE;
|
|
|
484 case DOP+GT: return DOP+LT;
|
|
|
485 case DOP+GE: return DOP+LE;
|
|
|
486 case DOP+LT: return DOP+GT;
|
|
|
487 case DOP+LE: return DOP+GE;
|
|
|
488 case FOP+GT: return FOP+LT;
|
|
|
489 case FOP+GE: return FOP+LE;
|
|
|
490 case FOP+LT: return FOP+GT;
|
|
|
491 case FOP+LE: return FOP+GE;
|
|
|
492
|
|
|
493 case LOP+GT: return LOP+LT;
|
|
|
494 case LOP+GE: return LOP+LE;
|
|
|
495 case LOP+LT: return LOP+GT;
|
|
|
496 case LOP+LE: return LOP+GE;
|
|
|
497 case LOP+UGT: return FOP+ULT;
|
|
|
498 case LOP+UGE: return FOP+ULE;
|
|
|
499 case LOP+ULT: return FOP+UGT;
|
|
|
500 case LOP+ULE: return FOP+UGE;
|
|
|
501 }
|
|
94
|
502 return op;
|
|
|
503 }
|
|
|
504
|
|
61
|
505 void
|
|
|
506 bexpr(int e1, char cond, int l1)
|
|
|
507 {
|
|
94
|
508 int op = car(e1);
|
|
66
|
509 if (chk) return;
|
|
61
|
510 gexpr_init();
|
|
94
|
511 if (dual_ops(op) && (car(caddr(e1))==CONST||(car(caddr(e1))==DCONST)))
|
|
|
512 b_expr(list3(rop_dual(op),caddr(e1),cadr(e1)),cond,l1,0);
|
|
|
513 else
|
|
|
514 b_expr(e1,cond,l1,0);
|
|
61
|
515 }
|
|
|
516
|
|
|
517 void
|
|
|
518 b_expr(int e1, char cond, int l1,int err)
|
|
|
519 {
|
|
94
|
520 int e2,l2,t;
|
|
132
|
521 if (!control) return;
|
|
127
|
522 l2 = 0;
|
|
61
|
523 e2=cadr(e1);
|
|
|
524 switch(car(e1)) {
|
|
|
525 case LNOT:
|
|
|
526 b_expr(e2,!cond,l1,0);
|
|
|
527 return;
|
|
|
528 case GT:
|
|
89
|
529 rexpr(e1,l1,code_gt(cond),INT);
|
|
61
|
530 return;
|
|
|
531 case UGT:
|
|
89
|
532 rexpr(e1,l1,code_ugt(cond),UNSIGNED);
|
|
61
|
533 return;
|
|
|
534 case GE:
|
|
89
|
535 rexpr(e1,l1,code_ge(cond),INT);
|
|
61
|
536 return;
|
|
|
537 case UGE:
|
|
89
|
538 rexpr(e1,l1,code_uge(cond),UNSIGNED);
|
|
61
|
539 return;
|
|
|
540 case LT:
|
|
89
|
541 rexpr(e1,l1,code_ge(!cond),INT);
|
|
61
|
542 return;
|
|
|
543 case ULT:
|
|
89
|
544 rexpr(e1,l1,code_uge(!cond),UNSIGNED);
|
|
61
|
545 return;
|
|
|
546 case LE:
|
|
89
|
547 rexpr(e1,l1,code_gt(!cond),INT);
|
|
61
|
548 return;
|
|
|
549 case ULE:
|
|
89
|
550 rexpr(e1,l1,code_ugt(!cond),UNSIGNED);
|
|
61
|
551 return;
|
|
|
552 case EQ:
|
|
89
|
553 rexpr(e1,l1,code_eq(cond),INT);
|
|
61
|
554 return;
|
|
|
555 case NEQ:
|
|
89
|
556 rexpr(e1,l1,code_eq(!cond),INT);
|
|
61
|
557 return;
|
|
195
|
558 #if FLOAT_CODE
|
|
82
|
559 case DOP+GT:
|
|
194
|
560 case DOP+GE:
|
|
|
561 case DOP+EQ:
|
|
|
562 case DOP+NEQ:
|
|
|
563 case FOP+GT:
|
|
|
564 case FOP+GE:
|
|
|
565 case FOP+EQ:
|
|
|
566 case FOP+NEQ:
|
|
|
567 drexpr(cadr(e1),caddr(e1),l1,car(e1));
|
|
82
|
568 return;
|
|
194
|
569 case FOP+LT:
|
|
|
570 drexpr(caddr(e1),cadr(e1),l1,FOP+GT);
|
|
|
571 return;
|
|
|
572 case FOP+LE:
|
|
|
573 drexpr(caddr(e1),cadr(e1),l1,FOP+GE);
|
|
82
|
574 return;
|
|
|
575 case DOP+LT:
|
|
84
|
576 drexpr(caddr(e1),cadr(e1),l1,DOP+GT);
|
|
82
|
577 return;
|
|
|
578 case DOP+LE:
|
|
84
|
579 drexpr(caddr(e1),cadr(e1),l1,DOP+GE);
|
|
82
|
580 return;
|
|
195
|
581 #endif
|
|
|
582 #if LONGLONG_CODE
|
|
|
583 case LOP+GT:
|
|
|
584 case LOP+GE:
|
|
|
585 case LOP+EQ:
|
|
|
586 case LOP+NEQ:
|
|
|
587 lrexpr(cadr(e1),caddr(e1),l1,car(e1));
|
|
|
588 return;
|
|
|
589 case LOP+LT:
|
|
|
590 lrexpr(caddr(e1),cadr(e1),l1,LOP+GT);
|
|
|
591 return;
|
|
|
592 case LOP+LE:
|
|
|
593 lrexpr(caddr(e1),cadr(e1),l1,LOP+GE);
|
|
|
594 return;
|
|
|
595 #endif
|
|
61
|
596 case LAND:
|
|
|
597 b_expr(e2,0,cond?(l2=fwdlabel()):l1,0);
|
|
|
598 b_expr(caddr(e1),cond,l1,0);
|
|
|
599 if(cond) fwddef(l2);
|
|
|
600 return;
|
|
|
601 case LOR:
|
|
|
602 b_expr(e2,1,cond?l1:(l2=fwdlabel()),0);
|
|
|
603 b_expr(caddr(e1),cond,l1,0);
|
|
|
604 if(!cond) fwddef(l2);
|
|
|
605 return;
|
|
167
|
606 case CRGVAR: case CURGVAR:
|
|
147
|
607 creg=use_int(creg);
|
|
167
|
608 code_cmp_crgvar(e1,1);
|
|
61
|
609 jcond(l1,cond);
|
|
|
610 return;
|
|
167
|
611 case SRGVAR: case SURGVAR:
|
|
|
612 creg=use_int(creg);
|
|
|
613 code_cmp_crgvar(e1,size_of_short);
|
|
|
614 jcond(l1,cond);
|
|
|
615 return;
|
|
|
616 case CRLVAR: case CURLVAR:
|
|
147
|
617 creg=use_int(creg);
|
|
167
|
618 code_cmp_crlvar(e2,1);
|
|
|
619 jcond(l1,cond);
|
|
|
620 return;
|
|
|
621 case SRLVAR: case SURLVAR:
|
|
|
622 creg=use_int(creg);
|
|
|
623 code_cmp_crlvar(e2,size_of_short);
|
|
61
|
624 jcond(l1,cond);
|
|
|
625 return;
|
|
|
626 case RGVAR:
|
|
147
|
627 creg=use_int(creg);
|
|
61
|
628 code_cmp_rgvar(e1);
|
|
|
629 jcond(l1,cond);
|
|
|
630 return;
|
|
|
631 case RLVAR:
|
|
147
|
632 creg=use_int(creg);
|
|
119
|
633 code_cmp_rlvar(e2);
|
|
61
|
634 jcond(l1,cond);
|
|
|
635 return;
|
|
195
|
636 #if FLOATC_DOE
|
|
81
|
637 case DRLVAR:
|
|
147
|
638 creg=use_double(creg);
|
|
138
|
639 code_cmp_drlvar(e2,1);
|
|
|
640 jcond(l1,cond);
|
|
|
641 return;
|
|
|
642 case FRLVAR:
|
|
147
|
643 creg=use_float(creg);
|
|
138
|
644 code_cmp_drlvar(e2,0);
|
|
81
|
645 jcond(l1,cond);
|
|
|
646 return;
|
|
|
647 case DRGVAR:
|
|
147
|
648 creg=use_double(creg);
|
|
138
|
649 code_cmp_drgvar(e2,1);
|
|
|
650 jcond(l1,cond);
|
|
|
651 return;
|
|
|
652 case FRGVAR:
|
|
147
|
653 creg=use_float(creg);
|
|
138
|
654 code_cmp_drgvar(e2,0);
|
|
81
|
655 jcond(l1,cond);
|
|
|
656 return;
|
|
138
|
657 case FREGISTER:
|
|
147
|
658 creg=use_float(creg);
|
|
138
|
659 code_cmp_dregister(e2,0);
|
|
|
660 jcond(l1,cond);
|
|
|
661 return;
|
|
94
|
662 case DREGISTER:
|
|
147
|
663 creg=use_double(creg);
|
|
138
|
664 code_cmp_dregister(e2,1);
|
|
94
|
665 jcond(l1,cond);
|
|
|
666 return;
|
|
81
|
667 case DCONST:
|
|
138
|
668 case FCONST:
|
|
132
|
669 if(control&&((dcadr(e2)!=0.0)^cond)) jmp(l1);
|
|
81
|
670 return;
|
|
195
|
671 #endif
|
|
|
672 #if LONGLONG_DOE
|
|
|
673 case LRLVAR:
|
|
|
674 creg=use_longlong(creg);
|
|
|
675 code_cmp_lrlvar(e2,1);
|
|
|
676 jcond(l1,cond);
|
|
|
677 return;
|
|
|
678 case LRGVAR:
|
|
|
679 creg=use_longlong(creg);
|
|
|
680 code_cmp_lrgvar(e2,1);
|
|
|
681 jcond(l1,cond);
|
|
|
682 return;
|
|
|
683 case LREGISTER:
|
|
|
684 creg=use_longlong(creg);
|
|
|
685 code_cmp_lregister(e2,1);
|
|
|
686 jcond(l1,cond);
|
|
|
687 return;
|
|
|
688 case LCONST:
|
|
|
689 if(control&&((lcadr(e2)!=0)^cond)) jmp(l1);
|
|
|
690 return;
|
|
|
691 #endif
|
|
|
692 case REGISTER:
|
|
|
693 creg=use_int(creg);
|
|
|
694 code_cmp_register(e2);
|
|
|
695 jcond(l1,cond);
|
|
|
696 return;
|
|
|
697 case CONST:
|
|
|
698 if(control&&((cond&&e2)||(!cond&&!e2))) jmp(l1);
|
|
|
699 return;
|
|
61
|
700 default:
|
|
|
701 if(err) {
|
|
81
|
702 error(-1); return; /* recursive g_expr/b_expr */
|
|
94
|
703 }
|
|
|
704 t=g_expr(e1);
|
|
195
|
705 if (0) ;
|
|
|
706 #if FLOAT_CODE
|
|
|
707 else if(t==FLOAT)
|
|
147
|
708 code_cmp_dregister(creg,0);
|
|
138
|
709 else if(t==DOUBLE)
|
|
147
|
710 code_cmp_dregister(creg,1);
|
|
195
|
711 #endif
|
|
|
712 #if LONGLONG_CODE
|
|
|
713 else if(t==LONGLONG||t==ULONGLONG)
|
|
|
714 code_cmp_lregister(creg);
|
|
|
715 #endif
|
|
94
|
716 else
|
|
|
717 code_cmp_register(creg);
|
|
61
|
718 jcond(l1,cond);
|
|
|
719 return;
|
|
|
720 }
|
|
|
721 }
|
|
|
722
|
|
126
|
723 int
|
|
|
724 is_code(NMTBL *fnptr)
|
|
|
725 {
|
|
|
726 int type = fnptr->ty;
|
|
|
727 return type==CODE|| (type>0 && car(type)==CODE);
|
|
|
728 }
|
|
|
729
|
|
|
730 int
|
|
|
731 is_function(NMTBL *fnptr)
|
|
|
732 {
|
|
|
733 int type = fnptr->ty;
|
|
|
734 return type==FUNCTION || (type>0 && car(type)==FUNCTION);
|
|
|
735 }
|
|
|
736
|
|
61
|
737
|
|
105
|
738 static int
|
|
|
739 register_to_lvar(int e)
|
|
|
740 {
|
|
|
741 error(REG_ERR);
|
|
|
742 return 0;
|
|
|
743 #if 0
|
|
|
744 ÅÓÃæ¤Ç¥ì¥¸¥¹¥¿¤«¤éLVAR¤ËÊѹ¹¤·¤Æ¤â¡¢´Ö¤Ë¹ç¤ï¤Ê¤¤¡£
|
|
|
745
|
|
|
746 NMTBL *n = (NMTBL*)caddr(e);
|
|
|
747 int reg = cadr(e);
|
|
|
748 int tag = car(e);
|
|
|
749 int lvar;
|
|
|
750 int t;
|
|
|
751 if (!n||n==&null_nptr) error(REG_ERR);
|
|
|
752 if (tag==REGISTER) {
|
|
|
753 n->dsp = new_lvar(size_of_int);
|
|
|
754 t = INT;
|
|
|
755 } else if (tag==DREGISTER) {
|
|
|
756 n->dsp = new_lvar(size_of_double);
|
|
|
757 t = DOUBLE;
|
|
138
|
758 } else if (tag==FREGISTER) {
|
|
|
759 n->dsp = new_lvar(size_of_float);
|
|
|
760 t = DOUBLE;
|
|
195
|
761 } else if (tag==LREGISTER) {
|
|
|
762 n->dsp = new_lvar(size_of_longlong);
|
|
|
763 t = LONGLONG;
|
|
105
|
764 } else error(-1);
|
|
|
765 n->sc = LVAR;
|
|
|
766 lvar = list2(LVAR,n->dsp);
|
|
|
767 g_expr_u(assign_expr0(list2(LVAR,n->dsp),list3(tag,reg,(int)n),t,t));
|
|
195
|
768 if (tag==REGISTER||tag==DREGISTER||tag==FREGISTER||tag==LREGISTER) {
|
|
105
|
769 free_register(reg);
|
|
|
770 return g_expr0(lvar);
|
|
|
771 #endif
|
|
|
772 }
|
|
|
773
|
|
61
|
774 /* goto arguments list */
|
|
|
775 /* target list4(list2(tag,disp),cdr,ty,source_expr) */
|
|
|
776 /* source expr=listn(tag,...) */
|
|
|
777 /* source (after) list2(tag,disp) */
|
|
|
778 /* source list list3(e,cdr,sz) */
|
|
|
779
|
|
|
780 #define DEBUG_PARALLEL_ASSIGN 1
|
|
|
781
|
|
|
782 int
|
|
|
783 overrap(int t,int sz,int source)
|
|
|
784 {
|
|
|
785 int s,s0,s1;
|
|
|
786 int t0=cadr(t);
|
|
|
787 int t1=t0+sz;
|
|
|
788 for(;source;source=cadr(source)) {
|
|
|
789 s=car(source); s0=cadr(s);
|
|
|
790 if(car(s)==REGISTER && car(t)==REGISTER) {
|
|
|
791 if(s0==t0) return s;
|
|
|
792 } else if (is_same_type(s,t)) {
|
|
|
793 s1=s0+caddr(source);
|
|
|
794 #if DEBUG_PARALLEL_ASSIGN>1
|
|
|
795 printf("# ovedrrap source %d t0 %d t1 %d\n",car(car(t)),t0,t1);
|
|
|
796 printf("# ovedrrap target %d s0 %d s1 %d\n",car(car(source)),s0,s1);
|
|
|
797 printf("# ovedrrap equal = %d\n",((t0<=s0&&s0<t1)||(t0<s1&&s1<=t1)));
|
|
|
798 #endif
|
|
|
799 if((t0<=s0&&s0<t1)||(t0<s1&&s1<=t1)) return s;
|
|
|
800 }
|
|
|
801 }
|
|
|
802 return 0;
|
|
|
803 }
|
|
|
804
|
|
|
805 void
|
|
|
806 remove_target(int *target,int t,int *use)
|
|
|
807 {
|
|
|
808 int use0=*use;
|
|
147
|
809 int reg;
|
|
61
|
810 while(use0) {
|
|
|
811 if (car(use0)==t) {
|
|
147
|
812 reg = car(caddr(use0));
|
|
|
813 if (reg==REGISTER||reg==FREGISTER||reg==DREGISTER)
|
|
99
|
814 free_register(cadr(caddr(use0)));
|
|
61
|
815 break;
|
|
|
816 }
|
|
|
817 use0 = cadr(use0);
|
|
|
818 }
|
|
|
819 remove0(target,t);
|
|
|
820 }
|
|
|
821
|
|
|
822 void
|
|
|
823 save_target(int t,int s,int *target,int *use,int sz,int ty)
|
|
|
824 {
|
|
|
825 int e1;
|
|
|
826 /*¿·¤·¤¤¥ì¥¸¥¹¥¿(or ¥¹¥¿¥Ã¥¯)¤ò¼èÆÀ¤¹¤ë*/
|
|
|
827 if (sz==size_of_int && (e1=get_register())!=-1) {
|
|
105
|
828 e1=list3(REGISTER,e1,0);
|
|
61
|
829 *use=list3(t,*use,e1);
|
|
99
|
830 g_expr_u(assign_expr0(e1,s,ty,ty));
|
|
|
831 *target = append4(*target,t,ty,e1);
|
|
195
|
832 #if FLOAT_CODE
|
|
138
|
833 } else if (sz==size_of_double && (e1=get_dregister(1))!=-1) {
|
|
105
|
834 e1=list3(DREGISTER,e1,0);
|
|
99
|
835 *use=list3(t,*use,e1);
|
|
83
|
836 g_expr_u(assign_expr0(e1,s,ty,ty));
|
|
61
|
837 *target = append4(*target,t,ty,e1);
|
|
138
|
838 } else if (sz==size_of_float && (e1=get_dregister(0))!=-1) {
|
|
|
839 e1=list3(FREGISTER,e1,0);
|
|
|
840 *use=list3(t,*use,e1);
|
|
|
841 g_expr_u(assign_expr0(e1,s,ty,ty));
|
|
|
842 *target = append4(*target,t,ty,e1);
|
|
195
|
843 #endif
|
|
61
|
844 } else {
|
|
94
|
845 g_expr_u(assign_expr0((e1=list2(LVAR,new_lvar(sz))),s,ty,ty));
|
|
61
|
846 *target = append4(*target,t,ty,e1);
|
|
117
|
847 *use=list3(t,*use,e1);
|
|
61
|
848 }
|
|
|
849 }
|
|
|
850
|
|
|
851 int
|
|
|
852 circular_dependency(int t,int s,int *target,int *source)
|
|
|
853 {
|
|
|
854 int target0=*target;
|
|
|
855 int t1,sz,ty,s1;
|
|
|
856 while(target0) {
|
|
|
857 if (cadddr(target0)==s) {
|
|
|
858 t1=car(target0);
|
|
|
859 s=cadddr(target0);
|
|
|
860 sz=size(ty=caddr(target0));
|
|
|
861 if(t==t1) {
|
|
|
862 #if DEBUG_PARALLEL_ASSIGN
|
|
|
863 printf("# circular dependency %d ty %d+%d sz %d\n",car(t1),ty,cadr(t1),sz);
|
|
|
864 #endif
|
|
|
865 return 1;
|
|
|
866 }
|
|
|
867 if ((s1=overrap(t1,sz,*source))) {
|
|
|
868 /* another overrap start over */
|
|
|
869 return circular_dependency(t,s1,target,source);
|
|
|
870 }
|
|
|
871 }
|
|
|
872 target0=cadr(target0);
|
|
|
873 }
|
|
|
874 return 0;
|
|
|
875 }
|
|
|
876
|
|
|
877 void
|
|
|
878 parallel_assign(int *target,int *source,int *processing,int *use)
|
|
|
879 {
|
|
|
880 int t,s,sz,ty,target0,s1;
|
|
|
881 while(*target) {
|
|
|
882 target0=*target;
|
|
|
883 while(target0) {
|
|
|
884 t=car(target0); s=cadddr(target0);
|
|
|
885 sz=size(ty=caddr(target0));
|
|
|
886 if(car(t)==car(s) && cadr(t)==cadr(s)) {
|
|
|
887 /*½ñ¤¹þ¤ßÀ褬¼«Ê¬¼«¿È*/
|
|
|
888 #if DEBUG_PARALLEL_ASSIGN
|
|
|
889 printf("# remove same %d ty %d+%d sz %d\n",car(t),ty,cadr(t),sz);
|
|
|
890 #endif
|
|
|
891 remove_target(target,t,use);
|
|
|
892 /* Ç˲õ¤µ¤ì¤Æ¤Ïº¤¤ë¤Î¤Ç¡¢source list¤«¤é¤Ï½ü¤«¤Ê¤¤ */
|
|
|
893 } else if (!(s1=overrap(t,sz,*source))) {
|
|
|
894 /* ½Å¤Ê¤Ã¤Æ¤Ê¤¤¤Î¤Ç°Â¿´¤·¤Æ½ñ¤¹þ¤á¤ë */
|
|
|
895 #if DEBUG_PARALLEL_ASSIGN
|
|
|
896 printf("# normal assign %d ty %d+%d sz %d\n",car(t),ty,cadr(t),sz);
|
|
|
897 #endif
|
|
83
|
898 g_expr_u(assign_expr0(t,s,ty,ty));
|
|
61
|
899 remove_target(target,t,use); remove0(source,s);
|
|
|
900 } else {
|
|
|
901 if(circular_dependency(t,s1,target,source)) {
|
|
|
902 #if DEBUG_PARALLEL_ASSIGN
|
|
|
903 printf("# saving %d ty %d+%d sz %d\n",car(t),ty,cadr(t),sz);
|
|
|
904 #endif
|
|
|
905 remove_target(target,t,use); remove0(source,s);
|
|
|
906 save_target(t,s,target,use,sz,ty);
|
|
|
907 }
|
|
|
908 }
|
|
|
909 target0=cadr(target0);
|
|
|
910 }
|
|
|
911 }
|
|
|
912 }
|
|
|
913
|
|
|
914 void
|
|
|
915 remove0(int *parent,int e)
|
|
|
916 {
|
|
|
917 int list;
|
|
|
918 while ((list=*parent)) {
|
|
|
919 if (car(list)==e) {
|
|
|
920 *parent= cadr(list); return;
|
|
|
921 } else {
|
|
|
922 parent=&cadr(list);
|
|
|
923 }
|
|
|
924 }
|
|
|
925 }
|
|
|
926
|
|
105
|
927 /*
|
|
61
|
928 void
|
|
|
929 remove0_all(int *parent,int e)
|
|
|
930 {
|
|
|
931 int list;
|
|
|
932 while ((list=*parent)) {
|
|
|
933 if (car(list)==e) {
|
|
|
934 *parent= cadr(list);
|
|
|
935 } else {
|
|
|
936 parent=&cadr(list);
|
|
|
937 }
|
|
|
938 }
|
|
|
939 }
|
|
105
|
940 */
|
|
61
|
941
|
|
|
942 int
|
|
|
943 is_simple(int e1)
|
|
|
944 {
|
|
|
945 return (
|
|
99
|
946 e1==CONST || e1==FNAME || e1==LVAR || e1==REGISTER ||e1==DREGISTER ||
|
|
195
|
947 e1==FREGISTER || e1==LREGISTER ||
|
|
81
|
948 e1==GVAR || e1==RGVAR || e1==RLVAR || e1==CRLVAR || e1==CRGVAR ||
|
|
195
|
949 e1==DRLVAR || e1==FRLVAR || e1==LRLVAR ||
|
|
165
|
950 e1==CURLVAR || e1==SURLVAR || e1==CURGVAR || e1==SURGVAR
|
|
61
|
951 );
|
|
|
952 }
|
|
|
953
|
|
|
954 int
|
|
|
955 is_same_type(int e1,int e2)
|
|
|
956 {
|
|
|
957 int ce1=car(e1);
|
|
|
958 int ce2=car(e2);
|
|
|
959 return (
|
|
81
|
960 (ce1==LVAR && (ce2==RLVAR||ce2==CRLVAR||ce2==FRLVAR||ce2==DRLVAR))
|
|
165
|
961 || (ce1==LVAR && (ce2==SRLVAR||ce2==SURLVAR||ce2==CURLVAR))
|
|
81
|
962 || (ce2==LVAR && (ce1==RLVAR||ce1==CRLVAR||ce1==FRLVAR||ce1==DRLVAR))
|
|
165
|
963 || (ce2==LVAR && (ce1==SRLVAR||ce1==SURLVAR||ce1==CURLVAR))
|
|
195
|
964 || (ce2==LVAR && (ce1==LRLVAR))
|
|
81
|
965 || (ce1==GVAR && (ce2==RGVAR||ce2==CRGVAR||ce2==FRGVAR||ce2==DRGVAR))
|
|
165
|
966 || (ce1==GVAR && (ce2==SRGVAR||ce2==SURGVAR||ce2==CURGVAR))
|
|
81
|
967 || (ce2==GVAR && (ce1==RGVAR||ce1==CRGVAR||ce1==FRGVAR||ce1==DRGVAR))
|
|
165
|
968 || (ce2==GVAR && (ce1==SRGVAR||ce1==SURGVAR||ce1==CURGVAR))
|
|
195
|
969 || (ce2==GVAR && (ce1==LRGVAR))
|
|
61
|
970 );
|
|
|
971 }
|
|
|
972
|
|
|
973 int
|
|
|
974 is_memory(int e1)
|
|
|
975 {
|
|
|
976 int ce1=car(e1);
|
|
|
977 return (
|
|
195
|
978 ce1==LVAR ||ce1==RLVAR||ce1==CRLVAR || ce1==DRLVAR || ce1==LRLVAR ||
|
|
|
979 ce1==GVAR ||ce1==RGVAR||ce1==CRGVAR || ce1==DRGVAR || ce1==LRGVAR ||
|
|
|
980 ce1==FRLVAR || ce1==FRGVAR ||
|
|
165
|
981 ce1==CURGVAR ||ce1==SURGVAR||ce1==SRGVAR ||
|
|
138
|
982 ce1==REGISTER|| ce1==DREGISTER || ce1==FREGISTER
|
|
61
|
983 );
|
|
|
984 }
|
|
|
985
|
|
98
|
986
|
|
61
|
987 void
|
|
|
988 jump(int e1, int env)
|
|
|
989 {
|
|
99
|
990 int e2,e3,e4,sz,arg_size,ty,regs,fregs;
|
|
147
|
991 int t0,s0,r,reg;
|
|
127
|
992 NMTBL *code0 = 0;
|
|
61
|
993 int target = 0;
|
|
|
994 int source = 0;
|
|
|
995 int processing = 0;
|
|
|
996 int use = 0;
|
|
|
997
|
|
|
998 /* ¤Þ¤º¡¢¥µ¥¤¥º¤ò·×»»¤·¤Ê¤¬¤é¡¢·è¤Þ¤Ã¤¿·Á¤ËÍ¡£ */
|
|
|
999
|
|
99
|
1000 arg_size = 0; regs = 0;
|
|
|
1001 fregs = 0;
|
|
61
|
1002 for (e3 = reverse0(caddr(e1)); e3; e3 = cadr(e3)) {
|
|
|
1003 e2 = car(e3); sz = size(ty=caddr(e3));
|
|
138
|
1004 if (scalar(ty) && (r = get_input_register_var(regs,0,1))) {
|
|
|
1005 target=list4(r,target,ty,e2); regs++;
|
|
|
1006 } else if (ty==FLOAT && (r = get_input_dregister_var(fregs,0,1,0))) {
|
|
|
1007 target=list4(r, target,ty,e2); fregs++;
|
|
|
1008 } else if (ty==DOUBLE && (r = get_input_dregister_var(fregs,0,1,1))) {
|
|
|
1009 target=list4(r, target,ty,e2); fregs++;
|
|
61
|
1010 } else {
|
|
|
1011 target=list4(list2(LVAR,0), target,ty,e2);
|
|
|
1012 }
|
|
128
|
1013 /* keep arg space for register variables */
|
|
|
1014 arg_size += sz;
|
|
61
|
1015 #if DEBUG_PARALLEL_ASSIGN
|
|
|
1016 printf("# target %d ty %d+%d sz %d\n",car(car(target)),ty,cadr(car(target)),sz);
|
|
|
1017 #endif
|
|
|
1018 }
|
|
|
1019
|
|
|
1020 /* disp ¤òÈô¤ÓÀè»÷¹ç¤ï¤»¤Æ½¤Àµ */
|
|
98
|
1021 if (is_code(fnptr)) {
|
|
61
|
1022 if (-arg_size<disp) disp = -arg_size;
|
|
|
1023 } else {
|
|
|
1024 if (disp_offset-arg_size<disp) disp = disp_offset-arg_size;
|
|
|
1025 }
|
|
|
1026
|
|
|
1027 /* Ê£»¨¤Ê¼°¤òÁ°¤â¤Ã¤Æ·×»»¤·¤Æ¤ª¤¯ */
|
|
|
1028 /* ɬÍפʤé¶É½êÊÑ¿ô¤òÍѤ¤¤ë¡£ */
|
|
|
1029 /* ¶É½êÊÑ¿ô¤Ø¤Î¥ª¥Õ¥»¥Ã¥È¤ò³Ð¤¨¤Æ¤ª¤¯ */
|
|
|
1030
|
|
|
1031 for (e2 = target; e2; e2 = cadr(e2)) {
|
|
|
1032 t0=car(e2); s0=cadddr(e2);
|
|
|
1033 sz=size(ty=caddr(e2));
|
|
|
1034 if(car(t0)==LVAR) {
|
|
|
1035 /* ¤³¤³¤Ç¡¢½ñ¹þÀ襢¥É¥ì¥¹¤ò·è¤á¤ë */
|
|
|
1036 cadr(t0)=-arg_size;
|
|
|
1037 }
|
|
128
|
1038 arg_size-=sz;
|
|
61
|
1039 if (!is_simple(car(s0))) {
|
|
94
|
1040 g_expr_u(assign_expr0((e4=list2(LVAR,new_lvar(sz))),s0,ty,ty));
|
|
117
|
1041 use=list3(ty,use,e1);
|
|
61
|
1042 cadddr(e2)=e4;
|
|
|
1043 s0=e4;
|
|
|
1044 } else if (is_same_type(t0,s0)) {
|
|
|
1045 if(cadr(t0)==cadr(s0)) {
|
|
|
1046 #if DEBUG_PARALLEL_ASSIGN
|
|
|
1047 printf("# remove same memory %d ty %d+%d sz %d\n",car(t0),ty,cadr(t0),sz);
|
|
|
1048 #endif
|
|
|
1049 /* we should check size also (but currently useless */
|
|
|
1050 remove0(&target,t0);
|
|
|
1051 /* still we have source to avoid overwrite */
|
|
|
1052 }
|
|
|
1053 }
|
|
|
1054 if(is_memory(s0)) {
|
|
|
1055 source=list3(s0,source,sz);
|
|
|
1056 #if DEBUG_PARALLEL_ASSIGN
|
|
|
1057 printf("# source %d ty %d+%d sz %d\n",car(car(source)),ty,cadr(car(source)),sz);
|
|
|
1058 #endif
|
|
|
1059 }
|
|
|
1060 }
|
|
|
1061
|
|
|
1062 /* compute jump address */
|
|
|
1063 e2 = cadr(e1);
|
|
|
1064 if (car(e2) == FNAME) {
|
|
|
1065 code0=(NMTBL *)cadr(e2);
|
|
98
|
1066 if (!is_code(code0)) {
|
|
61
|
1067 error(TYERR); return;
|
|
|
1068 }
|
|
|
1069 } else { /* indirect */
|
|
|
1070 g_expr(e2);
|
|
|
1071 emit_push();
|
|
|
1072 }
|
|
|
1073 if (env) {
|
|
|
1074 g_expr(env);
|
|
|
1075 emit_push();
|
|
|
1076 }
|
|
|
1077
|
|
|
1078 /* ÊÂÎóÂåÆþ¤ò¼Â¹Ô */
|
|
|
1079 parallel_assign(&target,&source,&processing,&use);
|
|
|
1080 while (use) {
|
|
147
|
1081 reg = car(caddr(use));
|
|
195
|
1082 if (reg==REGISTER||reg==FREGISTER||reg==DREGISTER||reg==LREGISTER)
|
|
99
|
1083 free_register(cadr(caddr(use)));
|
|
117
|
1084 else if (car(caddr(use))==LVAR)
|
|
|
1085 free_lvar(cadr(caddr(use)));
|
|
99
|
1086 use=cadr(use);
|
|
61
|
1087 }
|
|
|
1088 if(target) error(-1);
|
|
|
1089
|
|
|
1090 if (env) {
|
|
|
1091 /* change the frame pointer */
|
|
|
1092 e3 = emit_pop(0);
|
|
|
1093 code_frame_pointer(e3);
|
|
|
1094 emit_pop_free(e3);
|
|
98
|
1095 } else if (is_function(fnptr)) {
|
|
128
|
1096 if (car(e2) != FNAME) {
|
|
|
1097 e2 = emit_pop(0);
|
|
|
1098 code_fix_frame_pointer(disp_offset);
|
|
|
1099 code_indirect_jmp(e2);
|
|
|
1100 emit_pop_free(e2);
|
|
|
1101 return;
|
|
|
1102 }
|
|
61
|
1103 code_fix_frame_pointer(disp_offset);
|
|
|
1104 }
|
|
|
1105
|
|
|
1106 if (car(e2) == FNAME) {
|
|
|
1107 code_jmp(code0->nm);
|
|
|
1108 } else {
|
|
|
1109 e2 = emit_pop(0);
|
|
|
1110 code_indirect_jmp(e2);
|
|
|
1111 emit_pop_free(e2);
|
|
|
1112 }
|
|
|
1113 }
|
|
|
1114
|
|
|
1115 void
|
|
|
1116 machinop(int e1)
|
|
|
1117 {
|
|
189
|
1118 int e2,e3,op,v;
|
|
61
|
1119
|
|
|
1120 e2 = cadr(e1);
|
|
|
1121 op = car(e1);
|
|
|
1122 e3 = caddr(e1);
|
|
189
|
1123 if (car(e3)==CONST && code_const_op_p(op,v=cadr(e3))) {
|
|
|
1124 g_expr(e2);
|
|
|
1125 oprtc(op,v);
|
|
|
1126 return;
|
|
|
1127 }
|
|
61
|
1128 g_expr(e3);
|
|
|
1129 emit_push();
|
|
|
1130 g_expr(e2);
|
|
189
|
1131 tosop(op,(e2=pop_register()));
|
|
61
|
1132 emit_pop_free(e2);
|
|
|
1133 return;
|
|
|
1134 }
|
|
|
1135
|
|
195
|
1136 #if FLOAT_CODE
|
|
81
|
1137 void
|
|
133
|
1138 dmachinop(int e1,int d)
|
|
81
|
1139 {
|
|
|
1140 int e2,e3,op;
|
|
|
1141
|
|
|
1142 e2 = cadr(e1);
|
|
|
1143 op = car(e1);
|
|
|
1144 e3 = caddr(e1);
|
|
|
1145 g_expr(e3);
|
|
133
|
1146 emit_dpush(d);
|
|
81
|
1147 g_expr(e2);
|
|
133
|
1148 dtosop(car(e1),(e2=emit_dpop(d)));
|
|
138
|
1149 emit_dpop_free(e2,d);
|
|
81
|
1150 return;
|
|
|
1151 }
|
|
195
|
1152 #endif
|
|
|
1153
|
|
|
1154 #if LONGLONG_CODE
|
|
|
1155 void
|
|
|
1156 lmachinop(int e1)
|
|
|
1157 {
|
|
|
1158 int e2,e3,op;
|
|
|
1159
|
|
|
1160 e2 = cadr(e1);
|
|
|
1161 op = car(e1);
|
|
|
1162 e3 = caddr(e1);
|
|
|
1163 g_expr(e3);
|
|
|
1164 emit_lpush();
|
|
|
1165 g_expr(e2);
|
|
|
1166 ltosop(car(e1),(e2=emit_lpop()));
|
|
|
1167 emit_lpop_free(e2);
|
|
|
1168 return;
|
|
|
1169 }
|
|
|
1170 #endif
|
|
81
|
1171
|
|
61
|
1172 void
|
|
|
1173 sassign(int e1)
|
|
|
1174 {
|
|
|
1175 int e2,e3,e4,sz,xreg,det;
|
|
|
1176
|
|
|
1177 /* structure assignment */
|
|
|
1178 e2 = cadr(e1); /* pointer variable to the struct */
|
|
|
1179 e3 = cadr(e2); /* offset of the variable (distination) */
|
|
|
1180 e4 = caddr(e1); /* right value (source) */
|
|
|
1181 sz = cadddr(e1); /* size of struct or union */
|
|
|
1182 g_expr(e4);
|
|
|
1183 emit_push();
|
|
|
1184 g_expr(e2);
|
|
|
1185 xreg = emit_pop(0);
|
|
|
1186 /* °ìÈÌŪ¤Ë¤Ï¥³¥Ô¡¼¤Î¥ª¡¼¥Ð¥é¥Ã¥×¤Î¾õ¶·¤Ï¼Â¹Ô»þ¤Ë¤·¤«¤ï¤«¤é¤Ê¤¤ */
|
|
|
1187 /* ¤·¤«¤·¡¢¤ï¤«¤ë¾ì¹ç¤â¤¢¤ë */
|
|
|
1188 if (car(e4)==RSTRUCT) e4=cadr(e4);
|
|
|
1189 if (is_same_type(e2,e4)) {
|
|
|
1190 if(cadr(e2)<cadr(e4)) sz=-sz;
|
|
|
1191 det=1;
|
|
|
1192 } else {
|
|
|
1193 det = 0;
|
|
|
1194 }
|
|
|
1195 emit_copy(xreg,creg,sz,0,1,det);
|
|
|
1196 emit_pop_free(xreg);
|
|
|
1197 return;
|
|
|
1198 }
|
|
|
1199
|
|
|
1200 void
|
|
118
|
1201 assign_opt(int e5,int e2,int e4,int byte)
|
|
|
1202 {
|
|
|
1203 int reg;
|
|
|
1204 /* e2=e4 */
|
|
|
1205 if (e5==REGISTER) {
|
|
|
1206 reg = cadr(e4);
|
|
|
1207 switch(car(e2)) {
|
|
|
1208 case GVAR: code_assign_gvar(e2,reg,byte); return;
|
|
119
|
1209 case LVAR: code_assign_lvar(cadr(e2),reg,byte); return;
|
|
118
|
1210 case REGISTER: code_assign_register(cadr(e2),byte,reg); return;
|
|
|
1211 }
|
|
|
1212 g_expr(e2);
|
|
154
|
1213 code_assign(creg,byte,reg);
|
|
118
|
1214 return;
|
|
|
1215 }
|
|
|
1216 /* e2 is register now */
|
|
|
1217 if (car(e2)!=REGISTER) error(-1);
|
|
|
1218 reg = cadr(e2);
|
|
|
1219 switch(e5) {
|
|
162
|
1220 case CRGVAR:
|
|
165
|
1221 case CURGVAR: code_crgvar(e4,reg,e5==CRGVAR,1); return;
|
|
|
1222 case SRGVAR:
|
|
|
1223 case SURGVAR: code_crgvar(e4,reg,e5==SRGVAR,size_of_short); return;
|
|
118
|
1224 case RGVAR: code_rgvar(e4,reg); return;
|
|
162
|
1225 case CRLVAR:
|
|
165
|
1226 case CURLVAR: code_crlvar(cadr(e4),reg,e5==CRLVAR,1); return;
|
|
|
1227 case SRLVAR:
|
|
|
1228 case SURLVAR: code_crlvar(cadr(e4),reg,e5==SRLVAR,size_of_short); return;
|
|
119
|
1229 case RLVAR: code_rlvar(cadr(e4),reg); return;
|
|
118
|
1230 case GVAR: code_gvar(e4,reg); return;
|
|
119
|
1231 case LVAR: code_lvar(cadr(e4),reg); return;
|
|
118
|
1232 case CONST: code_const(cadr(e4),reg); return;
|
|
|
1233 case ADDRESS:
|
|
|
1234 if (car(cadr(e4))==STRING) code_string(cadr(e4),reg);
|
|
|
1235 else code_gvar(cadr(e4),reg);
|
|
|
1236 return;
|
|
|
1237 case FNAME: code_fname((NMTBL*)cadr(e4),reg); return;
|
|
|
1238 case STRING: code_string(e4,reg); return;
|
|
135
|
1239 default: error(-1);
|
|
118
|
1240 }
|
|
|
1241 }
|
|
|
1242
|
|
|
1243 void
|
|
61
|
1244 assign(int e1)
|
|
|
1245 {
|
|
118
|
1246 int e2,e4,byte,e5;
|
|
61
|
1247
|
|
166
|
1248 byte=(car(e1) == CASS)?1:(car(e1) == SASS)?size_of_short:0;
|
|
61
|
1249 /* e2=e4 */
|
|
|
1250 e2 = cadr(e1);
|
|
118
|
1251 e4 = caddr(e1);e5=car(e4);
|
|
|
1252 if (!use && (
|
|
|
1253 (e5==REGISTER) ||
|
|
|
1254 (car(e2)==REGISTER&&(
|
|
|
1255 e5== CRGVAR || e5== CRLVAR || e5== RGVAR || e5== RLVAR ||
|
|
162
|
1256 e5== CURGVAR || e5== CURLVAR ||
|
|
165
|
1257 e5== SURGVAR || e5== SURLVAR ||
|
|
118
|
1258 e5== GVAR || e5== LVAR ||
|
|
|
1259 e5== CONST || e5== FNAME || e5== STRING ||
|
|
|
1260 (e5==ADDRESS&&car(cadr(e4))==STRING) ||
|
|
|
1261 (e5==ADDRESS&&car(cadr(e4))==GVAR) )))) {
|
|
147
|
1262 creg = use_int(creg);
|
|
118
|
1263 assign_opt(e5,e2,e4,byte);
|
|
|
1264 return;
|
|
|
1265 }
|
|
61
|
1266 switch(car(e2)) {
|
|
|
1267 case GVAR: /* i=3 */
|
|
|
1268 g_expr(e4);
|
|
103
|
1269 code_assign_gvar(e2,creg,byte);
|
|
61
|
1270 return;
|
|
|
1271 case LVAR:
|
|
|
1272 g_expr(e4);
|
|
119
|
1273 code_assign_lvar(cadr(e2),creg,byte);
|
|
61
|
1274 return;
|
|
|
1275 case REGISTER:
|
|
|
1276 g_expr(e4);
|
|
|
1277 if (creg!=cadr(e2))
|
|
111
|
1278 code_assign_register(cadr(e2),byte,creg);
|
|
61
|
1279 return;
|
|
|
1280 }
|
|
|
1281 g_expr(e2);
|
|
|
1282 emit_push();
|
|
|
1283 g_expr(e4);
|
|
|
1284 e2 = emit_pop(0);
|
|
118
|
1285 code_assign(e2,byte,creg);
|
|
61
|
1286 emit_pop_free(e2);
|
|
|
1287 return;
|
|
|
1288 }
|
|
|
1289
|
|
195
|
1290 #if FLOAT_CODE
|
|
|
1291
|
|
61
|
1292 void
|
|
118
|
1293 dassign_opt(int e5,int e2,int e4,int d)
|
|
|
1294 {
|
|
|
1295 int reg;
|
|
|
1296 /* e2=e4 */
|
|
138
|
1297 if (e5==DREGISTER||e5==FREGISTER) {
|
|
118
|
1298 reg = cadr(e4);
|
|
|
1299 switch(car(e2)) {
|
|
|
1300 case GVAR: /* i=3 */
|
|
|
1301 code_dassign_gvar(e2,reg,d);
|
|
|
1302 return;
|
|
|
1303 case LVAR:
|
|
119
|
1304 code_dassign_lvar(cadr(e2),reg,d);
|
|
118
|
1305 return;
|
|
|
1306 case DREGISTER:
|
|
138
|
1307 case FREGISTER:
|
|
118
|
1308 if (reg!=cadr(e2))
|
|
138
|
1309 code_dassign_dregister(cadr(e2),d,reg);
|
|
118
|
1310 return;
|
|
135
|
1311 default:
|
|
|
1312 error(-1);
|
|
118
|
1313 }
|
|
|
1314 }
|
|
|
1315 /* e2 is register now */
|
|
138
|
1316 if (car(e2)!=DREGISTER && car(e2)!=FREGISTER) error(-1);
|
|
118
|
1317 reg = cadr(e2);
|
|
|
1318 switch(e5) {
|
|
135
|
1319 case FRGVAR:
|
|
118
|
1320 case DRGVAR: code_drgvar(e4,d,reg); return;
|
|
135
|
1321 case FRLVAR:
|
|
119
|
1322 case DRLVAR: code_drlvar(cadr(e4),d,reg); return;
|
|
135
|
1323 case FCONST:
|
|
138
|
1324 case DCONST: code_dconst(e4,reg,1); return;
|
|
135
|
1325 default:
|
|
118
|
1326 error(-1);
|
|
|
1327 }
|
|
|
1328 }
|
|
|
1329
|
|
|
1330 void
|
|
81
|
1331 dassign(int e1)
|
|
|
1332 {
|
|
118
|
1333 int e2,e3,e4,d,e5;
|
|
81
|
1334
|
|
|
1335 /* e2=e4 */
|
|
|
1336 e2 = cadr(e1);
|
|
|
1337 e3 = cadr(e2);
|
|
118
|
1338 e4 = caddr(e1); e5=car(e4);
|
|
82
|
1339 d = (car(e1)==LASS)?2:(car(e1)==DASS)?1:0;
|
|
118
|
1340 if (!use && (
|
|
138
|
1341 (e5==DREGISTER) || (e5==FREGISTER) ||
|
|
133
|
1342 (car(e2)==DREGISTER&&(e5==DRGVAR||e5==DRLVAR||e5==DCONST))||
|
|
|
1343 (car(e2)==DREGISTER&&(e5==FRGVAR||e5==FRLVAR||e5==FCONST))
|
|
118
|
1344 )) {
|
|
147
|
1345 creg = d?use_double(creg):use_float(creg);
|
|
118
|
1346 dassign_opt(e5,e2,e4,d);
|
|
|
1347 return;
|
|
|
1348 }
|
|
81
|
1349 switch(car(e2)) {
|
|
82
|
1350 case GVAR:
|
|
81
|
1351 g_expr(e4);
|
|
151
|
1352 creg = d?use_double(creg):use_float(creg);
|
|
147
|
1353 code_dassign_gvar(e2,creg,d);
|
|
81
|
1354 return;
|
|
|
1355 case LVAR:
|
|
|
1356 g_expr(e4);
|
|
151
|
1357 creg = d?use_double(creg):use_float(creg);
|
|
147
|
1358 code_dassign_lvar(cadr(e2),creg,d);
|
|
81
|
1359 return;
|
|
111
|
1360 case DREGISTER:
|
|
138
|
1361 case FREGISTER:
|
|
111
|
1362 g_expr(e4);
|
|
147
|
1363 if (creg!=cadr(e2)) {
|
|
|
1364 if (d) creg = use_double(creg); else creg = use_float(creg);
|
|
|
1365 code_dassign_dregister(cadr(e2),d,creg);
|
|
|
1366 }
|
|
111
|
1367 return;
|
|
81
|
1368 }
|
|
|
1369 g_expr(e2);
|
|
82
|
1370 emit_push();
|
|
81
|
1371 g_expr(e4);
|
|
82
|
1372 e2 = emit_pop(0);
|
|
147
|
1373 code_dassign(e2,creg,d);
|
|
82
|
1374 emit_pop_free(e2);
|
|
81
|
1375 return;
|
|
|
1376 }
|
|
|
1377
|
|
195
|
1378 #endif
|
|
|
1379
|
|
|
1380 #if LONGLONG_CODE
|
|
|
1381
|
|
|
1382 void
|
|
|
1383 lassign_opt(int e5,int e2,int e4)
|
|
|
1384 {
|
|
|
1385 int reg;
|
|
|
1386 /* e2=e4 */
|
|
|
1387 if (e5==LREGISTER) {
|
|
|
1388 reg = cadr(e4);
|
|
|
1389 switch(car(e2)) {
|
|
|
1390 case GVAR: /* i=3 */
|
|
|
1391 code_lassign_gvar(e2,reg);
|
|
|
1392 return;
|
|
|
1393 case LVAR:
|
|
|
1394 code_lassign_lvar(cadr(e2),reg);
|
|
|
1395 return;
|
|
|
1396 case LREGISTER:
|
|
|
1397 if (reg!=cadr(e2))
|
|
|
1398 code_lassign_lregister(cadr(e2),reg);
|
|
|
1399 return;
|
|
|
1400 default:
|
|
|
1401 error(-1);
|
|
|
1402 }
|
|
|
1403 }
|
|
|
1404 /* e2 is register now */
|
|
|
1405 if (car(e2)!=LREGISTER) error(-1);
|
|
|
1406 reg = cadr(e2);
|
|
|
1407 switch(e5) {
|
|
|
1408 case LRGVAR: code_lrgvar(e4,reg); return;
|
|
|
1409 case LRLVAR: code_lrlvar(cadr(e4),reg); return;
|
|
|
1410 case LCONST: code_lconst(e4,reg); return;
|
|
|
1411 default:
|
|
|
1412 error(-1);
|
|
|
1413 }
|
|
|
1414 }
|
|
|
1415
|
|
|
1416 void
|
|
|
1417 lassign(int e1)
|
|
|
1418 {
|
|
|
1419 int e2,e3,e4,e5;
|
|
|
1420
|
|
|
1421 /* e2=e4 */
|
|
|
1422 e2 = cadr(e1);
|
|
|
1423 e3 = cadr(e2);
|
|
|
1424 e4 = caddr(e1); e5=car(e4);
|
|
|
1425 if (!use && (
|
|
|
1426 (e5==LREGISTER) ||
|
|
|
1427 (car(e2)==LREGISTER&&(e5==LRGVAR||e5==LRLVAR||e5==LCONST))
|
|
|
1428 )) {
|
|
|
1429 creg = use_longlong(creg);
|
|
|
1430 lassign_opt(e5,e2,e4);
|
|
|
1431 return;
|
|
|
1432 }
|
|
|
1433 switch(car(e2)) {
|
|
|
1434 case GVAR:
|
|
|
1435 g_expr(e4);
|
|
|
1436 creg = use_longlong(creg);
|
|
|
1437 code_lassign_gvar(e2,creg);
|
|
|
1438 return;
|
|
|
1439 case LVAR:
|
|
|
1440 g_expr(e4);
|
|
|
1441 creg = use_longlong(creg);
|
|
|
1442 code_lassign_lvar(cadr(e2),creg);
|
|
|
1443 return;
|
|
|
1444 case LREGISTER:
|
|
|
1445 g_expr(e4);
|
|
|
1446 if (creg!=cadr(e2)) {
|
|
|
1447 creg = use_longlong(creg);
|
|
|
1448 code_lassign_lregister(cadr(e2),creg);
|
|
|
1449 }
|
|
|
1450 return;
|
|
|
1451 }
|
|
|
1452 g_expr(e2);
|
|
|
1453 emit_lpush();
|
|
|
1454 g_expr(e4);
|
|
|
1455 e2 = emit_lpop();
|
|
|
1456 code_lassign(e2,creg);
|
|
|
1457 emit_lpop_free(e2);
|
|
|
1458 return;
|
|
|
1459 }
|
|
|
1460
|
|
|
1461 #endif
|
|
|
1462
|
|
81
|
1463 void
|
|
61
|
1464 assop(int e1)
|
|
|
1465 {
|
|
165
|
1466 int e2,e3,byte,op,sign,size;
|
|
61
|
1467
|
|
|
1468 /* e2 op= e3 */
|
|
162
|
1469 if (car(e1) == CUASSOP) {
|
|
165
|
1470 byte = 1; sign = 0; size = 1;
|
|
162
|
1471 } else if (car(e1) == CASSOP) {
|
|
165
|
1472 byte = 1; sign = 1; size = 1;
|
|
|
1473 } else if (car(e1) == SUASSOP) {
|
|
|
1474 byte = size_of_short; sign = 0; size = size_of_short;
|
|
|
1475 } else if (car(e1) == SASSOP) {
|
|
|
1476 byte = size_of_short; sign = 1; size = size_of_short;
|
|
162
|
1477 } else {
|
|
165
|
1478 byte = 0; sign = 1; size = size_of_int;
|
|
162
|
1479 }
|
|
61
|
1480 e2 = cadr(e1);
|
|
|
1481 if (car(e2)==INDIRECT) e2=cadr(e2);
|
|
|
1482 e3 = caddr(e1);
|
|
|
1483 op = cadddr(e1);
|
|
|
1484
|
|
147
|
1485 creg = use_int(creg);
|
|
61
|
1486 g_expr(e3);
|
|
|
1487 if (car(e2)==REGISTER) {
|
|
|
1488 code_register_assop(cadr(e2),op,byte);
|
|
|
1489 return;
|
|
|
1490 }
|
|
|
1491 emit_push();
|
|
|
1492 g_expr(e2);
|
|
162
|
1493 code_assop(op,byte,sign);
|
|
61
|
1494 return;
|
|
|
1495 }
|
|
|
1496
|
|
195
|
1497 #if FLOAT_CODE
|
|
|
1498
|
|
81
|
1499 void
|
|
|
1500 dassop(int e1)
|
|
|
1501 {
|
|
83
|
1502 int e2,e3,op,d;
|
|
81
|
1503
|
|
83
|
1504 /* e2 op= e3 */
|
|
|
1505 d = (car(e1) == DASSOP);
|
|
|
1506 e2 = cadr(e1);
|
|
|
1507 if (car(e2)==INDIRECT) e2=cadr(e2);
|
|
|
1508 e3 = caddr(e1);
|
|
|
1509 op = cadddr(e1);
|
|
|
1510
|
|
147
|
1511 creg = d?use_double(creg):use_float(creg);
|
|
83
|
1512 g_expr(e3);
|
|
133
|
1513 emit_dpush(d);
|
|
83
|
1514 g_expr(e2);
|
|
144
|
1515 if (car(e2)==DREGISTER||car(e2)==FREGISTER) {
|
|
|
1516 /* code_register_dassop(cadr(e2),op,d); */
|
|
|
1517 error(-1); /* unsupported now */
|
|
|
1518 return;
|
|
|
1519 }
|
|
83
|
1520 code_dassop(op,d);
|
|
|
1521 return;
|
|
81
|
1522 }
|
|
61
|
1523
|
|
195
|
1524 #endif
|
|
|
1525
|
|
|
1526 #if LONGLONG_CODE
|
|
|
1527
|
|
|
1528 void
|
|
|
1529 lassop(int e1)
|
|
|
1530 {
|
|
|
1531 int e2,e3,op;
|
|
|
1532
|
|
|
1533 /* e2 op= e3 */
|
|
|
1534 e2 = cadr(e1);
|
|
|
1535 if (car(e2)==INDIRECT) e2=cadr(e2);
|
|
|
1536 e3 = caddr(e1);
|
|
|
1537 op = cadddr(e1);
|
|
|
1538
|
|
|
1539 creg = use_longlong(creg);
|
|
|
1540 g_expr(e3);
|
|
|
1541 emit_lpush();
|
|
|
1542 g_expr(e2);
|
|
|
1543 if (car(e2)==LREGISTER) {
|
|
|
1544 /* code_register_lassop(cadr(e2),op); */
|
|
|
1545 error(-1); /* unsupported now */
|
|
|
1546 return;
|
|
|
1547 }
|
|
|
1548 code_lassop(op);
|
|
|
1549 return;
|
|
|
1550 }
|
|
|
1551
|
|
|
1552 #endif
|
|
|
1553
|
|
95
|
1554 void
|
|
|
1555 cmpdimm(int e, int csreg)
|
|
|
1556 {
|
|
|
1557 code_cmpdimm(e, csreg);
|
|
|
1558 }
|
|
|
1559
|
|
|
1560 int
|
|
|
1561 csvalue()
|
|
|
1562 {
|
|
|
1563 return code_csvalue();
|
|
|
1564 }
|
|
|
1565
|
|
|
1566
|
|
61
|
1567 int
|
|
|
1568 fwdlabel(void)
|
|
|
1569 {
|
|
|
1570 return labelno++;
|
|
|
1571 }
|
|
|
1572
|
|
|
1573 void
|
|
|
1574 fwddef(int l)
|
|
|
1575 {
|
|
|
1576 control=1;
|
|
66
|
1577 if (!chk)
|
|
92
|
1578 code_label(l);
|
|
61
|
1579 }
|
|
|
1580
|
|
|
1581 int
|
|
|
1582 backdef(void)
|
|
|
1583 {
|
|
|
1584 control=1;
|
|
66
|
1585 if (!chk)
|
|
92
|
1586 code_label(labelno);
|
|
61
|
1587 return labelno++;
|
|
|
1588 }
|
|
|
1589
|
|
|
1590 void
|
|
|
1591 def_label(int cslabel, int dlabel)
|
|
|
1592 {
|
|
|
1593 int fl;
|
|
|
1594
|
|
|
1595 fl = 0;
|
|
|
1596 if (control) {
|
|
|
1597 jmp(fl=fwdlabel());
|
|
|
1598 }
|
|
|
1599 fwddef(cslabel);
|
|
|
1600 if (dlabel)
|
|
|
1601 jmp(dlabel);
|
|
|
1602 if (fl) {
|
|
|
1603 fwddef(fl);
|
|
|
1604 }
|
|
|
1605 }
|
|
|
1606
|
|
|
1607 void
|
|
|
1608 gen_source(char *s)
|
|
|
1609 {
|
|
|
1610 printf("%s",s);
|
|
|
1611 }
|
|
|
1612
|
|
|
1613 void
|
|
|
1614 ret(void)
|
|
|
1615 {
|
|
107
|
1616 code_set_return_register(1);
|
|
61
|
1617 jmp(retlabel);
|
|
|
1618 }
|
|
|
1619
|
|
66
|
1620 void
|
|
|
1621 opening(char *filename)
|
|
|
1622 {
|
|
|
1623 emit_init();
|
|
|
1624 if (!chk)
|
|
|
1625 code_opening(filename);
|
|
|
1626 }
|
|
|
1627
|
|
|
1628 void
|
|
|
1629 closing()
|
|
|
1630 {
|
|
|
1631 if (!chk)
|
|
|
1632 code_closing();
|
|
|
1633 }
|
|
|
1634
|
|
99
|
1635 int
|
|
|
1636 contains_in_list(int e,int type)
|
|
|
1637 {
|
|
|
1638 while(e) {
|
|
|
1639 if(contains(car(e),type)) return 1;
|
|
|
1640 e = cadr(e);
|
|
|
1641 }
|
|
|
1642 return 0;
|
|
|
1643 }
|
|
|
1644
|
|
|
1645 int
|
|
|
1646 contains(int e,int type)
|
|
|
1647 {
|
|
|
1648 while(e) {
|
|
|
1649 if (car(e)==type) return 1;
|
|
164
|
1650 if (LIST_ARGS(car(e))){
|
|
99
|
1651 /* list arguments */
|
|
|
1652 return contains_in_list(caddr(e),type);
|
|
164
|
1653 } else if (UNARY_ARGS(car(e))) {
|
|
99
|
1654 /* unary operators */
|
|
|
1655 e = cadr(e);
|
|
|
1656 continue;
|
|
164
|
1657 } else if (BINARY_ARGS(car(e))) {
|
|
99
|
1658 /* biary operators */
|
|
|
1659 if (contains(cadr(e),type)) return 1;
|
|
|
1660 e = caddr(e);
|
|
|
1661 continue;
|
|
164
|
1662 } else if (TARNARY_ARGS(car(e))) {
|
|
99
|
1663 /* tarary operators */
|
|
|
1664 if (contains(cadr(e), type)) return 1;
|
|
|
1665 if (contains(caddr(e),type)) return 1;
|
|
|
1666 e = cadddr(e);
|
|
|
1667 continue;
|
|
164
|
1668 } else if (NULLARY_ARGS(car(e))) {
|
|
135
|
1669 /* nullary operators */
|
|
|
1670 return 0;
|
|
164
|
1671 } else {
|
|
135
|
1672 fprintf(stderr,"Unknown Tree ID %d\n",car(e));
|
|
|
1673 error(-1);
|
|
99
|
1674 return 0;
|
|
|
1675 }
|
|
|
1676 }
|
|
|
1677 return 0;
|
|
|
1678 }
|
|
|
1679
|
|
61
|
1680 /* end */
|
