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