?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
db: look up all the function pointers
[smatch.git] / compile-i386.c
blobda3ee4978f728056c2a5f0621cc910c065d258d1
1 /*
2 * sparse/compile-i386.c
3 *
4 * Copyright (C) 2003 Transmeta Corp.
5 * 2003 Linus Torvalds
6 * Copyright 2003 Jeff Garzik
7 *
8 * Licensed under the Open Software License version 1.1
9 *
10 * x86 backend
11 *
12 * TODO list:
13 * in general, any non-32bit SYM_BASETYPE is unlikely to work.
14 * complex initializers
15 * bitfields
16 * global struct/union variables
17 * addressing structures, and members of structures (as opposed to
18 * scalars) on the stack. Requires smarter stack frame allocation.
19 * labels / goto
20 * any function argument that isn't 32 bits (or promoted to such)
21 * inline asm
22 * floating point
23 *
24 */
25 #include <stdarg.h>
26 #include <stdlib.h>
27 #include <stdio.h>
28 #include <string.h>
29 #include <ctype.h>
30 #include <unistd.h>
31 #include <fcntl.h>
32 #include <assert.h>
33
34 #include "lib.h"
35 #include "allocate.h"
36 #include "token.h"
37 #include "parse.h"
38 #include "symbol.h"
39 #include "scope.h"
40 #include "expression.h"
41 #include "target.h"
42 #include "compile.h"
43 #include "bitmap.h"
44
45 struct textbuf {
46 unsigned int len; /* does NOT include terminating null */
47 char *text;
48 struct textbuf *next;
49 struct textbuf *prev;
50 };
51
52 struct loop_stack {
53 int continue_lbl;
54 int loop_bottom_lbl;
55 struct loop_stack *next;
56 };
57
58 struct atom;
59 struct storage;
60 DECLARE_PTR_LIST(str_list, struct atom);
61 DECLARE_PTR_LIST(atom_list, struct atom);
62 DECLARE_PTR_LIST(storage_list, struct storage);
63
64 struct function {
65 int stack_size;
66 int pseudo_nr;
67 struct storage_list *pseudo_list;
68 struct atom_list *atom_list;
69 struct str_list *str_list;
70 struct loop_stack *loop_stack;
71 struct symbol **argv;
72 unsigned int argc;
73 int ret_target;
74 };
75
76 enum storage_type {
77 STOR_PSEUDO, /* variable stored on the stack */
78 STOR_ARG, /* function argument */
79 STOR_SYM, /* a symbol we can directly ref in the asm */
80 STOR_REG, /* scratch register */
81 STOR_VALUE, /* integer constant */
82 STOR_LABEL, /* label / jump target */
83 STOR_LABELSYM, /* label generated from symbol's pointer value */
84 };
85
86 struct reg_info {
87 const char *name;
88 struct storage *contains;
89 const unsigned char aliases[12];
90 #define own_regno aliases[0]
91 };
92
93 struct storage {
94 enum storage_type type;
95 unsigned long flags;
96
97 /* STOR_REG */
98 struct reg_info *reg;
99 struct symbol *ctype;
100
101 union {
102 /* STOR_PSEUDO */
103 struct {
104 int pseudo;
105 int offset;
106 int size;
107 };
108 /* STOR_ARG */
109 struct {
110 int idx;
111 };
112 /* STOR_SYM */
113 struct {
114 struct symbol *sym;
115 };
116 /* STOR_VALUE */
117 struct {
118 long long value;
119 };
120 /* STOR_LABEL */
121 struct {
122 int label;
123 };
124 /* STOR_LABELSYM */
125 struct {
126 struct symbol *labelsym;
127 };
128 };
129 };
130
131 enum {
132 STOR_LABEL_VAL = (1 << 0),
133 STOR_WANTS_FREE = (1 << 1),
134 };
135
136 struct symbol_private {
137 struct storage *addr;
138 };
139
140 enum atom_type {
141 ATOM_TEXT,
142 ATOM_INSN,
143 ATOM_CSTR,
144 };
145
146 struct atom {
147 enum atom_type type;
148 union {
149 /* stuff for text */
150 struct {
151 char *text;
152 unsigned int text_len; /* w/o terminating null */
153 };
154
155 /* stuff for insns */
156 struct {
157 char insn[32];
158 char comment[40];
159 struct storage *op1;
160 struct storage *op2;
161 };
162
163 /* stuff for C strings */
164 struct {
165 struct string *string;
166 int label;
167 };
168 };
169 };
170
171
172 static struct function *current_func = NULL;
173 static struct textbuf *unit_post_text = NULL;
174 static const char *current_section;
175
176 static void emit_comment(const char * fmt, ...) FORMAT_ATTR(1);
177 static void emit_move(struct storage *src, struct storage *dest,
178 struct symbol *ctype, const char *comment);
179 static int type_is_signed(struct symbol *sym);
180 static struct storage *x86_address_gen(struct expression *expr);
181 static struct storage *x86_symbol_expr(struct symbol *sym);
182 static void x86_symbol(struct symbol *sym);
183 static struct storage *x86_statement(struct statement *stmt);
184 static struct storage *x86_expression(struct expression *expr);
185
186 enum registers {
187 NOREG,
188 AL, DL, CL, BL, AH, DH, CH, BH, // 8-bit
189 AX, DX, CX, BX, SI, DI, BP, SP, // 16-bit
190 EAX, EDX, ECX, EBX, ESI, EDI, EBP, ESP, // 32-bit
191 EAX_EDX, ECX_EBX, ESI_EDI, // 64-bit
192 };
193
194 /* This works on regno's, reg_info's and hardreg_storage's */
195 #define byte_reg(reg) ((reg) - 16)
196 #define highbyte_reg(reg) ((reg)-12)
197 #define word_reg(reg) ((reg)-8)
198
199 #define REGINFO(nr, str, conflicts...) [nr] = { .name = str, .aliases = { nr , conflicts } }
200
201 static struct reg_info reg_info_table[] = {
202 REGINFO( AL, "%al", AX, EAX, EAX_EDX),
203 REGINFO( DL, "%dl", DX, EDX, EAX_EDX),
204 REGINFO( CL, "%cl", CX, ECX, ECX_EBX),
205 REGINFO( BL, "%bl", BX, EBX, ECX_EBX),
206 REGINFO( AH, "%ah", AX, EAX, EAX_EDX),
207 REGINFO( DH, "%dh", DX, EDX, EAX_EDX),
208 REGINFO( CH, "%ch", CX, ECX, ECX_EBX),
209 REGINFO( BH, "%bh", BX, EBX, ECX_EBX),
210 REGINFO( AX, "%ax", AL, AH, EAX, EAX_EDX),
211 REGINFO( DX, "%dx", DL, DH, EDX, EAX_EDX),
212 REGINFO( CX, "%cx", CL, CH, ECX, ECX_EBX),
213 REGINFO( BX, "%bx", BL, BH, EBX, ECX_EBX),
214 REGINFO( SI, "%si", ESI, ESI_EDI),
215 REGINFO( DI, "%di", EDI, ESI_EDI),
216 REGINFO( BP, "%bp", EBP),
217 REGINFO( SP, "%sp", ESP),
218 REGINFO(EAX, "%eax", AL, AH, AX, EAX_EDX),
219 REGINFO(EDX, "%edx", DL, DH, DX, EAX_EDX),
220 REGINFO(ECX, "%ecx", CL, CH, CX, ECX_EBX),
221 REGINFO(EBX, "%ebx", BL, BH, BX, ECX_EBX),
222 REGINFO(ESI, "%esi", SI, ESI_EDI),
223 REGINFO(EDI, "%edi", DI, ESI_EDI),
224 REGINFO(EBP, "%ebp", BP),
225 REGINFO(ESP, "%esp", SP),
226 REGINFO(EAX_EDX, "%eax:%edx", AL, AH, AX, EAX, DL, DH, DX, EDX),
227 REGINFO(ECX_EBX, "%ecx:%ebx", CL, CH, CX, ECX, BL, BH, BX, EBX),
228 REGINFO(ESI_EDI, "%esi:%edi", SI, ESI, DI, EDI),
229 };
230
231 #define REGSTORAGE(nr) [nr] = { .type = STOR_REG, .reg = reg_info_table + (nr) }
232
233 static struct storage hardreg_storage_table[] = {
234 REGSTORAGE(AL), REGSTORAGE(DL), REGSTORAGE(CL), REGSTORAGE(BL),
235 REGSTORAGE(AH), REGSTORAGE(DH), REGSTORAGE(CH), REGSTORAGE(BH),
236 REGSTORAGE(AX), REGSTORAGE(DX), REGSTORAGE(CX), REGSTORAGE(BX),
237 REGSTORAGE(SI), REGSTORAGE(DI), REGSTORAGE(BP), REGSTORAGE(SP),
238 REGSTORAGE(EAX), REGSTORAGE(EDX), REGSTORAGE(ECX), REGSTORAGE(EBX),
239 REGSTORAGE(ESI), REGSTORAGE(EDI), REGSTORAGE(EBP), REGSTORAGE(ESP),
240 REGSTORAGE(EAX_EDX), REGSTORAGE(ECX_EBX), REGSTORAGE(ESI_EDI),
241 };
242
243 #define REG_EAX (&hardreg_storage_table[EAX])
244 #define REG_ECX (&hardreg_storage_table[ECX])
245 #define REG_EDX (&hardreg_storage_table[EDX])
246 #define REG_ESP (&hardreg_storage_table[ESP])
247 #define REG_DL (&hardreg_storage_table[DL])
248 #define REG_DX (&hardreg_storage_table[DX])
249 #define REG_AL (&hardreg_storage_table[AL])
250 #define REG_AX (&hardreg_storage_table[AX])
251
252 static DECLARE_BITMAP(regs_in_use, 256);
253
254 static inline struct storage * reginfo_reg(struct reg_info *info)
255 {
256 return hardreg_storage_table + info->own_regno;
257 }
258
259 static struct storage * get_hardreg(struct storage *reg, int clear)
260 {
261 struct reg_info *info = reg->reg;
262 const unsigned char *aliases;
263 int regno;
264
265 aliases = info->aliases;
266 while ((regno = *aliases++) != NOREG) {
267 if (test_bit(regno, regs_in_use))
268 goto busy;
269 if (clear)
270 reg_info_table[regno].contains = NULL;
271 }
272 set_bit(info->own_regno, regs_in_use);
273 return reg;
274 busy:
275 fprintf(stderr, "register %s is busy\n", info->name);
276 if (regno + reg_info_table != info)
277 fprintf(stderr, " conflicts with %s\n", reg_info_table[regno].name);
278 exit(1);
279 }
280
281 static void put_reg(struct storage *reg)
282 {
283 struct reg_info *info = reg->reg;
284 int regno = info->own_regno;
285
286 if (test_and_clear_bit(regno, regs_in_use))
287 return;
288 fprintf(stderr, "freeing already free'd register %s\n", reg_info_table[regno].name);
289 }
290
291 struct regclass {
292 const char *name;
293 const unsigned char regs[30];
294 };
295
296 static struct regclass regclass_8 = { "8-bit", { AL, DL, CL, BL, AH, DH, CH, BH }};
297 static struct regclass regclass_16 = { "16-bit", { AX, DX, CX, BX, SI, DI, BP }};
298 static struct regclass regclass_32 = { "32-bit", { EAX, EDX, ECX, EBX, ESI, EDI, EBP }};
299 static struct regclass regclass_64 = { "64-bit", { EAX_EDX, ECX_EBX, ESI_EDI }};
300
301 static struct regclass regclass_32_8 = { "32-bit bytes", { EAX, EDX, ECX, EBX }};
302
303 static struct regclass *get_regclass_bits(int bits)
304 {
305 switch (bits) {
306 case 8: return &regclass_8;
307 case 16: return &regclass_16;
308 case 64: return &regclass_64;
309 default: return &regclass_32;
310 }
311 }
312
313 static struct regclass *get_regclass(struct expression *expr)
314 {
315 return get_regclass_bits(expr->ctype->bit_size);
316 }
317
318 static int register_busy(int regno)
319 {
320 if (!test_bit(regno, regs_in_use)) {
321 struct reg_info *info = reg_info_table + regno;
322 const unsigned char *regs = info->aliases+1;
323
324 while ((regno = *regs) != NOREG) {
325 regs++;
326 if (test_bit(regno, regs_in_use))
327 goto busy;
328 }
329 return 0;
330 }
331 busy:
332 return 1;
333 }
334
335 static struct storage *get_reg(struct regclass *class)
336 {
337 const unsigned char *regs = class->regs;
338 int regno;
339
340 while ((regno = *regs) != NOREG) {
341 regs++;
342 if (register_busy(regno))
343 continue;
344 return get_hardreg(hardreg_storage_table + regno, 1);
345 }
346 fprintf(stderr, "Ran out of %s registers\n", class->name);
347 exit(1);
348 }
349
350 static struct storage *get_reg_value(struct storage *value, struct regclass *class)
351 {
352 struct reg_info *info;
353 struct storage *reg;
354
355 /* Do we already have it somewhere */
356 info = value->reg;
357 if (info && info->contains == value) {
358 emit_comment("already have register %s", info->name);
359 return get_hardreg(hardreg_storage_table + info->own_regno, 0);
360 }
361
362 reg = get_reg(class);
363 emit_move(value, reg, value->ctype, "reload register");
364 info = reg->reg;
365 info->contains = value;
366 value->reg = info;
367 return reg;
368 }
369
370 static struct storage *temp_from_bits(unsigned int bit_size)
371 {
372 return get_reg(get_regclass_bits(bit_size));
373 }
374
375 static inline unsigned int pseudo_offset(struct storage *s)
376 {
377 if (s->type != STOR_PSEUDO)
378 return 123456; /* intentionally bogus value */
379
380 return s->offset;
381 }
382
383 static inline unsigned int arg_offset(struct storage *s)
384 {
385 if (s->type != STOR_ARG)
386 return 123456; /* intentionally bogus value */
387
388 /* FIXME: this is wrong wrong wrong */
389 return current_func->stack_size + ((1 + s->idx) * 4);
390 }
391
392 static const char *pretty_offset(int ofs)
393 {
394 static char esp_buf[64];
395
396 if (ofs)
397 sprintf(esp_buf, "%d(%%esp)", ofs);
398 else
399 strcpy(esp_buf, "(%esp)");
400
401 return esp_buf;
402 }
403
404 static void stor_sym_init(struct symbol *sym)
405 {
406 struct storage *stor;
407 struct symbol_private *priv;
408
409 priv = calloc(1, sizeof(*priv) + sizeof(*stor));
410 if (!priv)
411 die("OOM in stor_sym_init");
412
413 stor = (struct storage *) (priv + 1);
414
415 priv->addr = stor;
416 stor->type = STOR_SYM;
417 stor->sym = sym;
418 }
419
420 static const char *stor_op_name(struct storage *s)
421 {
422 static char name[32];
423
424 switch (s->type) {
425 case STOR_PSEUDO:
426 strcpy(name, pretty_offset((int) pseudo_offset(s)));
427 break;
428 case STOR_ARG:
429 strcpy(name, pretty_offset((int) arg_offset(s)));
430 break;
431 case STOR_SYM:
432 strcpy(name, show_ident(s->sym->ident));
433 break;
434 case STOR_REG:
435 strcpy(name, s->reg->name);
436 break;
437 case STOR_VALUE:
438 sprintf(name, "$%Ld", s->value);
439 break;
440 case STOR_LABEL:
441 sprintf(name, "%s.L%d", s->flags & STOR_LABEL_VAL ? "$" : "",
442 s->label);
443 break;
444 case STOR_LABELSYM:
445 sprintf(name, "%s.LS%p", s->flags & STOR_LABEL_VAL ? "$" : "",
446 s->labelsym);
447 break;
448 }
449
450 return name;
451 }
452
453 static struct atom *new_atom(enum atom_type type)
454 {
455 struct atom *atom;
456
457 atom = calloc(1, sizeof(*atom)); /* TODO: chunked alloc */
458 if (!atom)
459 die("nuclear OOM");
460
461 atom->type = type;
462
463 return atom;
464 }
465
466 static inline void push_cstring(struct function *f, struct string *str,
467 int label)
468 {
469 struct atom *atom;
470
471 atom = new_atom(ATOM_CSTR);
472 atom->string = str;
473 atom->label = label;
474
475 add_ptr_list(&f->str_list, atom); /* note: _not_ atom_list */
476 }
477
478 static inline void push_atom(struct function *f, struct atom *atom)
479 {
480 add_ptr_list(&f->atom_list, atom);
481 }
482
483 static void push_text_atom(struct function *f, const char *text)
484 {
485 struct atom *atom = new_atom(ATOM_TEXT);
486
487 atom->text = strdup(text);
488 atom->text_len = strlen(text);
489
490 push_atom(f, atom);
491 }
492
493 static struct storage *new_storage(enum storage_type type)
494 {
495 struct storage *stor;
496
497 stor = calloc(1, sizeof(*stor));
498 if (!stor)
499 die("OOM in new_storage");
500
501 stor->type = type;
502
503 return stor;
504 }
505
506 static struct storage *stack_alloc(int n_bytes)
507 {
508 struct function *f = current_func;
509 struct storage *stor;
510
511 assert(f != NULL);
512
513 stor = new_storage(STOR_PSEUDO);
514 stor->type = STOR_PSEUDO;
515 stor->pseudo = f->pseudo_nr;
516 stor->offset = f->stack_size; /* FIXME: stack req. natural align */
517 stor->size = n_bytes;
518 f->stack_size += n_bytes;
519 f->pseudo_nr++;
520
521 add_ptr_list(&f->pseudo_list, stor);
522
523 return stor;
524 }
525
526 static struct storage *new_labelsym(struct symbol *sym)
527 {
528 struct storage *stor;
529
530 stor = new_storage(STOR_LABELSYM);
531
532 if (stor) {
533 stor->flags |= STOR_WANTS_FREE;
534 stor->labelsym = sym;
535 }
536
537 return stor;
538 }
539
540 static struct storage *new_val(long long value)
541 {
542 struct storage *stor;
543
544 stor = new_storage(STOR_VALUE);
545
546 if (stor) {
547 stor->flags |= STOR_WANTS_FREE;
548 stor->value = value;
549 }
550
551 return stor;
552 }
553
554 static int new_label(void)
555 {
556 static int label = 0;
557 return ++label;
558 }
559
560 static void textbuf_push(struct textbuf **buf_p, const char *text)
561 {
562 struct textbuf *tmp, *list = *buf_p;
563 unsigned int text_len = strlen(text);
564 unsigned int alloc_len = text_len + 1 + sizeof(*list);
565
566 tmp = calloc(1, alloc_len);
567 if (!tmp)
568 die("OOM on textbuf alloc");
569
570 tmp->text = ((void *) tmp) + sizeof(*tmp);
571 memcpy(tmp->text, text, text_len + 1);
572 tmp->len = text_len;
573
574 /* add to end of list */
575 if (!list) {
576 list = tmp;
577 tmp->prev = tmp;
578 } else {
579 tmp->prev = list->prev;
580 tmp->prev->next = tmp;
581 list->prev = tmp;
582 }
583 tmp->next = list;
584
585 *buf_p = list;
586 }
587
588 static void textbuf_emit(struct textbuf **buf_p)
589 {
590 struct textbuf *tmp, *list = *buf_p;
591
592 while (list) {
593 tmp = list;
594 if (tmp->next == tmp)
595 list = NULL;
596 else {
597 tmp->prev->next = tmp->next;
598 tmp->next->prev = tmp->prev;
599 list = tmp->next;
600 }
601
602 fputs(tmp->text, stdout);
603
604 free(tmp);
605 }
606
607 *buf_p = list;
608 }
609
610 static void insn(const char *insn, struct storage *op1, struct storage *op2,
611 const char *comment_in)
612 {
613 struct function *f = current_func;
614 struct atom *atom = new_atom(ATOM_INSN);
615
616 assert(insn != NULL);
617
618 strcpy(atom->insn, insn);
619 if (comment_in && (*comment_in))
620 strncpy(atom->comment, comment_in,
621 sizeof(atom->comment) - 1);
622
623 atom->op1 = op1;
624 atom->op2 = op2;
625
626 push_atom(f, atom);
627 }
628
629 static void emit_comment(const char *fmt, ...)
630 {
631 struct function *f = current_func;
632 static char tmpbuf[100] = "\t# ";
633 va_list args;
634 int i;
635
636 va_start(args, fmt);
637 i = vsnprintf(tmpbuf+3, sizeof(tmpbuf)-4, fmt, args);
638 va_end(args);
639 tmpbuf[i+3] = '\n';
640 tmpbuf[i+4] = '\0';
641 push_text_atom(f, tmpbuf);
642 }
643
644 static void emit_label (int label, const char *comment)
645 {
646 struct function *f = current_func;
647 char s[64];
648
649 if (!comment)
650 sprintf(s, ".L%d:\n", label);
651 else
652 sprintf(s, ".L%d:\t\t\t\t\t# %s\n", label, comment);
653
654 push_text_atom(f, s);
655 }
656
657 static void emit_labelsym (struct symbol *sym, const char *comment)
658 {
659 struct function *f = current_func;
660 char s[64];
661
662 if (!comment)
663 sprintf(s, ".LS%p:\n", sym);
664 else
665 sprintf(s, ".LS%p:\t\t\t\t# %s\n", sym, comment);
666
667 push_text_atom(f, s);
668 }
669
670 void emit_unit_begin(const char *basename)
671 {
672 printf("\t.file\t\"%s\"\n", basename);
673 }
674
675 void emit_unit_end(void)
676 {
677 textbuf_emit(&unit_post_text);
678 printf("\t.ident\t\"sparse silly x86 backend (built %s)\"\n", __DATE__);
679 }
680
681 /* conditionally switch sections */
682 static void emit_section(const char *s)
683 {
684 if (s == current_section)
685 return;
686 if (current_section && (!strcmp(s, current_section)))
687 return;
688
689 printf("\t%s\n", s);
690 current_section = s;
691 }
692
693 static void emit_insn_atom(struct function *f, struct atom *atom)
694 {
695 char s[128];
696 char comment[64];
697 struct storage *op1 = atom->op1;
698 struct storage *op2 = atom->op2;
699
700 if (atom->comment[0])
701 sprintf(comment, "\t\t# %s", atom->comment);
702 else
703 comment[0] = 0;
704
705 if (atom->op2) {
706 char tmp[16];
707 strcpy(tmp, stor_op_name(op1));
708 sprintf(s, "\t%s\t%s, %s%s\n",
709 atom->insn, tmp, stor_op_name(op2), comment);
710 } else if (atom->op1)
711 sprintf(s, "\t%s\t%s%s%s\n",
712 atom->insn, stor_op_name(op1),
713 comment[0] ? "\t" : "", comment);
714 else
715 sprintf(s, "\t%s\t%s%s\n",
716 atom->insn,
717 comment[0] ? "\t\t" : "", comment);
718
719 write(STDOUT_FILENO, s, strlen(s));
720 }
721
722 static void emit_atom_list(struct function *f)
723 {
724 struct atom *atom;
725
726 FOR_EACH_PTR(f->atom_list, atom) {
727 switch (atom->type) {
728 case ATOM_TEXT: {
729 ssize_t rc = write(STDOUT_FILENO, atom->text,
730 atom->text_len);
731 (void) rc; /* FIXME */
732 break;
733 }
734 case ATOM_INSN:
735 emit_insn_atom(f, atom);
736 break;
737 case ATOM_CSTR:
738 assert(0);
739 break;
740 }
741 } END_FOR_EACH_PTR(atom);
742 }
743
744 static void emit_string_list(struct function *f)
745 {
746 struct atom *atom;
747
748 emit_section(".section\t.rodata");
749
750 FOR_EACH_PTR(f->str_list, atom) {
751 /* FIXME: escape " in string */
752 printf(".L%d:\n", atom->label);
753 printf("\t.string\t%s\n", show_string(atom->string));
754
755 free(atom);
756 } END_FOR_EACH_PTR(atom);
757 }
758
759 static void func_cleanup(struct function *f)
760 {
761 struct storage *stor;
762 struct atom *atom;
763
764 FOR_EACH_PTR(f->pseudo_list, stor) {
765 free(stor);
766 } END_FOR_EACH_PTR(stor);
767
768 FOR_EACH_PTR(f->atom_list, atom) {
769 if ((atom->type == ATOM_TEXT) && (atom->text))
770 free(atom->text);
771 if (atom->op1 && (atom->op1->flags & STOR_WANTS_FREE))
772 free(atom->op1);
773 if (atom->op2 && (atom->op2->flags & STOR_WANTS_FREE))
774 free(atom->op2);
775 free(atom);
776 } END_FOR_EACH_PTR(atom);
777
778 free_ptr_list(&f->pseudo_list);
779 free(f);
780 }
781
782 /* function prologue */
783 static void emit_func_pre(struct symbol *sym)
784 {
785 struct function *f;
786 struct symbol *arg;
787 unsigned int i, argc = 0, alloc_len;
788 unsigned char *mem;
789 struct symbol_private *privbase;
790 struct storage *storage_base;
791 struct symbol *base_type = sym->ctype.base_type;
792
793 FOR_EACH_PTR(base_type->arguments, arg) {
794 argc++;
795 } END_FOR_EACH_PTR(arg);
796
797 alloc_len =
798 sizeof(*f) +
799 (argc * sizeof(struct symbol *)) +
800 (argc * sizeof(struct symbol_private)) +
801 (argc * sizeof(struct storage));
802 mem = calloc(1, alloc_len);
803 if (!mem)
804 die("OOM on func info");
805
806 f = (struct function *) mem;
807 mem += sizeof(*f);
808 f->argv = (struct symbol **) mem;
809 mem += (argc * sizeof(struct symbol *));
810 privbase = (struct symbol_private *) mem;
811 mem += (argc * sizeof(struct symbol_private));
812 storage_base = (struct storage *) mem;
813
814 f->argc = argc;
815 f->ret_target = new_label();
816
817 i = 0;
818 FOR_EACH_PTR(base_type->arguments, arg) {
819 f->argv[i] = arg;
820 arg->aux = &privbase[i];
821 storage_base[i].type = STOR_ARG;
822 storage_base[i].idx = i;
823 privbase[i].addr = &storage_base[i];
824 i++;
825 } END_FOR_EACH_PTR(arg);
826
827 assert(current_func == NULL);
828 current_func = f;
829 }
830
831 /* function epilogue */
832 static void emit_func_post(struct symbol *sym)
833 {
834 const char *name = show_ident(sym->ident);
835 struct function *f = current_func;
836 int stack_size = f->stack_size;
837
838 if (f->str_list)
839 emit_string_list(f);
840
841 /* function prologue */
842 emit_section(".text");
843 if ((sym->ctype.modifiers & MOD_STATIC) == 0)
844 printf(".globl %s\n", name);
845 printf("\t.type\t%s, @function\n", name);
846 printf("%s:\n", name);
847
848 if (stack_size) {
849 char pseudo_const[16];
850
851 sprintf(pseudo_const, "$%d", stack_size);
852 printf("\tsubl\t%s, %%esp\n", pseudo_const);
853 }
854
855 /* function epilogue */
856
857 /* jump target for 'return' statements */
858 emit_label(f->ret_target, NULL);
859
860 if (stack_size) {
861 struct storage *val;
862
863 val = new_storage(STOR_VALUE);
864 val->value = (long long) (stack_size);
865 val->flags = STOR_WANTS_FREE;
866
867 insn("addl", val, REG_ESP, NULL);
868 }
869
870 insn("ret", NULL, NULL, NULL);
871
872 /* output everything to stdout */
873 fflush(stdout); /* paranoia; needed? */
874 emit_atom_list(f);
875
876 /* function footer */
877 name = show_ident(sym->ident);
878 printf("\t.size\t%s, .-%s\n", name, name);
879
880 func_cleanup(f);
881 current_func = NULL;
882 }
883
884 /* emit object (a.k.a. variable, a.k.a. data) prologue */
885 static void emit_object_pre(const char *name, unsigned long modifiers,
886 unsigned long alignment, unsigned int byte_size)
887 {
888 if ((modifiers & MOD_STATIC) == 0)
889 printf(".globl %s\n", name);
890 emit_section(".data");
891 if (alignment)
892 printf("\t.align %lu\n", alignment);
893 printf("\t.type\t%s, @object\n", name);
894 printf("\t.size\t%s, %d\n", name, byte_size);
895 printf("%s:\n", name);
896 }
897
898 /* emit value (only) for an initializer scalar */
899 static void emit_scalar(struct expression *expr, unsigned int bit_size)
900 {
901 const char *type;
902 long long ll;
903
904 assert(expr->type == EXPR_VALUE);
905
906 if (expr->value == 0ULL) {
907 printf("\t.zero\t%d\n", bit_size / 8);
908 return;
909 }
910
911 ll = (long long) expr->value;
912
913 switch (bit_size) {
914 case 8: type = "byte"; ll = (char) ll; break;
915 case 16: type = "value"; ll = (short) ll; break;
916 case 32: type = "long"; ll = (int) ll; break;
917 case 64: type = "quad"; break;
918 default: type = NULL; break;
919 }
920
921 assert(type != NULL);
922
923 printf("\t.%s\t%Ld\n", type, ll);
924 }
925
926 static void emit_global_noinit(const char *name, unsigned long modifiers,
927 unsigned long alignment, unsigned int byte_size)
928 {
929 char s[64];
930
931 if (modifiers & MOD_STATIC) {
932 sprintf(s, "\t.local\t%s\n", name);
933 textbuf_push(&unit_post_text, s);
934 }
935 if (alignment)
936 sprintf(s, "\t.comm\t%s,%d,%lu\n", name, byte_size, alignment);
937 else
938 sprintf(s, "\t.comm\t%s,%d\n", name, byte_size);
939 textbuf_push(&unit_post_text, s);
940 }
941
942 static int ea_current, ea_last;
943
944 static void emit_initializer(struct symbol *sym,
945 struct expression *expr)
946 {
947 int distance = ea_current - ea_last - 1;
948
949 if (distance > 0)
950 printf("\t.zero\t%d\n", (sym->bit_size / 8) * distance);
951
952 if (expr->type == EXPR_VALUE) {
953 struct symbol *base_type = sym->ctype.base_type;
954 assert(base_type != NULL);
955
956 emit_scalar(expr, sym->bit_size / get_expression_value(base_type->array_size));
957 return;
958 }
959 if (expr->type != EXPR_INITIALIZER)
960 return;
961
962 assert(0); /* FIXME */
963 }
964
965 static int sort_array_cmp(const struct expression *a,
966 const struct expression *b)
967 {
968 int a_ofs = 0, b_ofs = 0;
969
970 if (a->type == EXPR_POS)
971 a_ofs = (int) a->init_offset;
972 if (b->type == EXPR_POS)
973 b_ofs = (int) b->init_offset;
974
975 return a_ofs - b_ofs;
976 }
977
978 /* move to front-end? */
979 static void sort_array(struct expression *expr)
980 {
981 struct expression *entry, **list;
982 unsigned int elem, sorted, i;
983
984 elem = 0;
985 FOR_EACH_PTR(expr->expr_list, entry) {
986 elem++;
987 } END_FOR_EACH_PTR(entry);
988
989 if (!elem)
990 return;
991
992 list = malloc(sizeof(entry) * elem);
993 if (!list)
994 die("OOM in sort_array");
995
996 /* this code is no doubt evil and ignores EXPR_INDEX possibly
997 * to its detriment and other nasty things. improvements
998 * welcome.
999 */
1000 i = 0;
1001 sorted = 0;
1002 FOR_EACH_PTR(expr->expr_list, entry) {
1003 if ((entry->type == EXPR_POS) || (entry->type == EXPR_VALUE)) {
1004 /* add entry to list[], in sorted order */
1005 if (sorted == 0) {
1006 list[0] = entry;
1007 sorted = 1;
1008 } else {
1009 for (i = 0; i < sorted; i++)
1010 if (sort_array_cmp(entry, list[i]) <= 0)
1011 break;
1012
1013 /* If inserting into the middle of list[]
1014 * instead of appending, we memmove.
1015 * This is ugly, but thankfully
1016 * uncommon. Input data with tons of
1017 * entries very rarely have explicit
1018 * offsets. convert to qsort eventually...
1019 */
1020 if (i != sorted)
1021 memmove(&list[i + 1], &list[i],
1022 (sorted - i) * sizeof(entry));
1023 list[i] = entry;
1024 sorted++;
1025 }
1026 }
1027 } END_FOR_EACH_PTR(entry);
1028
1029 i = 0;
1030 FOR_EACH_PTR(expr->expr_list, entry) {
1031 if ((entry->type == EXPR_POS) || (entry->type == EXPR_VALUE))
1032 *THIS_ADDRESS(entry) = list[i++];
1033 } END_FOR_EACH_PTR(entry);
1034
1035 }
1036
1037 static void emit_array(struct symbol *sym)
1038 {
1039 struct symbol *base_type = sym->ctype.base_type;
1040 struct expression *expr = sym->initializer;
1041 struct expression *entry;
1042
1043 assert(base_type != NULL);
1044
1045 stor_sym_init(sym);
1046
1047 ea_last = -1;
1048
1049 emit_object_pre(show_ident(sym->ident), sym->ctype.modifiers,
1050 sym->ctype.alignment,
1051 sym->bit_size / 8);
1052
1053 sort_array(expr);
1054
1055 FOR_EACH_PTR(expr->expr_list, entry) {
1056 if (entry->type == EXPR_VALUE) {
1057 ea_current = 0;
1058 emit_initializer(sym, entry);
1059 ea_last = ea_current;
1060 } else if (entry->type == EXPR_POS) {
1061 ea_current =
1062 entry->init_offset / (base_type->bit_size / 8);
1063 emit_initializer(sym, entry->init_expr);
1064 ea_last = ea_current;
1065 }
1066 } END_FOR_EACH_PTR(entry);
1067 }
1068
1069 void emit_one_symbol(struct symbol *sym)
1070 {
1071 x86_symbol(sym);
1072 }
1073
1074 static void emit_copy(struct storage *dest, struct storage *src,
1075 struct symbol *ctype)
1076 {
1077 struct storage *reg = NULL;
1078 unsigned int bit_size;
1079
1080 /* FIXME: Bitfield copy! */
1081
1082 bit_size = src->size * 8;
1083 if (!bit_size)
1084 bit_size = 32;
1085 if ((src->type == STOR_ARG) && (bit_size < 32))
1086 bit_size = 32;
1087
1088 reg = temp_from_bits(bit_size);
1089 emit_move(src, reg, ctype, "begin copy ..");
1090
1091 bit_size = dest->size * 8;
1092 if (!bit_size)
1093 bit_size = 32;
1094 if ((dest->type == STOR_ARG) && (bit_size < 32))
1095 bit_size = 32;
1096
1097 emit_move(reg, dest, ctype, ".... end copy");
1098 put_reg(reg);
1099 }
1100
1101 static void emit_store(struct expression *dest_expr, struct storage *dest,
1102 struct storage *src, int bits)
1103 {
1104 /* FIXME: Bitfield store! */
1105 printf("\tst.%d\t\tv%d,[v%d]\n", bits, src->pseudo, dest->pseudo);
1106 }
1107
1108 static void emit_scalar_noinit(struct symbol *sym)
1109 {
1110 emit_global_noinit(show_ident(sym->ident),
1111 sym->ctype.modifiers, sym->ctype.alignment,
1112 sym->bit_size / 8);
1113 stor_sym_init(sym);
1114 }
1115
1116 static void emit_array_noinit(struct symbol *sym)
1117 {
1118 emit_global_noinit(show_ident(sym->ident),
1119 sym->ctype.modifiers, sym->ctype.alignment,
1120 get_expression_value(sym->array_size) * (sym->bit_size / 8));
1121 stor_sym_init(sym);
1122 }
1123
1124 static const char *opbits(const char *insn, unsigned int bits)
1125 {
1126 static char opbits_str[32];
1127 char c;
1128
1129 switch (bits) {
1130 case 8: c = 'b'; break;
1131 case 16: c = 'w'; break;
1132 case 32: c = 'l'; break;
1133 case 64: c = 'q'; break;
1134 default: abort(); break;
1135 }
1136
1137 sprintf(opbits_str, "%s%c", insn, c);
1138
1139 return opbits_str;
1140 }
1141
1142 static void emit_move(struct storage *src, struct storage *dest,
1143 struct symbol *ctype, const char *comment)
1144 {
1145 unsigned int bits;
1146 unsigned int is_signed;
1147 unsigned int is_dest = (src->type == STOR_REG);
1148 const char *opname;
1149
1150 if (ctype) {
1151 bits = ctype->bit_size;
1152 is_signed = type_is_signed(ctype);
1153 } else {
1154 bits = 32;
1155 is_signed = 0;
1156 }
1157
1158 /*
1159 * Are we moving from a register to a register?
1160 * Make the new reg to be the "cache".
1161 */
1162 if ((dest->type == STOR_REG) && (src->type == STOR_REG)) {
1163 struct storage *backing;
1164
1165 reg_reg_move:
1166 if (dest == src)
1167 return;
1168
1169 backing = src->reg->contains;
1170 if (backing) {
1171 /* Is it still valid? */
1172 if (backing->reg != src->reg)
1173 backing = NULL;
1174 else
1175 backing->reg = dest->reg;
1176 }
1177 dest->reg->contains = backing;
1178 insn("mov", src, dest, NULL);
1179 return;
1180 }
1181
1182 /*
1183 * Are we moving to a register from a non-reg?
1184 *
1185 * See if we have the non-reg source already cached
1186 * in a register..
1187 */
1188 if (dest->type == STOR_REG) {
1189 if (src->reg) {
1190 struct reg_info *info = src->reg;
1191 if (info->contains == src) {
1192 src = reginfo_reg(info);
1193 goto reg_reg_move;
1194 }
1195 }
1196 dest->reg->contains = src;
1197 src->reg = dest->reg;
1198 }
1199
1200 if (src->type == STOR_REG) {
1201 /* We could just mark the register dirty here and do lazy store.. */
1202 src->reg->contains = dest;
1203 dest->reg = src->reg;
1204 }
1205
1206 if ((bits == 8) || (bits == 16)) {
1207 if (is_dest)
1208 opname = "mov";
1209 else
1210 opname = is_signed ? "movsx" : "movzx";
1211 } else
1212 opname = "mov";
1213
1214 insn(opbits(opname, bits), src, dest, comment);
1215 }
1216
1217 static struct storage *emit_compare(struct expression *expr)
1218 {
1219 struct storage *left = x86_expression(expr->left);
1220 struct storage *right = x86_expression(expr->right);
1221 struct storage *reg1, *reg2;
1222 struct storage *new, *val;
1223 const char *opname = NULL;
1224 unsigned int right_bits = expr->right->ctype->bit_size;
1225
1226 switch(expr->op) {
1227 case '<': opname = "setl"; break;
1228 case '>': opname = "setg"; break;
1229 case SPECIAL_LTE:
1230 opname = "setle"; break;
1231 case SPECIAL_GTE:
1232 opname = "setge"; break;
1233 case SPECIAL_EQUAL: opname = "sete"; break;
1234 case SPECIAL_NOTEQUAL: opname = "setne"; break;
1235 case SPECIAL_UNSIGNED_LT:
1236 opname = "setb"; break;
1237 case SPECIAL_UNSIGNED_GT:
1238 opname = "seta"; break;
1239 case SPECIAL_UNSIGNED_LTE:
1240 opname = "setb"; break;
1241 case SPECIAL_UNSIGNED_GTE:
1242 opname = "setae"; break;
1243 default:
1244 assert(0);
1245 break;
1246 }
1247
1248 /* init EDX to 0 */
1249 val = new_storage(STOR_VALUE);
1250 val->flags = STOR_WANTS_FREE;
1251
1252 reg1 = get_reg(&regclass_32_8);
1253 emit_move(val, reg1, NULL, NULL);
1254
1255 /* move op1 into EAX */
1256 reg2 = get_reg_value(left, get_regclass(expr->left));
1257
1258 /* perform comparison, RHS (op1, right) and LHS (op2, EAX) */
1259 insn(opbits("cmp", right_bits), right, reg2, NULL);
1260 put_reg(reg2);
1261
1262 /* store result of operation, 0 or 1, in DL using SETcc */
1263 insn(opname, byte_reg(reg1), NULL, NULL);
1264
1265 /* finally, store the result (DL) in a new pseudo / stack slot */
1266 new = stack_alloc(4);
1267 emit_move(reg1, new, NULL, "end EXPR_COMPARE");
1268 put_reg(reg1);
1269
1270 return new;
1271 }
1272
1273 static struct storage *emit_value(struct expression *expr)
1274 {
1275 #if 0 /* old and slow way */
1276 struct storage *new = stack_alloc(4);
1277 struct storage *val;
1278
1279 val = new_storage(STOR_VALUE);
1280 val->value = (long long) expr->value;
1281 val->flags = STOR_WANTS_FREE;
1282 insn("movl", val, new, NULL);
1283
1284 return new;
1285 #else
1286 struct storage *val;
1287
1288 val = new_storage(STOR_VALUE);
1289 val->value = (long long) expr->value;
1290
1291 return val; /* FIXME: memory leak */
1292 #endif
1293 }
1294
1295 static struct storage *emit_divide(struct expression *expr, struct storage *left, struct storage *right)
1296 {
1297 struct storage *eax_edx;
1298 struct storage *reg, *new;
1299 struct storage *val = new_storage(STOR_VALUE);
1300
1301 emit_comment("begin DIVIDE");
1302 eax_edx = get_hardreg(hardreg_storage_table + EAX_EDX, 1);
1303
1304 /* init EDX to 0 */
1305 val->flags = STOR_WANTS_FREE;
1306 emit_move(val, REG_EDX, NULL, NULL);
1307
1308 new = stack_alloc(expr->ctype->bit_size / 8);
1309
1310 /* EAX is dividend */
1311 emit_move(left, REG_EAX, NULL, NULL);
1312
1313 reg = get_reg_value(right, &regclass_32);
1314
1315 /* perform binop */
1316 insn("div", reg, REG_EAX, NULL);
1317 put_reg(reg);
1318
1319 reg = REG_EAX;
1320 if (expr->op == '%')
1321 reg = REG_EDX;
1322 emit_move(reg, new, NULL, NULL);
1323
1324 put_reg(eax_edx);
1325 emit_comment("end DIVIDE");
1326 return new;
1327 }
1328
1329 static struct storage *emit_binop(struct expression *expr)
1330 {
1331 struct storage *left = x86_expression(expr->left);
1332 struct storage *right = x86_expression(expr->right);
1333 struct storage *new;
1334 struct storage *dest, *src;
1335 const char *opname = NULL;
1336 const char *suffix = NULL;
1337 char opstr[16];
1338 int is_signed;
1339
1340 /* Divides have special register constraints */
1341 if ((expr->op == '/') || (expr->op == '%'))
1342 return emit_divide(expr, left, right);
1343
1344 is_signed = type_is_signed(expr->ctype);
1345
1346 switch (expr->op) {
1347 case '+':
1348 opname = "add";
1349 break;
1350 case '-':
1351 opname = "sub";
1352 break;
1353 case '&':
1354 opname = "and";
1355 break;
1356 case '|':
1357 opname = "or";
1358 break;
1359 case '^':
1360 opname = "xor";
1361 break;
1362 case SPECIAL_LEFTSHIFT:
1363 opname = "shl";
1364 break;
1365 case SPECIAL_RIGHTSHIFT:
1366 if (is_signed)
1367 opname = "sar";
1368 else
1369 opname = "shr";
1370 break;
1371 case '*':
1372 if (is_signed)
1373 opname = "imul";
1374 else
1375 opname = "mul";
1376 break;
1377 case SPECIAL_LOGICAL_AND:
1378 warning(expr->pos, "bogus bitwise and for logical op (should use '2*setne + and' or something)");
1379 opname = "and";
1380 break;
1381 case SPECIAL_LOGICAL_OR:
1382 warning(expr->pos, "bogus bitwise or for logical op (should use 'or + setne' or something)");
1383 opname = "or";
1384 break;
1385 default:
1386 error_die(expr->pos, "unhandled binop '%s'\n", show_special(expr->op));
1387 break;
1388 }
1389
1390 dest = get_reg_value(right, &regclass_32);
1391 src = get_reg_value(left, &regclass_32);
1392 switch (expr->ctype->bit_size) {
1393 case 8:
1394 suffix = "b";
1395 break;
1396 case 16:
1397 suffix = "w";
1398 break;
1399 case 32:
1400 suffix = "l";
1401 break;
1402 case 64:
1403 suffix = "q"; /* FIXME */
1404 break;
1405 default:
1406 assert(0);
1407 break;
1408 }
1409
1410 snprintf(opstr, sizeof(opstr), "%s%s", opname, suffix);
1411
1412 /* perform binop */
1413 insn(opstr, src, dest, NULL);
1414 put_reg(src);
1415
1416 /* store result in new pseudo / stack slot */
1417 new = stack_alloc(expr->ctype->bit_size / 8);
1418 emit_move(dest, new, NULL, "end EXPR_BINOP");
1419
1420 put_reg(dest);
1421
1422 return new;
1423 }
1424
1425 static int emit_conditional_test(struct storage *val)
1426 {
1427 struct storage *reg;
1428 struct storage *target_val;
1429 int target_false;
1430
1431 /* load result into EAX */
1432 emit_comment("begin if/conditional");
1433 reg = get_reg_value(val, &regclass_32);
1434
1435 /* compare result with zero */
1436 insn("test", reg, reg, NULL);
1437 put_reg(reg);
1438
1439 /* create conditional-failed label to jump to */
1440 target_false = new_label();
1441 target_val = new_storage(STOR_LABEL);
1442 target_val->label = target_false;
1443 target_val->flags = STOR_WANTS_FREE;
1444 insn("jz", target_val, NULL, NULL);
1445
1446 return target_false;
1447 }
1448
1449 static int emit_conditional_end(int target_false)
1450 {
1451 struct storage *cond_end_st;
1452 int cond_end;
1453
1454 /* finished generating code for if-true statement.
1455 * add a jump-to-end jump to avoid falling through
1456 * to the if-false statement code.
1457 */
1458 cond_end = new_label();
1459 cond_end_st = new_storage(STOR_LABEL);
1460 cond_end_st->label = cond_end;
1461 cond_end_st->flags = STOR_WANTS_FREE;
1462 insn("jmp", cond_end_st, NULL, NULL);
1463
1464 /* if we have both if-true and if-false statements,
1465 * the failed-conditional case will fall through to here
1466 */
1467 emit_label(target_false, NULL);
1468
1469 return cond_end;
1470 }
1471
1472 static void emit_if_conditional(struct statement *stmt)
1473 {
1474 struct storage *val;
1475 int cond_end;
1476
1477 /* emit test portion of conditional */
1478 val = x86_expression(stmt->if_conditional);
1479 cond_end = emit_conditional_test(val);
1480
1481 /* emit if-true statement */
1482 x86_statement(stmt->if_true);
1483
1484 /* emit if-false statement, if present */
1485 if (stmt->if_false) {
1486 cond_end = emit_conditional_end(cond_end);
1487 x86_statement(stmt->if_false);
1488 }
1489
1490 /* end of conditional; jump target for if-true branch */
1491 emit_label(cond_end, "end if");
1492 }
1493
1494 static struct storage *emit_inc_dec(struct expression *expr, int postop)
1495 {
1496 struct storage *addr = x86_address_gen(expr->unop);
1497 struct storage *retval;
1498 char opname[16];
1499
1500 strcpy(opname, opbits(expr->op == SPECIAL_INCREMENT ? "inc" : "dec",
1501 expr->ctype->bit_size));
1502
1503 if (postop) {
1504 struct storage *new = stack_alloc(4);
1505
1506 emit_copy(new, addr, expr->unop->ctype);
1507
1508 retval = new;
1509 } else
1510 retval = addr;
1511
1512 insn(opname, addr, NULL, NULL);
1513
1514 return retval;
1515 }
1516
1517 static struct storage *emit_postop(struct expression *expr)
1518 {
1519 return emit_inc_dec(expr, 1);
1520 }
1521
1522 static struct storage *emit_return_stmt(struct statement *stmt)
1523 {
1524 struct function *f = current_func;
1525 struct expression *expr = stmt->ret_value;
1526 struct storage *val = NULL, *jmplbl;
1527
1528 if (expr && expr->ctype) {
1529 val = x86_expression(expr);
1530 assert(val != NULL);
1531 emit_move(val, REG_EAX, expr->ctype, "return");
1532 }
1533
1534 jmplbl = new_storage(STOR_LABEL);
1535 jmplbl->flags |= STOR_WANTS_FREE;
1536 jmplbl->label = f->ret_target;
1537 insn("jmp", jmplbl, NULL, NULL);
1538
1539 return val;
1540 }
1541
1542 static struct storage *emit_conditional_expr(struct expression *expr)
1543 {
1544 struct storage *cond, *true = NULL, *false = NULL;
1545 struct storage *new = stack_alloc(expr->ctype->bit_size / 8);
1546 int target_false, cond_end;
1547
1548 /* evaluate conditional */
1549 cond = x86_expression(expr->conditional);
1550 target_false = emit_conditional_test(cond);
1551
1552 /* handle if-true part of the expression */
1553 true = x86_expression(expr->cond_true);
1554
1555 emit_copy(new, true, expr->ctype);
1556
1557 cond_end = emit_conditional_end(target_false);
1558
1559 /* handle if-false part of the expression */
1560 false = x86_expression(expr->cond_false);
1561
1562 emit_copy(new, false, expr->ctype);
1563
1564 /* end of conditional; jump target for if-true branch */
1565 emit_label(cond_end, "end conditional");
1566
1567 return new;
1568 }
1569
1570 static struct storage *emit_select_expr(struct expression *expr)
1571 {
1572 struct storage *cond = x86_expression(expr->conditional);
1573 struct storage *true = x86_expression(expr->cond_true);
1574 struct storage *false = x86_expression(expr->cond_false);
1575 struct storage *reg_cond, *reg_true, *reg_false;
1576 struct storage *new = stack_alloc(4);
1577
1578 emit_comment("begin SELECT");
1579 reg_cond = get_reg_value(cond, get_regclass(expr->conditional));
1580 reg_true = get_reg_value(true, get_regclass(expr));
1581 reg_false = get_reg_value(false, get_regclass(expr));
1582
1583 /*
1584 * Do the actual select: check the conditional for zero,
1585 * move false over true if zero
1586 */
1587 insn("test", reg_cond, reg_cond, NULL);
1588 insn("cmovz", reg_false, reg_true, NULL);
1589
1590 /* Store it back */
1591 emit_move(reg_true, new, expr->ctype, NULL);
1592 put_reg(reg_cond);
1593 put_reg(reg_true);
1594 put_reg(reg_false);
1595 emit_comment("end SELECT");
1596 return new;
1597 }
1598
1599 static struct storage *emit_symbol_expr_init(struct symbol *sym)
1600 {
1601 struct expression *expr = sym->initializer;
1602 struct symbol_private *priv = sym->aux;
1603
1604 if (priv == NULL) {
1605 priv = calloc(1, sizeof(*priv));
1606 sym->aux = priv;
1607
1608 if (expr == NULL) {
1609 struct storage *new = stack_alloc(4);
1610 fprintf(stderr, "FIXME! no value for symbol %s. creating pseudo %d (stack offset %d)\n",
1611 show_ident(sym->ident),
1612 new->pseudo, new->pseudo * 4);
1613 priv->addr = new;
1614 } else {
1615 priv->addr = x86_expression(expr);
1616 }
1617 }
1618
1619 return priv->addr;
1620 }
1621
1622 static struct storage *emit_string_expr(struct expression *expr)
1623 {
1624 struct function *f = current_func;
1625 int label = new_label();
1626 struct storage *new;
1627
1628 push_cstring(f, expr->string, label);
1629
1630 new = new_storage(STOR_LABEL);
1631 new->label = label;
1632 new->flags = STOR_LABEL_VAL | STOR_WANTS_FREE;
1633 return new;
1634 }
1635
1636 static struct storage *emit_cast_expr(struct expression *expr)
1637 {
1638 struct symbol *old_type, *new_type;
1639 struct storage *op = x86_expression(expr->cast_expression);
1640 int oldbits, newbits;
1641 struct storage *new;
1642
1643 old_type = expr->cast_expression->ctype;
1644 new_type = expr->cast_type;
1645
1646 oldbits = old_type->bit_size;
1647 newbits = new_type->bit_size;
1648 if (oldbits >= newbits)
1649 return op;
1650
1651 emit_move(op, REG_EAX, old_type, "begin cast ..");
1652
1653 new = stack_alloc(newbits / 8);
1654 emit_move(REG_EAX, new, new_type, ".... end cast");
1655
1656 return new;
1657 }
1658
1659 static struct storage *emit_regular_preop(struct expression *expr)
1660 {
1661 struct storage *target = x86_expression(expr->unop);
1662 struct storage *val, *new = stack_alloc(4);
1663 const char *opname = NULL;
1664
1665 switch (expr->op) {
1666 case '!':
1667 val = new_storage(STOR_VALUE);
1668 val->flags = STOR_WANTS_FREE;
1669 emit_move(val, REG_EDX, NULL, NULL);
1670 emit_move(target, REG_EAX, expr->unop->ctype, NULL);
1671 insn("test", REG_EAX, REG_EAX, NULL);
1672 insn("setz", REG_DL, NULL, NULL);
1673 emit_move(REG_EDX, new, expr->unop->ctype, NULL);
1674
1675 break;
1676 case '~':
1677 opname = "not";
1678 case '-':
1679 if (!opname)
1680 opname = "neg";
1681 emit_move(target, REG_EAX, expr->unop->ctype, NULL);
1682 insn(opname, REG_EAX, NULL, NULL);
1683 emit_move(REG_EAX, new, expr->unop->ctype, NULL);
1684 break;
1685 default:
1686 assert(0);
1687 break;
1688 }
1689
1690 return new;
1691 }
1692
1693 static void emit_case_statement(struct statement *stmt)
1694 {
1695 emit_labelsym(stmt->case_label, NULL);
1696 x86_statement(stmt->case_statement);
1697 }
1698
1699 static void emit_switch_statement(struct statement *stmt)
1700 {
1701 struct storage *val = x86_expression(stmt->switch_expression);
1702 struct symbol *sym, *default_sym = NULL;
1703 struct storage *labelsym, *label;
1704 int switch_end = 0;
1705
1706 emit_move(val, REG_EAX, stmt->switch_expression->ctype, "begin case");
1707
1708 /*
1709 * This is where a _real_ back-end would go through the
1710 * cases to decide whether to use a lookup table or a
1711 * series of comparisons etc
1712 */
1713 FOR_EACH_PTR(stmt->switch_case->symbol_list, sym) {
1714 struct statement *case_stmt = sym->stmt;
1715 struct expression *expr = case_stmt->case_expression;
1716 struct expression *to = case_stmt->case_to;
1717
1718 /* default: */
1719 if (!expr)
1720 default_sym = sym;
1721
1722 /* case NNN: */
1723 else {
1724 struct storage *case_val = new_val(expr->value);
1725
1726 assert (expr->type == EXPR_VALUE);
1727
1728 insn("cmpl", case_val, REG_EAX, NULL);
1729
1730 if (!to) {
1731 labelsym = new_labelsym(sym);
1732 insn("je", labelsym, NULL, NULL);
1733 } else {
1734 int next_test;
1735
1736 label = new_storage(STOR_LABEL);
1737 label->flags |= STOR_WANTS_FREE;
1738 label->label = next_test = new_label();
1739
1740 /* FIXME: signed/unsigned */
1741 insn("jl", label, NULL, NULL);
1742
1743 case_val = new_val(to->value);
1744 insn("cmpl", case_val, REG_EAX, NULL);
1745
1746 /* TODO: implement and use refcounting... */
1747 label = new_storage(STOR_LABEL);
1748 label->flags |= STOR_WANTS_FREE;
1749 label->label = next_test;
1750
1751 /* FIXME: signed/unsigned */
1752 insn("jg", label, NULL, NULL);
1753
1754 labelsym = new_labelsym(sym);
1755 insn("jmp", labelsym, NULL, NULL);
1756
1757 emit_label(next_test, NULL);
1758 }
1759 }
1760 } END_FOR_EACH_PTR(sym);
1761
1762 if (default_sym) {
1763 labelsym = new_labelsym(default_sym);
1764 insn("jmp", labelsym, NULL, "default");
1765 } else {
1766 label = new_storage(STOR_LABEL);
1767 label->flags |= STOR_WANTS_FREE;
1768 label->label = switch_end = new_label();
1769 insn("jmp", label, NULL, "goto end of switch");
1770 }
1771
1772 x86_statement(stmt->switch_statement);
1773
1774 if (stmt->switch_break->used)
1775 emit_labelsym(stmt->switch_break, NULL);
1776
1777 if (switch_end)
1778 emit_label(switch_end, NULL);
1779 }
1780
1781 static void x86_struct_member(struct symbol *sym)
1782 {
1783 printf("\t%s:%d:%ld at offset %ld.%d", show_ident(sym->ident), sym->bit_size, sym->ctype.alignment, sym->offset, sym->bit_offset);
1784 printf("\n");
1785 }
1786
1787 static void x86_symbol(struct symbol *sym)
1788 {
1789 struct symbol *type;
1790
1791 if (!sym)
1792 return;
1793
1794 type = sym->ctype.base_type;
1795 if (!type)
1796 return;
1797
1798 /*
1799 * Show actual implementation information
1800 */
1801 switch (type->type) {
1802
1803 case SYM_ARRAY:
1804 if (sym->initializer)
1805 emit_array(sym);
1806 else
1807 emit_array_noinit(sym);
1808 break;
1809
1810 case SYM_BASETYPE:
1811 if (sym->initializer) {
1812 emit_object_pre(show_ident(sym->ident),
1813 sym->ctype.modifiers,
1814 sym->ctype.alignment,
1815 sym->bit_size / 8);
1816 emit_scalar(sym->initializer, sym->bit_size);
1817 stor_sym_init(sym);
1818 } else
1819 emit_scalar_noinit(sym);
1820 break;
1821
1822 case SYM_STRUCT:
1823 case SYM_UNION: {
1824 struct symbol *member;
1825
1826 printf(" {\n");
1827 FOR_EACH_PTR(type->symbol_list, member) {
1828 x86_struct_member(member);
1829 } END_FOR_EACH_PTR(member);
1830 printf("}\n");
1831 break;
1832 }
1833
1834 case SYM_FN: {
1835 struct statement *stmt = type->stmt;
1836 if (stmt) {
1837 emit_func_pre(sym);
1838 x86_statement(stmt);
1839 emit_func_post(sym);
1840 }
1841 break;
1842 }
1843
1844 default:
1845 break;
1846 }
1847
1848 if (sym->initializer && (type->type != SYM_BASETYPE) &&
1849 (type->type != SYM_ARRAY)) {
1850 printf(" = \n");
1851 x86_expression(sym->initializer);
1852 }
1853 }
1854
1855 static void x86_symbol_init(struct symbol *sym);
1856
1857 static void x86_symbol_decl(struct symbol_list *syms)
1858 {
1859 struct symbol *sym;
1860 FOR_EACH_PTR(syms, sym) {
1861 x86_symbol_init(sym);
1862 } END_FOR_EACH_PTR(sym);
1863 }
1864
1865 static void loopstk_push(int cont_lbl, int loop_bottom_lbl)
1866 {
1867 struct function *f = current_func;
1868 struct loop_stack *ls;
1869
1870 ls = malloc(sizeof(*ls));
1871 ls->continue_lbl = cont_lbl;
1872 ls->loop_bottom_lbl = loop_bottom_lbl;
1873 ls->next = f->loop_stack;
1874 f->loop_stack = ls;
1875 }
1876
1877 static void loopstk_pop(void)
1878 {
1879 struct function *f = current_func;
1880 struct loop_stack *ls;
1881
1882 assert(f->loop_stack != NULL);
1883 ls = f->loop_stack;
1884 f->loop_stack = f->loop_stack->next;
1885 free(ls);
1886 }
1887
1888 static int loopstk_break(void)
1889 {
1890 return current_func->loop_stack->loop_bottom_lbl;
1891 }
1892
1893 static int loopstk_continue(void)
1894 {
1895 return current_func->loop_stack->continue_lbl;
1896 }
1897
1898 static void emit_loop(struct statement *stmt)
1899 {
1900 struct statement *pre_statement = stmt->iterator_pre_statement;
1901 struct expression *pre_condition = stmt->iterator_pre_condition;
1902 struct statement *statement = stmt->iterator_statement;
1903 struct statement *post_statement = stmt->iterator_post_statement;
1904 struct expression *post_condition = stmt->iterator_post_condition;
1905 int loop_top = 0, loop_bottom, loop_continue;
1906 int have_bottom = 0;
1907 struct storage *val;
1908
1909 loop_bottom = new_label();
1910 loop_continue = new_label();
1911 loopstk_push(loop_continue, loop_bottom);
1912
1913 x86_symbol_decl(stmt->iterator_syms);
1914 x86_statement(pre_statement);
1915 if (!post_condition || post_condition->type != EXPR_VALUE || post_condition->value) {
1916 loop_top = new_label();
1917 emit_label(loop_top, "loop top");
1918 }
1919 if (pre_condition) {
1920 if (pre_condition->type == EXPR_VALUE) {
1921 if (!pre_condition->value) {
1922 struct storage *lbv;
1923 lbv = new_storage(STOR_LABEL);
1924 lbv->label = loop_bottom;
1925 lbv->flags = STOR_WANTS_FREE;
1926 insn("jmp", lbv, NULL, "go to loop bottom");
1927 have_bottom = 1;
1928 }
1929 } else {
1930 struct storage *lbv = new_storage(STOR_LABEL);
1931 lbv->label = loop_bottom;
1932 lbv->flags = STOR_WANTS_FREE;
1933 have_bottom = 1;
1934
1935 val = x86_expression(pre_condition);
1936
1937 emit_move(val, REG_EAX, NULL, "loop pre condition");
1938 insn("test", REG_EAX, REG_EAX, NULL);
1939 insn("jz", lbv, NULL, NULL);
1940 }
1941 }
1942 x86_statement(statement);
1943 if (stmt->iterator_continue->used)
1944 emit_label(loop_continue, "'continue' iterator");
1945 x86_statement(post_statement);
1946 if (!post_condition) {
1947 struct storage *lbv = new_storage(STOR_LABEL);
1948 lbv->label = loop_top;
1949 lbv->flags = STOR_WANTS_FREE;
1950 insn("jmp", lbv, NULL, "go to loop top");
1951 } else if (post_condition->type == EXPR_VALUE) {
1952 if (post_condition->value) {
1953 struct storage *lbv = new_storage(STOR_LABEL);
1954 lbv->label = loop_top;
1955 lbv->flags = STOR_WANTS_FREE;
1956 insn("jmp", lbv, NULL, "go to loop top");
1957 }
1958 } else {
1959 struct storage *lbv = new_storage(STOR_LABEL);
1960 lbv->label = loop_top;
1961 lbv->flags = STOR_WANTS_FREE;
1962
1963 val = x86_expression(post_condition);
1964
1965 emit_move(val, REG_EAX, NULL, "loop post condition");
1966 insn("test", REG_EAX, REG_EAX, NULL);
1967 insn("jnz", lbv, NULL, NULL);
1968 }
1969 if (have_bottom || stmt->iterator_break->used)
1970 emit_label(loop_bottom, "loop bottom");
1971
1972 loopstk_pop();
1973 }
1974
1975 /*
1976 * Print out a statement
1977 */
1978 static struct storage *x86_statement(struct statement *stmt)
1979 {
1980 if (!stmt)
1981 return NULL;
1982 switch (stmt->type) {
1983 default:
1984 return NULL;
1985 case STMT_RETURN:
1986 return emit_return_stmt(stmt);
1987 case STMT_DECLARATION:
1988 x86_symbol_decl(stmt->declaration);
1989 break;
1990 case STMT_COMPOUND: {
1991 struct statement *s;
1992 struct storage *last = NULL;
1993
1994 FOR_EACH_PTR(stmt->stmts, s) {
1995 last = x86_statement(s);
1996 } END_FOR_EACH_PTR(s);
1997
1998 return last;
1999 }
2000
2001 case STMT_EXPRESSION:
2002 return x86_expression(stmt->expression);
2003 case STMT_IF:
2004 emit_if_conditional(stmt);
2005 return NULL;
2006
2007 case STMT_CASE:
2008 emit_case_statement(stmt);
2009 break;
2010 case STMT_SWITCH:
2011 emit_switch_statement(stmt);
2012 break;
2013
2014 case STMT_ITERATOR:
2015 emit_loop(stmt);
2016 break;
2017
2018 case STMT_NONE:
2019 break;
2020
2021 case STMT_LABEL:
2022 printf(".L%p:\n", stmt->label_identifier);
2023 x86_statement(stmt->label_statement);
2024 break;
2025
2026 case STMT_GOTO:
2027 if (stmt->goto_expression) {
2028 struct storage *val = x86_expression(stmt->goto_expression);
2029 printf("\tgoto *v%d\n", val->pseudo);
2030 } else if (!strcmp("break", show_ident(stmt->goto_label->ident))) {
2031 struct storage *lbv = new_storage(STOR_LABEL);
2032 lbv->label = loopstk_break();
2033 lbv->flags = STOR_WANTS_FREE;
2034 insn("jmp", lbv, NULL, "'break'; go to loop bottom");
2035 } else if (!strcmp("continue", show_ident(stmt->goto_label->ident))) {
2036 struct storage *lbv = new_storage(STOR_LABEL);
2037 lbv->label = loopstk_continue();
2038 lbv->flags = STOR_WANTS_FREE;
2039 insn("jmp", lbv, NULL, "'continue'; go to loop top");
2040 } else {
2041 struct storage *labelsym = new_labelsym(stmt->goto_label);
2042 insn("jmp", labelsym, NULL, NULL);
2043 }
2044 break;
2045 case STMT_ASM:
2046 printf("\tasm( .... )\n");
2047 break;
2048 }
2049 return NULL;
2050 }
2051
2052 static struct storage *x86_call_expression(struct expression *expr)
2053 {
2054 struct function *f = current_func;
2055 struct symbol *direct;
2056 struct expression *arg, *fn;
2057 struct storage *retval, *fncall;
2058 int framesize;
2059 char s[64];
2060
2061 if (!expr->ctype) {
2062 warning(expr->pos, "\tcall with no type!");
2063 return NULL;
2064 }
2065
2066 framesize = 0;
2067 FOR_EACH_PTR_REVERSE(expr->args, arg) {
2068 struct storage *new = x86_expression(arg);
2069 int size = arg->ctype->bit_size;
2070
2071 /*
2072 * FIXME: i386 SysV ABI dictates that values
2073 * smaller than 32 bits should be placed onto
2074 * the stack as 32-bit objects. We should not
2075 * blindly do a 32-bit push on objects smaller
2076 * than 32 bits.
2077 */
2078 if (size < 32)
2079 size = 32;
2080 insn("pushl", new, NULL,
2081 !framesize ? "begin function call" : NULL);
2082
2083 framesize += bits_to_bytes(size);
2084 } END_FOR_EACH_PTR_REVERSE(arg);
2085
2086 fn = expr->fn;
2087
2088 /* Remove dereference, if any */
2089 direct = NULL;
2090 if (fn->type == EXPR_PREOP) {
2091 if (fn->unop->type == EXPR_SYMBOL) {
2092 struct symbol *sym = fn->unop->symbol;
2093 if (sym->ctype.base_type->type == SYM_FN)
2094 direct = sym;
2095 }
2096 }
2097 if (direct) {
2098 struct storage *direct_stor = new_storage(STOR_SYM);
2099 direct_stor->flags |= STOR_WANTS_FREE;
2100 direct_stor->sym = direct;
2101 insn("call", direct_stor, NULL, NULL);
2102 } else {
2103 fncall = x86_expression(fn);
2104 emit_move(fncall, REG_EAX, fn->ctype, NULL);
2105
2106 strcpy(s, "\tcall\t*%eax\n");
2107 push_text_atom(f, s);
2108 }
2109
2110 /* FIXME: pay attention to BITS_IN_POINTER */
2111 if (framesize) {
2112 struct storage *val = new_storage(STOR_VALUE);
2113 val->value = (long long) framesize;
2114 val->flags = STOR_WANTS_FREE;
2115 insn("addl", val, REG_ESP, NULL);
2116 }
2117
2118 retval = stack_alloc(4);
2119 emit_move(REG_EAX, retval, NULL, "end function call");
2120
2121 return retval;
2122 }
2123
2124 static struct storage *x86_address_gen(struct expression *expr)
2125 {
2126 struct function *f = current_func;
2127 struct storage *addr;
2128 struct storage *new;
2129 char s[32];
2130
2131 addr = x86_expression(expr->unop);
2132 if (expr->unop->type == EXPR_SYMBOL)
2133 return addr;
2134
2135 emit_move(addr, REG_EAX, NULL, "begin deref ..");
2136
2137 /* FIXME: operand size */
2138 strcpy(s, "\tmovl\t(%eax), %ecx\n");
2139 push_text_atom(f, s);
2140
2141 new = stack_alloc(4);
2142 emit_move(REG_ECX, new, NULL, ".... end deref");
2143
2144 return new;
2145 }
2146
2147 static struct storage *x86_assignment(struct expression *expr)
2148 {
2149 struct expression *target = expr->left;
2150 struct storage *val, *addr;
2151
2152 if (!expr->ctype)
2153 return NULL;
2154
2155 val = x86_expression(expr->right);
2156 addr = x86_address_gen(target);
2157
2158 switch (val->type) {
2159 /* copy, where both operands are memory */
2160 case STOR_PSEUDO:
2161 case STOR_ARG:
2162 emit_copy(addr, val, expr->ctype);
2163 break;
2164
2165 /* copy, one or zero operands are memory */
2166 case STOR_REG:
2167 case STOR_SYM:
2168 case STOR_VALUE:
2169 case STOR_LABEL:
2170 emit_move(val, addr, expr->left->ctype, NULL);
2171 break;
2172
2173 case STOR_LABELSYM:
2174 assert(0);
2175 break;
2176 }
2177 return val;
2178 }
2179
2180 static int x86_initialization(struct symbol *sym, struct expression *expr)
2181 {
2182 struct storage *val, *addr;
2183 int bits;
2184
2185 if (!expr->ctype)
2186 return 0;
2187
2188 bits = expr->ctype->bit_size;
2189 val = x86_expression(expr);
2190 addr = x86_symbol_expr(sym);
2191 // FIXME! The "target" expression is for bitfield store information.
2192 // Leave it NULL, which works fine.
2193 emit_store(NULL, addr, val, bits);
2194 return 0;
2195 }
2196
2197 static struct storage *x86_access(struct expression *expr)
2198 {
2199 return x86_address_gen(expr);
2200 }
2201
2202 static struct storage *x86_preop(struct expression *expr)
2203 {
2204 /*
2205 * '*' is an lvalue access, and is fundamentally different
2206 * from an arithmetic operation. Maybe it should have an
2207 * expression type of its own..
2208 */
2209 if (expr->op == '*')
2210 return x86_access(expr);
2211 if (expr->op == SPECIAL_INCREMENT || expr->op == SPECIAL_DECREMENT)
2212 return emit_inc_dec(expr, 0);
2213 return emit_regular_preop(expr);
2214 }
2215
2216 static struct storage *x86_symbol_expr(struct symbol *sym)
2217 {
2218 struct storage *new = stack_alloc(4);
2219
2220 if (sym->ctype.modifiers & (MOD_TOPLEVEL | MOD_EXTERN | MOD_STATIC)) {
2221 printf("\tmovi.%d\t\tv%d,$%s\n", bits_in_pointer, new->pseudo, show_ident(sym->ident));
2222 return new;
2223 }
2224 if (sym->ctype.modifiers & MOD_ADDRESSABLE) {
2225 printf("\taddi.%d\t\tv%d,vFP,$%lld\n", bits_in_pointer, new->pseudo, sym->value);
2226 return new;
2227 }
2228 printf("\taddi.%d\t\tv%d,vFP,$offsetof(%s:%p)\n", bits_in_pointer, new->pseudo, show_ident(sym->ident), sym);
2229 return new;
2230 }
2231
2232 static void x86_symbol_init(struct symbol *sym)
2233 {
2234 struct symbol_private *priv = sym->aux;
2235 struct expression *expr = sym->initializer;
2236 struct storage *new;
2237
2238 if (expr)
2239 new = x86_expression(expr);
2240 else
2241 new = stack_alloc(sym->bit_size / 8);
2242
2243 if (!priv) {
2244 priv = calloc(1, sizeof(*priv));
2245 sym->aux = priv;
2246 /* FIXME: leak! we don't free... */
2247 /* (well, we don't free symbols either) */
2248 }
2249
2250 priv->addr = new;
2251 }
2252
2253 static int type_is_signed(struct symbol *sym)
2254 {
2255 if (sym->type == SYM_NODE)
2256 sym = sym->ctype.base_type;
2257 if (sym->type == SYM_PTR)
2258 return 0;
2259 return !(sym->ctype.modifiers & MOD_UNSIGNED);
2260 }
2261
2262 static struct storage *x86_label_expr(struct expression *expr)
2263 {
2264 struct storage *new = stack_alloc(4);
2265 printf("\tmovi.%d\t\tv%d,.L%p\n", bits_in_pointer, new->pseudo, expr->label_symbol);
2266 return new;
2267 }
2268
2269 static struct storage *x86_statement_expr(struct expression *expr)
2270 {
2271 return x86_statement(expr->statement);
2272 }
2273
2274 static int x86_position_expr(struct expression *expr, struct symbol *base)
2275 {
2276 struct storage *new = x86_expression(expr->init_expr);
2277 struct symbol *ctype = expr->init_expr->ctype;
2278
2279 printf("\tinsert v%d at [%d:%d] of %s\n", new->pseudo,
2280 expr->init_offset, ctype->bit_offset,
2281 show_ident(base->ident));
2282 return 0;
2283 }
2284
2285 static void x86_initializer_expr(struct expression *expr, struct symbol *ctype)
2286 {
2287 struct expression *entry;
2288
2289 FOR_EACH_PTR(expr->expr_list, entry) {
2290 // Nested initializers have their positions already
2291 // recursively calculated - just output them too
2292 if (entry->type == EXPR_INITIALIZER) {
2293 x86_initializer_expr(entry, ctype);
2294 continue;
2295 }
2296
2297 // Ignore initializer indexes and identifiers - the
2298 // evaluator has taken them into account
2299 if (entry->type == EXPR_IDENTIFIER || entry->type == EXPR_INDEX)
2300 continue;
2301 if (entry->type == EXPR_POS) {
2302 x86_position_expr(entry, ctype);
2303 continue;
2304 }
2305 x86_initialization(ctype, entry);
2306 } END_FOR_EACH_PTR(entry);
2307 }
2308
2309 /*
2310 * Print out an expression. Return the pseudo that contains the
2311 * variable.
2312 */
2313 static struct storage *x86_expression(struct expression *expr)
2314 {
2315 if (!expr)
2316 return NULL;
2317
2318 if (!expr->ctype) {
2319 struct position *pos = &expr->pos;
2320 printf("\tno type at %s:%d:%d\n",
2321 stream_name(pos->stream),
2322 pos->line, pos->pos);
2323 return NULL;
2324 }
2325
2326 switch (expr->type) {
2327 default:
2328 return NULL;
2329 case EXPR_CALL:
2330 return x86_call_expression(expr);
2331
2332 case EXPR_ASSIGNMENT:
2333 return x86_assignment(expr);
2334
2335 case EXPR_COMPARE:
2336 return emit_compare(expr);
2337 case EXPR_BINOP:
2338 case EXPR_COMMA:
2339 case EXPR_LOGICAL:
2340 return emit_binop(expr);
2341 case EXPR_PREOP:
2342 return x86_preop(expr);
2343 case EXPR_POSTOP:
2344 return emit_postop(expr);
2345 case EXPR_SYMBOL:
2346 return emit_symbol_expr_init(expr->symbol);
2347 case EXPR_DEREF:
2348 case EXPR_SIZEOF:
2349 case EXPR_ALIGNOF:
2350 warning(expr->pos, "invalid expression after evaluation");
2351 return NULL;
2352 case EXPR_CAST:
2353 case EXPR_FORCE_CAST:
2354 case EXPR_IMPLIED_CAST:
2355 return emit_cast_expr(expr);
2356 case EXPR_VALUE:
2357 return emit_value(expr);
2358 case EXPR_STRING:
2359 return emit_string_expr(expr);
2360 case EXPR_INITIALIZER:
2361 x86_initializer_expr(expr, expr->ctype);
2362 return NULL;
2363 case EXPR_SELECT:
2364 return emit_select_expr(expr);
2365 case EXPR_CONDITIONAL:
2366 return emit_conditional_expr(expr);
2367 case EXPR_STATEMENT:
2368 return x86_statement_expr(expr);
2369 case EXPR_LABEL:
2370 return x86_label_expr(expr);
2371
2372 // None of these should exist as direct expressions: they are only
2373 // valid as sub-expressions of initializers.
2374 case EXPR_POS:
2375 warning(expr->pos, "unable to show plain initializer position expression");
2376 return NULL;
2377 case EXPR_IDENTIFIER:
2378 warning(expr->pos, "unable to show identifier expression");
2379 return NULL;
2380 case EXPR_INDEX:
2381 warning(expr->pos, "unable to show index expression");
2382 return NULL;
2383 case EXPR_TYPE:
2384 warning(expr->pos, "unable to show type expression");
2385 return NULL;
2386 case EXPR_FVALUE:
2387 warning(expr->pos, "floating point support is not implemented");
2388 return NULL;
2389 }
2390 return NULL;
2391 }
Static analysis for C