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