source: EcnlProtoTool/trunk/tcc-0.9.27/il-gen.c@ 331

Last change on this file since 331 was 331, checked in by coas-nagasima, 6 years ago

prototoolに関連するプロジェクトをnewlibからmuslを使うよう変更・更新
ntshellをnewlibの下位の実装から、muslのsyscallの実装に変更・更新
以下のOSSをアップデート
・mruby-1.3.0
・musl-1.1.18
・onigmo-6.1.3
・tcc-0.9.27
以下のOSSを追加
・openssl-1.1.0e
・curl-7.57.0
・zlib-1.2.11
以下のmrbgemsを追加
・iij/mruby-digest
・iij/mruby-env
・iij/mruby-errno
・iij/mruby-iijson
・iij/mruby-ipaddr
・iij/mruby-mock
・iij/mruby-require
・iij/mruby-tls-openssl
  • Property svn:eol-style set to native
  • Property svn:mime-type set to text/x-csrc;charset=UTF-8
File size: 16.0 KB
Line 
1/*
2 * CIL code generator for TCC
3 *
4 * Copyright (c) 2002 Fabrice Bellard
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 */
20
21#error this code has bit-rotted since 2003
22
23/* number of available registers */
24#define NB_REGS 3
25
26/* a register can belong to several classes. The classes must be
27 sorted from more general to more precise (see gv2() code which does
28 assumptions on it). */
29#define RC_ST 0x0001 /* any stack entry */
30#define RC_ST0 0x0002 /* top of stack */
31#define RC_ST1 0x0004 /* top - 1 */
32
33#define RC_INT RC_ST
34#define RC_FLOAT RC_ST
35#define RC_IRET RC_ST0 /* function return: integer register */
36#define RC_LRET RC_ST0 /* function return: second integer register */
37#define RC_FRET RC_ST0 /* function return: float register */
38
39/* pretty names for the registers */
40enum {
41 REG_ST0 = 0,
42 REG_ST1,
43 REG_ST2,
44};
45
46const int reg_classes[NB_REGS] = {
47 /* ST0 */ RC_ST | RC_ST0,
48 /* ST1 */ RC_ST | RC_ST1,
49 /* ST2 */ RC_ST,
50};
51
52/* return registers for function */
53#define REG_IRET REG_ST0 /* single word int return register */
54#define REG_LRET REG_ST0 /* second word return register (for long long) */
55#define REG_FRET REG_ST0 /* float return register */
56
57/* defined if function parameters must be evaluated in reverse order */
58/* #define INVERT_FUNC_PARAMS */
59
60/* defined if structures are passed as pointers. Otherwise structures
61 are directly pushed on stack. */
62/* #define FUNC_STRUCT_PARAM_AS_PTR */
63
64/* pointer size, in bytes */
65#define PTR_SIZE 4
66
67/* long double size and alignment, in bytes */
68#define LDOUBLE_SIZE 8
69#define LDOUBLE_ALIGN 8
70
71/* function call context */
72typedef struct GFuncContext {
73 int func_call; /* func call type (FUNC_STDCALL or FUNC_CDECL) */
74} GFuncContext;
75
76/******************************************************/
77/* opcode definitions */
78
79#define IL_OP_PREFIX 0xFE
80
81enum ILOPCodes {
82#define OP(name, str, n) IL_OP_ ## name = n,
83#include "il-opcodes.h"
84#undef OP
85};
86
87char *il_opcodes_str[] = {
88#define OP(name, str, n) [n] = str,
89#include "il-opcodes.h"
90#undef OP
91};
92
93/******************************************************/
94
95/* arguments variable numbers start from there */
96#define ARG_BASE 0x70000000
97
98static FILE *il_outfile;
99
100static void out_byte(int c)
101{
102 *(char *)ind++ = c;
103}
104
105static void out_le32(int c)
106{
107 out_byte(c);
108 out_byte(c >> 8);
109 out_byte(c >> 16);
110 out_byte(c >> 24);
111}
112
113static void init_outfile(void)
114{
115 if (!il_outfile) {
116 il_outfile = stdout;
117 fprintf(il_outfile,
118 ".assembly extern mscorlib\n"
119 "{\n"
120 ".ver 1:0:2411:0\n"
121 "}\n\n");
122 }
123}
124
125static void out_op1(int op)
126{
127 if (op & 0x100)
128 out_byte(IL_OP_PREFIX);
129 out_byte(op & 0xff);
130}
131
132/* output an opcode with prefix */
133static void out_op(int op)
134{
135 out_op1(op);
136 fprintf(il_outfile, " %s\n", il_opcodes_str[op]);
137}
138
139static void out_opb(int op, int c)
140{
141 out_op1(op);
142 out_byte(c);
143 fprintf(il_outfile, " %s %d\n", il_opcodes_str[op], c);
144}
145
146static void out_opi(int op, int c)
147{
148 out_op1(op);
149 out_le32(c);
150 fprintf(il_outfile, " %s 0x%x\n", il_opcodes_str[op], c);
151}
152
153/* XXX: not complete */
154static void il_type_to_str(char *buf, int buf_size,
155 int t, const char *varstr)
156{
157 int bt;
158 Sym *s, *sa;
159 char buf1[256];
160 const char *tstr;
161
162 t = t & VT_TYPE;
163 bt = t & VT_BTYPE;
164 buf[0] = '\0';
165 if (t & VT_UNSIGNED)
166 pstrcat(buf, buf_size, "unsigned ");
167 switch(bt) {
168 case VT_VOID:
169 tstr = "void";
170 goto add_tstr;
171 case VT_BOOL:
172 tstr = "bool";
173 goto add_tstr;
174 case VT_BYTE:
175 tstr = "int8";
176 goto add_tstr;
177 case VT_SHORT:
178 tstr = "int16";
179 goto add_tstr;
180 case VT_ENUM:
181 case VT_INT:
182 case VT_LONG:
183 tstr = "int32";
184 goto add_tstr;
185 case VT_LLONG:
186 tstr = "int64";
187 goto add_tstr;
188 case VT_FLOAT:
189 tstr = "float32";
190 goto add_tstr;
191 case VT_DOUBLE:
192 case VT_LDOUBLE:
193 tstr = "float64";
194 add_tstr:
195 pstrcat(buf, buf_size, tstr);
196 break;
197 case VT_STRUCT:
198 tcc_error("structures not handled yet");
199 break;
200 case VT_FUNC:
201 s = sym_find((unsigned)t >> VT_STRUCT_SHIFT);
202 il_type_to_str(buf, buf_size, s->t, varstr);
203 pstrcat(buf, buf_size, "(");
204 sa = s->next;
205 while (sa != NULL) {
206 il_type_to_str(buf1, sizeof(buf1), sa->t, NULL);
207 pstrcat(buf, buf_size, buf1);
208 sa = sa->next;
209 if (sa)
210 pstrcat(buf, buf_size, ", ");
211 }
212 pstrcat(buf, buf_size, ")");
213 goto no_var;
214 case VT_PTR:
215 s = sym_find((unsigned)t >> VT_STRUCT_SHIFT);
216 pstrcpy(buf1, sizeof(buf1), "*");
217 if (varstr)
218 pstrcat(buf1, sizeof(buf1), varstr);
219 il_type_to_str(buf, buf_size, s->t, buf1);
220 goto no_var;
221 }
222 if (varstr) {
223 pstrcat(buf, buf_size, " ");
224 pstrcat(buf, buf_size, varstr);
225 }
226 no_var: ;
227}
228
229
230/* patch relocation entry with value 'val' */
231void greloc_patch1(Reloc *p, int val)
232{
233}
234
235/* output a symbol and patch all calls to it */
236void gsym_addr(t, a)
237{
238}
239
240/* output jump and return symbol */
241static int out_opj(int op, int c)
242{
243 out_op1(op);
244 out_le32(0);
245 if (c == 0) {
246 c = ind - (int)cur_text_section->data;
247 }
248 fprintf(il_outfile, " %s L%d\n", il_opcodes_str[op], c);
249 return c;
250}
251
252void gsym(int t)
253{
254 fprintf(il_outfile, "L%d:\n", t);
255}
256
257/* load 'r' from value 'sv' */
258void load(int r, SValue *sv)
259{
260 int v, fc, ft;
261
262 v = sv->r & VT_VALMASK;
263 fc = sv->c.i;
264 ft = sv->t;
265
266 if (sv->r & VT_LVAL) {
267 if (v == VT_LOCAL) {
268 if (fc >= ARG_BASE) {
269 fc -= ARG_BASE;
270 if (fc >= 0 && fc <= 4) {
271 out_op(IL_OP_LDARG_0 + fc);
272 } else if (fc <= 0xff) {
273 out_opb(IL_OP_LDARG_S, fc);
274 } else {
275 out_opi(IL_OP_LDARG, fc);
276 }
277 } else {
278 if (fc >= 0 && fc <= 4) {
279 out_op(IL_OP_LDLOC_0 + fc);
280 } else if (fc <= 0xff) {
281 out_opb(IL_OP_LDLOC_S, fc);
282 } else {
283 out_opi(IL_OP_LDLOC, fc);
284 }
285 }
286 } else if (v == VT_CONST) {
287 /* XXX: handle globals */
288 out_opi(IL_OP_LDSFLD, 0);
289 } else {
290 if ((ft & VT_BTYPE) == VT_FLOAT) {
291 out_op(IL_OP_LDIND_R4);
292 } else if ((ft & VT_BTYPE) == VT_DOUBLE) {
293 out_op(IL_OP_LDIND_R8);
294 } else if ((ft & VT_BTYPE) == VT_LDOUBLE) {
295 out_op(IL_OP_LDIND_R8);
296 } else if ((ft & VT_TYPE) == VT_BYTE)
297 out_op(IL_OP_LDIND_I1);
298 else if ((ft & VT_TYPE) == (VT_BYTE | VT_UNSIGNED))
299 out_op(IL_OP_LDIND_U1);
300 else if ((ft & VT_TYPE) == VT_SHORT)
301 out_op(IL_OP_LDIND_I2);
302 else if ((ft & VT_TYPE) == (VT_SHORT | VT_UNSIGNED))
303 out_op(IL_OP_LDIND_U2);
304 else
305 out_op(IL_OP_LDIND_I4);
306 }
307 } else {
308 if (v == VT_CONST) {
309 /* XXX: handle globals */
310 if (fc >= -1 && fc <= 8) {
311 out_op(IL_OP_LDC_I4_M1 + fc + 1);
312 } else {
313 out_opi(IL_OP_LDC_I4, fc);
314 }
315 } else if (v == VT_LOCAL) {
316 if (fc >= ARG_BASE) {
317 fc -= ARG_BASE;
318 if (fc <= 0xff) {
319 out_opb(IL_OP_LDARGA_S, fc);
320 } else {
321 out_opi(IL_OP_LDARGA, fc);
322 }
323 } else {
324 if (fc <= 0xff) {
325 out_opb(IL_OP_LDLOCA_S, fc);
326 } else {
327 out_opi(IL_OP_LDLOCA, fc);
328 }
329 }
330 } else {
331 /* XXX: do it */
332 }
333 }
334}
335
336/* store register 'r' in lvalue 'v' */
337void store(int r, SValue *sv)
338{
339 int v, fc, ft;
340
341 v = sv->r & VT_VALMASK;
342 fc = sv->c.i;
343 ft = sv->t;
344 if (v == VT_LOCAL) {
345 if (fc >= ARG_BASE) {
346 fc -= ARG_BASE;
347 /* XXX: check IL arg store semantics */
348 if (fc <= 0xff) {
349 out_opb(IL_OP_STARG_S, fc);
350 } else {
351 out_opi(IL_OP_STARG, fc);
352 }
353 } else {
354 if (fc >= 0 && fc <= 4) {
355 out_op(IL_OP_STLOC_0 + fc);
356 } else if (fc <= 0xff) {
357 out_opb(IL_OP_STLOC_S, fc);
358 } else {
359 out_opi(IL_OP_STLOC, fc);
360 }
361 }
362 } else if (v == VT_CONST) {
363 /* XXX: handle globals */
364 out_opi(IL_OP_STSFLD, 0);
365 } else {
366 if ((ft & VT_BTYPE) == VT_FLOAT)
367 out_op(IL_OP_STIND_R4);
368 else if ((ft & VT_BTYPE) == VT_DOUBLE)
369 out_op(IL_OP_STIND_R8);
370 else if ((ft & VT_BTYPE) == VT_LDOUBLE)
371 out_op(IL_OP_STIND_R8);
372 else if ((ft & VT_BTYPE) == VT_BYTE)
373 out_op(IL_OP_STIND_I1);
374 else if ((ft & VT_BTYPE) == VT_SHORT)
375 out_op(IL_OP_STIND_I2);
376 else
377 out_op(IL_OP_STIND_I4);
378 }
379}
380
381/* start function call and return function call context */
382void gfunc_start(GFuncContext *c, int func_call)
383{
384 c->func_call = func_call;
385}
386
387/* push function parameter which is in (vtop->t, vtop->c). Stack entry
388 is then popped. */
389void gfunc_param(GFuncContext *c)
390{
391 if ((vtop->t & VT_BTYPE) == VT_STRUCT) {
392 tcc_error("structures passed as value not handled yet");
393 } else {
394 /* simply push on stack */
395 gv(RC_ST0);
396 }
397 vtop--;
398}
399
400/* generate function call with address in (vtop->t, vtop->c) and free function
401 context. Stack entry is popped */
402void gfunc_call(GFuncContext *c)
403{
404 char buf[1024];
405
406 if ((vtop->r & (VT_VALMASK | VT_LVAL)) == VT_CONST) {
407 /* XXX: more info needed from tcc */
408 il_type_to_str(buf, sizeof(buf), vtop->t, "xxx");
409 fprintf(il_outfile, " call %s\n", buf);
410 } else {
411 /* indirect call */
412 gv(RC_INT);
413 il_type_to_str(buf, sizeof(buf), vtop->t, NULL);
414 fprintf(il_outfile, " calli %s\n", buf);
415 }
416 vtop--;
417}
418
419/* generate function prolog of type 't' */
420void gfunc_prolog(int t)
421{
422 int addr, u, func_call;
423 Sym *sym;
424 char buf[1024];
425
426 init_outfile();
427
428 /* XXX: pass function name to gfunc_prolog */
429 il_type_to_str(buf, sizeof(buf), t, funcname);
430 fprintf(il_outfile, ".method static %s il managed\n", buf);
431 fprintf(il_outfile, "{\n");
432 /* XXX: cannot do better now */
433 fprintf(il_outfile, " .maxstack %d\n", NB_REGS);
434 fprintf(il_outfile, " .locals (int32, int32, int32, int32, int32, int32, int32, int32)\n");
435
436 if (!strcmp(funcname, "main"))
437 fprintf(il_outfile, " .entrypoint\n");
438
439 sym = sym_find((unsigned)t >> VT_STRUCT_SHIFT);
440 func_call = sym->r;
441
442 addr = ARG_BASE;
443 /* if the function returns a structure, then add an
444 implicit pointer parameter */
445 func_vt = sym->t;
446 func_var = (sym->c == FUNC_ELLIPSIS);
447 if ((func_vt & VT_BTYPE) == VT_STRUCT) {
448 func_vc = addr;
449 addr++;
450 }
451 /* define parameters */
452 while ((sym = sym->next) != NULL) {
453 u = sym->t;
454 sym_push(sym->v & ~SYM_FIELD, u,
455 VT_LOCAL | lvalue_type(sym->type.t), addr);
456 addr++;
457 }
458}
459
460/* generate function epilog */
461void gfunc_epilog(void)
462{
463 out_op(IL_OP_RET);
464 fprintf(il_outfile, "}\n\n");
465}
466
467/* generate a jump to a label */
468int gjmp(int t)
469{
470 return out_opj(IL_OP_BR, t);
471}
472
473/* generate a jump to a fixed address */
474void gjmp_addr(int a)
475{
476 /* XXX: handle syms */
477 out_opi(IL_OP_BR, a);
478}
479
480/* generate a test. set 'inv' to invert test. Stack entry is popped */
481int gtst(int inv, int t)
482{
483 int v, *p, c;
484
485 v = vtop->r & VT_VALMASK;
486 if (v == VT_CMP) {
487 c = vtop->c.i ^ inv;
488 switch(c) {
489 case TOK_EQ:
490 c = IL_OP_BEQ;
491 break;
492 case TOK_NE:
493 c = IL_OP_BNE_UN;
494 break;
495 case TOK_LT:
496 c = IL_OP_BLT;
497 break;
498 case TOK_LE:
499 c = IL_OP_BLE;
500 break;
501 case TOK_GT:
502 c = IL_OP_BGT;
503 break;
504 case TOK_GE:
505 c = IL_OP_BGE;
506 break;
507 case TOK_ULT:
508 c = IL_OP_BLT_UN;
509 break;
510 case TOK_ULE:
511 c = IL_OP_BLE_UN;
512 break;
513 case TOK_UGT:
514 c = IL_OP_BGT_UN;
515 break;
516 case TOK_UGE:
517 c = IL_OP_BGE_UN;
518 break;
519 }
520 t = out_opj(c, t);
521 } else if (v == VT_JMP || v == VT_JMPI) {
522 /* && or || optimization */
523 if ((v & 1) == inv) {
524 /* insert vtop->c jump list in t */
525 p = &vtop->c.i;
526 while (*p != 0)
527 p = (int *)*p;
528 *p = t;
529 t = vtop->c.i;
530 } else {
531 t = gjmp(t);
532 gsym(vtop->c.i);
533 }
534 }
535 vtop--;
536 return t;
537}
538
539/* generate an integer binary operation */
540void gen_opi(int op)
541{
542 gv2(RC_ST1, RC_ST0);
543 switch(op) {
544 case '+':
545 out_op(IL_OP_ADD);
546 goto std_op;
547 case '-':
548 out_op(IL_OP_SUB);
549 goto std_op;
550 case '&':
551 out_op(IL_OP_AND);
552 goto std_op;
553 case '^':
554 out_op(IL_OP_XOR);
555 goto std_op;
556 case '|':
557 out_op(IL_OP_OR);
558 goto std_op;
559 case '*':
560 out_op(IL_OP_MUL);
561 goto std_op;
562 case TOK_SHL:
563 out_op(IL_OP_SHL);
564 goto std_op;
565 case TOK_SHR:
566 out_op(IL_OP_SHR_UN);
567 goto std_op;
568 case TOK_SAR:
569 out_op(IL_OP_SHR);
570 goto std_op;
571 case '/':
572 case TOK_PDIV:
573 out_op(IL_OP_DIV);
574 goto std_op;
575 case TOK_UDIV:
576 out_op(IL_OP_DIV_UN);
577 goto std_op;
578 case '%':
579 out_op(IL_OP_REM);
580 goto std_op;
581 case TOK_UMOD:
582 out_op(IL_OP_REM_UN);
583 std_op:
584 vtop--;
585 vtop[0].r = REG_ST0;
586 break;
587 case TOK_EQ:
588 case TOK_NE:
589 case TOK_LT:
590 case TOK_LE:
591 case TOK_GT:
592 case TOK_GE:
593 case TOK_ULT:
594 case TOK_ULE:
595 case TOK_UGT:
596 case TOK_UGE:
597 vtop--;
598 vtop[0].r = VT_CMP;
599 vtop[0].c.i = op;
600 break;
601 }
602}
603
604/* generate a floating point operation 'v = t1 op t2' instruction. The
605 two operands are guaranteed to have the same floating point type */
606void gen_opf(int op)
607{
608 /* same as integer */
609 gen_opi(op);
610}
611
612/* convert integers to fp 't' type. Must handle 'int', 'unsigned int'
613 and 'long long' cases. */
614void gen_cvt_itof(int t)
615{
616 gv(RC_ST0);
617 if (t == VT_FLOAT)
618 out_op(IL_OP_CONV_R4);
619 else
620 out_op(IL_OP_CONV_R8);
621}
622
623/* convert fp to int 't' type */
624/* XXX: handle long long case */
625void gen_cvt_ftoi(int t)
626{
627 gv(RC_ST0);
628 switch(t) {
629 case VT_INT | VT_UNSIGNED:
630 out_op(IL_OP_CONV_U4);
631 break;
632 case VT_LLONG:
633 out_op(IL_OP_CONV_I8);
634 break;
635 case VT_LLONG | VT_UNSIGNED:
636 out_op(IL_OP_CONV_U8);
637 break;
638 default:
639 out_op(IL_OP_CONV_I4);
640 break;
641 }
642}
643
644/* convert from one floating point type to another */
645void gen_cvt_ftof(int t)
646{
647 gv(RC_ST0);
648 if (t == VT_FLOAT) {
649 out_op(IL_OP_CONV_R4);
650 } else {
651 out_op(IL_OP_CONV_R8);
652 }
653}
654
655/* end of CIL code generator */
656/*************************************************************/
657
Note: See TracBrowser for help on using the repository browser.