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