4 */
5
6 #include <llvm-c/Core.h>
7 #include <llvm-c/BitWriter.h>
8 #include <llvm-c/Analysis.h>
9 #include <llvm-c/Target.h>
10
11 #include <stdbool.h>
12 #include <stdio.h>
13 #include <unistd.h>
14 #include <string.h>
15 #include <assert.h>
16
17 #include "symbol.h"
18 #include "expression.h"
19 #include "linearize.h"
20 #include "flow.h"
21
22 struct function {
23 LLVMBuilderRef builder;
24 LLVMTypeRef type;
25 LLVMValueRef fn;
26 LLVMModuleRef module;
27 };
28
29 static inline bool symbol_is_fp_type(struct symbol *sym)
30 {
31 if (!sym)
32 return false;
33
34 return sym->ctype.base_type == &fp_type;
35 }
36
37 static LLVMTypeRef symbol_type(LLVMModuleRef module, struct symbol *sym);
38
39 static LLVMTypeRef func_return_type(LLVMModuleRef module, struct symbol *sym)
40 {
41 return symbol_type(module, sym->ctype.base_type);
42 }
43
44 static LLVMTypeRef sym_func_type(LLVMModuleRef module, struct symbol *sym)
45 {
46 LLVMTypeRef *arg_type;
47 LLVMTypeRef func_type;
48 LLVMTypeRef ret_type;
49 struct symbol *arg;
50 int n_arg = 0;
51
52 /* to avoid strangeness with varargs [for now], we build
53 * the function and type anew, for each call. This
54 * is probably wrong. We should look up the
55 * symbol declaration info.
56 */
57
58 ret_type = func_return_type(module, sym);
59
60 /* count args, build argument type information */
61 FOR_EACH_PTR(sym->arguments, arg) {
62 n_arg++;
63 } END_FOR_EACH_PTR(arg);
64
65 arg_type = calloc(n_arg, sizeof(LLVMTypeRef));
66
67 int idx = 0;
68 FOR_EACH_PTR(sym->arguments, arg) {
69 struct symbol *arg_sym = arg->ctype.base_type;
70
71 arg_type[idx++] = symbol_type(module, arg_sym);
72 } END_FOR_EACH_PTR(arg);
73 func_type = LLVMFunctionType(ret_type, arg_type, n_arg,
74 sym->variadic);
75
76 return func_type;
77 }
78
79 static LLVMTypeRef sym_array_type(LLVMModuleRef module, struct symbol *sym)
80 {
81 LLVMTypeRef elem_type;
82 struct symbol *base_type;
83
84 base_type = sym->ctype.base_type;
85 /* empty struct is undefined [6.7.2.1(8)] */
86 assert(base_type->bit_size > 0);
87
88 elem_type = symbol_type(module, base_type);
89 if (!elem_type)
90 return NULL;
91
92 return LLVMArrayType(elem_type, sym->bit_size / base_type->bit_size);
93 }
94
95 #define MAX_STRUCT_MEMBERS 64
96
97 static LLVMTypeRef sym_struct_type(LLVMModuleRef module, struct symbol *sym)
98 {
99 LLVMTypeRef elem_types[MAX_STRUCT_MEMBERS];
100 struct symbol *member;
101 char buffer[256];
102 LLVMTypeRef ret;
103 unsigned nr = 0;
104
105 snprintf(buffer, sizeof(buffer), "struct.%s", sym->ident ? sym->ident->name : "anno");
106 ret = LLVMStructCreateNamed(LLVMGetGlobalContext(), buffer);
107 /* set ->aux to avoid recursion */
108 sym->aux = ret;
109
110 FOR_EACH_PTR(sym->symbol_list, member) {
111 LLVMTypeRef member_type;
112
113 assert(nr < MAX_STRUCT_MEMBERS);
114
115 member_type = symbol_type(module, member);
116
117 elem_types[nr++] = member_type;
118 } END_FOR_EACH_PTR(member);
119
120 LLVMStructSetBody(ret, elem_types, nr, 0 /* packed? */);
121 return ret;
122 }
123
124 static LLVMTypeRef sym_union_type(LLVMModuleRef module, struct symbol *sym)
125 {
126 LLVMTypeRef elements;
127 unsigned union_size;
128
129 /*
130 * There's no union support in the LLVM API so we treat unions as
131 * opaque structs. The downside is that we lose type information on the
132 * members but as LLVM doesn't care, neither do we.
133 */
134 union_size = sym->bit_size / 8;
135
136 elements = LLVMArrayType(LLVMInt8Type(), union_size);
137
138 return LLVMStructType(&elements, 1, 0 /* packed? */);
139 }
140
141 static LLVMTypeRef sym_ptr_type(LLVMModuleRef module, struct symbol *sym)
142 {
143 LLVMTypeRef type;
144
145 /* 'void *' is treated like 'char *' */
146 if (is_void_type(sym->ctype.base_type))
147 type = LLVMInt8Type();
148 else
149 type = symbol_type(module, sym->ctype.base_type);
150
151 return LLVMPointerType(type, 0);
152 }
153
154 static LLVMTypeRef sym_basetype_type(struct symbol *sym)
155 {
156 LLVMTypeRef ret = NULL;
157
158 if (symbol_is_fp_type(sym)) {
159 switch (sym->bit_size) {
160 case 32:
161 ret = LLVMFloatType();
162 break;
163 case 64:
164 ret = LLVMDoubleType();
165 break;
166 case 80:
167 ret = LLVMX86FP80Type();
168 break;
169 default:
170 die("invalid bit size %d for type %d", sym->bit_size, sym->type);
171 break;
172 }
173 } else {
174 switch (sym->bit_size) {
175 case -1:
176 ret = LLVMVoidType();
177 break;
178 case 1:
182 ret = LLVMInt8Type();
183 break;
184 case 16:
185 ret = LLVMInt16Type();
186 break;
187 case 32:
188 ret = LLVMInt32Type();
189 break;
190 case 64:
191 ret = LLVMInt64Type();
192 break;
193 default:
194 die("invalid bit size %d for type %d", sym->bit_size, sym->type);
195 break;
196 }
197 }
198
199 return ret;
200 }
201
202 static LLVMTypeRef symbol_type(LLVMModuleRef module, struct symbol *sym)
203 {
204 LLVMTypeRef ret = NULL;
205
206 /* don't cache the result for SYM_NODE */
207 if (sym->type == SYM_NODE)
208 return symbol_type(module, sym->ctype.base_type);
209
210 if (sym->aux)
211 return sym->aux;
212
213 switch (sym->type) {
214 case SYM_BITFIELD:
215 case SYM_ENUM:
216 ret = symbol_type(module, sym->ctype.base_type);
217 break;
218 case SYM_BASETYPE:
219 ret = sym_basetype_type(sym);
220 break;
221 case SYM_PTR:
222 ret = sym_ptr_type(module, sym);
223 break;
224 case SYM_UNION:
225 ret = sym_union_type(module, sym);
226 break;
227 case SYM_STRUCT:
228 ret = sym_struct_type(module, sym);
229 break;
230 case SYM_ARRAY:
231 ret = sym_array_type(module, sym);
232 break;
233 case SYM_FN:
234 ret = sym_func_type(module, sym);
235 break;
236 default:
237 assert(0);
238 }
239
240 /* cache the result */
241 sym->aux = ret;
242 return ret;
243 }
244
245 static LLVMTypeRef int_type_by_size(int size)
246 {
247 switch (size) {
248 case 1: return LLVMInt1Type();
249 case 8: return LLVMInt8Type();
250 case 16: return LLVMInt16Type();
251 case 32: return LLVMInt32Type();
252 case 64: return LLVMInt64Type();
253
254 default:
255 die("invalid bit size %d", size);
256 break;
257 }
258 return NULL; /* not reached */
259 }
260
261 static LLVMTypeRef insn_symbol_type(LLVMModuleRef module, struct instruction *insn)
262 {
263 if (insn->type)
264 return symbol_type(module, insn->type);
265
266 return int_type_by_size(insn->size);
267 }
268
269 static LLVMLinkage data_linkage(struct symbol *sym)
270 {
271 if (sym->ctype.modifiers & MOD_STATIC)
272 return LLVMPrivateLinkage;
273
274 return LLVMExternalLinkage;
275 }
276
277 static LLVMLinkage function_linkage(struct symbol *sym)
278 {
279 if (sym->ctype.modifiers & MOD_STATIC)
280 return LLVMInternalLinkage;
281
282 return LLVMExternalLinkage;
283 }
284
285 #define MAX_PSEUDO_NAME 64
286
287 static void pseudo_name(pseudo_t pseudo, char *buf)
288 {
289 switch (pseudo->type) {
290 case PSEUDO_REG:
291 snprintf(buf, MAX_PSEUDO_NAME, "R%d", pseudo->nr);
292 break;
293 case PSEUDO_SYM:
294 assert(0);
295 break;
296 case PSEUDO_VAL:
297 assert(0);
298 break;
299 case PSEUDO_ARG: {
300 assert(0);
301 break;
302 }
303 case PSEUDO_PHI:
304 snprintf(buf, MAX_PSEUDO_NAME, "PHI%d", pseudo->nr);
305 break;
306 default:
307 assert(0);
308 }
309 }
310
311 static LLVMValueRef pseudo_to_value(struct function *fn, struct instruction *insn, pseudo_t pseudo)
312 {
313 LLVMValueRef result = NULL;
314
315 switch (pseudo->type) {
316 case PSEUDO_REG:
317 result = pseudo->priv;
318 break;
319 case PSEUDO_SYM: {
320 struct symbol *sym = pseudo->sym;
321 struct expression *expr;
322
323 assert(sym->bb_target == NULL);
324
325 expr = sym->initializer;
326 if (expr) {
327 switch (expr->type) {
328 case EXPR_STRING: {
329 const char *s = expr->string->data;
330 LLVMValueRef indices[] = { LLVMConstInt(LLVMInt64Type(), 0, 0), LLVMConstInt(LLVMInt64Type(), 0, 0) };
331 LLVMValueRef data;
332
333 data = LLVMAddGlobal(fn->module, LLVMArrayType(LLVMInt8Type(), strlen(s) + 1), ".str");
334 LLVMSetLinkage(data, LLVMPrivateLinkage);
335 LLVMSetGlobalConstant(data, 1);
336 LLVMSetInitializer(data, LLVMConstString(strdup(s), strlen(s) + 1, true));
337
338 result = LLVMConstGEP(data, indices, ARRAY_SIZE(indices));
339 break;
340 }
341 case EXPR_SYMBOL: {
342 struct symbol *sym = expr->symbol;
343
344 result = LLVMGetNamedGlobal(fn->module, show_ident(sym->ident));
345 assert(result != NULL);
346 break;
347 }
348 default:
349 assert(0);
350 }
351 } else {
352 const char *name = show_ident(sym->ident);
353 LLVMTypeRef type = symbol_type(fn->module, sym);
354
355 if (LLVMGetTypeKind(type) == LLVMFunctionTypeKind) {
356 result = LLVMGetNamedFunction(fn->module, name);
357 if (!result)
358 result = LLVMAddFunction(fn->module, name, type);
359 } else {
360 result = LLVMGetNamedGlobal(fn->module, name);
361 if (!result)
362 result = LLVMAddGlobal(fn->module, type, name);
363 }
364 }
365 break;
366 }
367 case PSEUDO_VAL:
368 result = LLVMConstInt(int_type_by_size(pseudo->size), pseudo->value, 1);
369 break;
370 case PSEUDO_ARG: {
371 result = LLVMGetParam(fn->fn, pseudo->nr - 1);
372 break;
373 }
374 case PSEUDO_PHI:
375 result = pseudo->priv;
376 break;
377 case PSEUDO_VOID:
378 result = NULL;
379 break;
380 default:
381 assert(0);
382 }
383
384 return result;
385 }
386
387 static LLVMValueRef calc_gep(LLVMBuilderRef builder, LLVMValueRef base, LLVMValueRef off)
388 {
389 LLVMTypeRef type = LLVMTypeOf(base);
390 unsigned int as = LLVMGetPointerAddressSpace(type);
391 LLVMTypeRef bytep = LLVMPointerType(LLVMInt8Type(), as);
392 LLVMValueRef addr;
393
394 /* convert base to char* type */
395 base = LLVMBuildPointerCast(builder, base, bytep, "");
396 /* addr = base + off */
397 addr = LLVMBuildInBoundsGEP(builder, base, &off, 1, "");
398 /* convert back to the actual pointer type */
399 addr = LLVMBuildPointerCast(builder, addr, type, "");
400 return addr;
401 }
402
403 static LLVMRealPredicate translate_fop(int opcode)
404 {
405 static const LLVMRealPredicate trans_tbl[] = {
406 [OP_SET_EQ] = LLVMRealOEQ,
407 [OP_SET_NE] = LLVMRealUNE,
408 [OP_SET_LE] = LLVMRealOLE,
409 [OP_SET_GE] = LLVMRealOGE,
410 [OP_SET_LT] = LLVMRealOLT,
411 [OP_SET_GT] = LLVMRealOGT,
412 /* Are these used with FP? */
413 [OP_SET_B] = LLVMRealOLT,
414 [OP_SET_A] = LLVMRealOGT,
415 [OP_SET_BE] = LLVMRealOLE,
416 [OP_SET_AE] = LLVMRealOGE,
417 };
418
419 return trans_tbl[opcode];
420 }
421
422 static LLVMIntPredicate translate_op(int opcode)
423 {
424 static const LLVMIntPredicate trans_tbl[] = {
425 [OP_SET_EQ] = LLVMIntEQ,
426 [OP_SET_NE] = LLVMIntNE,
427 [OP_SET_LE] = LLVMIntSLE,
428 [OP_SET_GE] = LLVMIntSGE,
429 [OP_SET_LT] = LLVMIntSLT,
430 [OP_SET_GT] = LLVMIntSGT,
431 [OP_SET_B] = LLVMIntULT,
432 [OP_SET_A] = LLVMIntUGT,
433 [OP_SET_BE] = LLVMIntULE,
434 [OP_SET_AE] = LLVMIntUGE,
435 };
436
437 return trans_tbl[opcode];
438 }
439
440 static void output_op_binary(struct function *fn, struct instruction *insn)
441 {
442 LLVMValueRef lhs, rhs, target;
443 char target_name[64];
444
445 lhs = pseudo_to_value(fn, insn, insn->src1);
446
447 rhs = pseudo_to_value(fn, insn, insn->src2);
448
449 pseudo_name(insn->target, target_name);
450
451 switch (insn->opcode) {
452 /* Binary */
453 case OP_ADD:
454 if (symbol_is_fp_type(insn->type))
455 target = LLVMBuildFAdd(fn->builder, lhs, rhs, target_name);
456 else
457 target = LLVMBuildAdd(fn->builder, lhs, rhs, target_name);
458 break;
459 case OP_SUB:
460 if (symbol_is_fp_type(insn->type))
461 target = LLVMBuildFSub(fn->builder, lhs, rhs, target_name);
462 else
463 target = LLVMBuildSub(fn->builder, lhs, rhs, target_name);
464 break;
465 case OP_MULU:
466 if (symbol_is_fp_type(insn->type))
467 target = LLVMBuildFMul(fn->builder, lhs, rhs, target_name);
468 else
469 target = LLVMBuildMul(fn->builder, lhs, rhs, target_name);
470 break;
471 case OP_MULS:
472 assert(!symbol_is_fp_type(insn->type));
473 target = LLVMBuildMul(fn->builder, lhs, rhs, target_name);
474 break;
475 case OP_DIVU:
476 if (symbol_is_fp_type(insn->type))
477 target = LLVMBuildFDiv(fn->builder, lhs, rhs, target_name);
478 else
479 target = LLVMBuildUDiv(fn->builder, lhs, rhs, target_name);
480 break;
481 case OP_DIVS:
482 assert(!symbol_is_fp_type(insn->type));
483 target = LLVMBuildSDiv(fn->builder, lhs, rhs, target_name);
484 break;
485 case OP_MODU:
486 assert(!symbol_is_fp_type(insn->type));
487 target = LLVMBuildURem(fn->builder, lhs, rhs, target_name);
488 break;
489 case OP_MODS:
490 assert(!symbol_is_fp_type(insn->type));
491 target = LLVMBuildSRem(fn->builder, lhs, rhs, target_name);
492 break;
493 case OP_SHL:
494 assert(!symbol_is_fp_type(insn->type));
495 target = LLVMBuildShl(fn->builder, lhs, rhs, target_name);
496 break;
497 case OP_LSR:
498 assert(!symbol_is_fp_type(insn->type));
499 target = LLVMBuildLShr(fn->builder, lhs, rhs, target_name);
500 break;
501 case OP_ASR:
502 assert(!symbol_is_fp_type(insn->type));
503 target = LLVMBuildAShr(fn->builder, lhs, rhs, target_name);
504 break;
505
506 /* Logical */
507 case OP_AND:
508 assert(!symbol_is_fp_type(insn->type));
509 target = LLVMBuildAnd(fn->builder, lhs, rhs, target_name);
510 break;
511 case OP_OR:
512 assert(!symbol_is_fp_type(insn->type));
513 target = LLVMBuildOr(fn->builder, lhs, rhs, target_name);
514 break;
515 case OP_XOR:
516 assert(!symbol_is_fp_type(insn->type));
517 target = LLVMBuildXor(fn->builder, lhs, rhs, target_name);
518 break;
519 case OP_AND_BOOL: {
520 LLVMValueRef lhs_nz, rhs_nz;
521 LLVMTypeRef dst_type;
522
523 lhs_nz = LLVMBuildIsNotNull(fn->builder, lhs, "");
524 rhs_nz = LLVMBuildIsNotNull(fn->builder, rhs, "");
525 target = LLVMBuildAnd(fn->builder, lhs_nz, rhs_nz, target_name);
526
527 dst_type = insn_symbol_type(fn->module, insn);
528 target = LLVMBuildZExt(fn->builder, target, dst_type, target_name);
529 break;
530 }
531 case OP_OR_BOOL: {
532 LLVMValueRef lhs_nz, rhs_nz;
533 LLVMTypeRef dst_type;
534
535 lhs_nz = LLVMBuildIsNotNull(fn->builder, lhs, "");
536 rhs_nz = LLVMBuildIsNotNull(fn->builder, rhs, "");
537 target = LLVMBuildOr(fn->builder, lhs_nz, rhs_nz, target_name);
538
539 dst_type = insn_symbol_type(fn->module, insn);
540 target = LLVMBuildZExt(fn->builder, target, dst_type, target_name);
541 break;
542 }
543 default:
544 assert(0);
545 break;
546 }
547
548 insn->target->priv = target;
549 }
550
551 static void output_op_compare(struct function *fn, struct instruction *insn)
552 {
553 LLVMValueRef lhs, rhs, target;
554 char target_name[64];
555
556 lhs = pseudo_to_value(fn, insn, insn->src1);
557
558 if (insn->src2->type == PSEUDO_VAL)
559 rhs = LLVMConstInt(LLVMTypeOf(lhs), insn->src2->value, 1);
560 else
561 rhs = pseudo_to_value(fn, insn, insn->src2);
562
563 pseudo_name(insn->target, target_name);
564
565 LLVMTypeRef dst_type = insn_symbol_type(fn->module, insn);
566
567 if (LLVMGetTypeKind(LLVMTypeOf(lhs)) == LLVMIntegerTypeKind) {
568 LLVMIntPredicate op = translate_op(insn->opcode);
569
570 target = LLVMBuildICmp(fn->builder, op, lhs, rhs, target_name);
571 } else {
572 LLVMRealPredicate op = translate_fop(insn->opcode);
573
574 target = LLVMBuildFCmp(fn->builder, op, lhs, rhs, target_name);
575 }
576
577 target = LLVMBuildZExt(fn->builder, target, dst_type, target_name);
578
579 insn->target->priv = target;
580 }
581
582 static void output_op_ret(struct function *fn, struct instruction *insn)
583 {
584 pseudo_t pseudo = insn->src;
585
586 if (pseudo && pseudo != VOID) {
587 LLVMValueRef result = pseudo_to_value(fn, insn, pseudo);
588
589 LLVMBuildRet(fn->builder, result);
590 } else
591 LLVMBuildRetVoid(fn->builder);
592 }
593
594 static LLVMValueRef calc_memop_addr(struct function *fn, struct instruction *insn)
595 {
596 LLVMTypeRef int_type, addr_type;
597 LLVMValueRef src, off, addr;
598 unsigned int as;
599
600 /* int type large enough to hold a pointer */
601 int_type = LLVMIntType(bits_in_pointer);
602 off = LLVMConstInt(int_type, insn->offset, 0);
603
604 /* convert src to the effective pointer type */
605 src = pseudo_to_value(fn, insn, insn->src);
606 as = LLVMGetPointerAddressSpace(LLVMTypeOf(src));
607 addr_type = LLVMPointerType(insn_symbol_type(fn->module, insn), as);
608 src = LLVMBuildPointerCast(fn->builder, src, addr_type, "");
609
610 /* addr = src + off */
611 addr = calc_gep(fn->builder, src, off);
612 return addr;
613 }
614
615
616 static void output_op_load(struct function *fn, struct instruction *insn)
617 {
618 LLVMValueRef addr, target;
619
620 addr = calc_memop_addr(fn, insn);
621
622 /* perform load */
623 target = LLVMBuildLoad(fn->builder, addr, "load_target");
624
625 insn->target->priv = target;
626 }
627
628 static void output_op_store(struct function *fn, struct instruction *insn)
629 {
630 LLVMValueRef addr, target, target_in;
631
632 addr = calc_memop_addr(fn, insn);
633
634 target_in = pseudo_to_value(fn, insn, insn->target);
635
636 /* perform store */
637 target = LLVMBuildStore(fn->builder, target_in, addr);
638
639 insn->target->priv = target;
640 }
641
642 static LLVMValueRef bool_value(struct function *fn, LLVMValueRef value)
643 {
644 if (LLVMTypeOf(value) != LLVMInt1Type())
645 value = LLVMBuildIsNotNull(fn->builder, value, "cond");
646
647 return value;
648 }
649
650 static void output_op_cbr(struct function *fn, struct instruction *br)
651 {
652 LLVMValueRef cond = bool_value(fn,
653 pseudo_to_value(fn, br, br->cond));
654
655 LLVMBuildCondBr(fn->builder, cond,
656 br->bb_true->priv,
657 br->bb_false->priv);
658 }
659
660 static void output_op_br(struct function *fn, struct instruction *br)
661 {
662 LLVMBuildBr(fn->builder, br->bb_true->priv);
663 }
664
665 static void output_op_sel(struct function *fn, struct instruction *insn)
666 {
667 LLVMValueRef target, src1, src2, src3;
668
669 src1 = bool_value(fn, pseudo_to_value(fn, insn, insn->src1));
670 src2 = pseudo_to_value(fn, insn, insn->src2);
671 src3 = pseudo_to_value(fn, insn, insn->src3);
672
673 target = LLVMBuildSelect(fn->builder, src1, src2, src3, "select");
674
675 insn->target->priv = target;
676 }
677
678 static void output_op_switch(struct function *fn, struct instruction *insn)
679 {
680 LLVMValueRef sw_val, target;
681 struct basic_block *def = NULL;
682 struct multijmp *jmp;
683 int n_jmp = 0;
684
685 FOR_EACH_PTR(insn->multijmp_list, jmp) {
686 if (jmp->begin == jmp->end) { /* case N */
687 n_jmp++;
688 } else if (jmp->begin < jmp->end) { /* case M..N */
689 assert(0);
690 } else /* default case */
691 def = jmp->target;
692 } END_FOR_EACH_PTR(jmp);
693
694 sw_val = pseudo_to_value(fn, insn, insn->target);
695 target = LLVMBuildSwitch(fn->builder, sw_val,
696 def ? def->priv : NULL, n_jmp);
697
698 FOR_EACH_PTR(insn->multijmp_list, jmp) {
699 if (jmp->begin == jmp->end) { /* case N */
700 LLVMAddCase(target,
701 LLVMConstInt(LLVMInt32Type(), jmp->begin, 0),
702 jmp->target->priv);
703 } else if (jmp->begin < jmp->end) { /* case M..N */
704 assert(0);
705 }
706 } END_FOR_EACH_PTR(jmp);
707
708 insn->target->priv = target;
709 }
710
711 static void output_op_call(struct function *fn, struct instruction *insn)
712 {
713 LLVMValueRef target, func;
714 int n_arg = 0, i;
715 struct pseudo *arg;
716 LLVMValueRef *args;
717
718 FOR_EACH_PTR(insn->arguments, arg) {
719 n_arg++;
720 } END_FOR_EACH_PTR(arg);
721
722 args = calloc(n_arg, sizeof(LLVMValueRef));
723
724 i = 0;
725 FOR_EACH_PTR(insn->arguments, arg) {
726 args[i++] = pseudo_to_value(fn, insn, arg);
727 } END_FOR_EACH_PTR(arg);
728
729 func = pseudo_to_value(fn, insn, insn->func);
730 target = LLVMBuildCall(fn->builder, func, args, n_arg, "");
731
732 insn->target->priv = target;
733 }
734
735 static void output_op_phisrc(struct function *fn, struct instruction *insn)
736 {
737 LLVMValueRef v;
738 struct instruction *phi;
739
740 assert(insn->target->priv == NULL);
741
742 /* target = src */
743 v = pseudo_to_value(fn, insn, insn->phi_src);
744
745 FOR_EACH_PTR(insn->phi_users, phi) {
746 LLVMValueRef load, ptr;
747
748 assert(phi->opcode == OP_PHI);
749 /* phi must be load from alloca */
750 load = phi->target->priv;
751 assert(LLVMGetInstructionOpcode(load) == LLVMLoad);
752 ptr = LLVMGetOperand(load, 0);
753 /* store v to alloca */
754 LLVMBuildStore(fn->builder, v, ptr);
755 } END_FOR_EACH_PTR(phi);
756 }
757
758 static void output_op_phi(struct function *fn, struct instruction *insn)
759 {
760 LLVMValueRef load = insn->target->priv;
761
762 /* forward load */
763 assert(LLVMGetInstructionOpcode(load) == LLVMLoad);
764 /* forward load has no parent block */
765 assert(!LLVMGetInstructionParent(load));
766 /* finalize load in current block */
767 LLVMInsertIntoBuilder(fn->builder, load);
768 }
769
770 static void output_op_ptrcast(struct function *fn, struct instruction *insn)
771 {
772 LLVMValueRef src, target;
773 char target_name[64];
774
775 src = insn->src->priv;
776 if (!src)
777 src = pseudo_to_value(fn, insn, insn->src);
778
779 pseudo_name(insn->target, target_name);
780
781 assert(!symbol_is_fp_type(insn->type));
782
783 target = LLVMBuildBitCast(fn->builder, src, insn_symbol_type(fn->module, insn), target_name);
784
785 insn->target->priv = target;
786 }
787
788 static void output_op_cast(struct function *fn, struct instruction *insn, LLVMOpcode op)
789 {
790 LLVMValueRef src, target;
791 char target_name[64];
792
793 src = insn->src->priv;
794 if (!src)
795 src = pseudo_to_value(fn, insn, insn->src);
796
797 pseudo_name(insn->target, target_name);
798
799 assert(!symbol_is_fp_type(insn->type));
800
801 if (insn->size < LLVMGetIntTypeWidth(LLVMTypeOf(src)))
802 target = LLVMBuildTrunc(fn->builder, src, insn_symbol_type(fn->module, insn), target_name);
803 else
804 target = LLVMBuildCast(fn->builder, op, src, insn_symbol_type(fn->module, insn), target_name);
805
806 insn->target->priv = target;
807 }
808
809 static void output_insn(struct function *fn, struct instruction *insn)
810 {
811 switch (insn->opcode) {
812 case OP_RET:
813 output_op_ret(fn, insn);
814 break;
815 case OP_BR:
816 output_op_br(fn, insn);
817 break;
818 case OP_CBR:
819 output_op_cbr(fn, insn);
820 break;
821 case OP_SYMADDR:
822 assert(0);
823 break;
824 case OP_SETVAL:
825 assert(0);
826 break;
827 case OP_SWITCH:
828 output_op_switch(fn, insn);
829 break;
830 case OP_COMPUTEDGOTO:
831 assert(0);
832 break;
833 case OP_PHISOURCE:
834 output_op_phisrc(fn, insn);
835 break;
836 case OP_PHI:
837 output_op_phi(fn, insn);
838 break;
839 case OP_LOAD:
840 output_op_load(fn, insn);
841 break;
842 case OP_LNOP:
843 assert(0);
844 break;
845 case OP_STORE:
846 output_op_store(fn, insn);
847 break;
848 case OP_SNOP:
849 assert(0);
850 break;
851 case OP_INLINED_CALL:
852 assert(0);
853 break;
854 case OP_CALL:
855 output_op_call(fn, insn);
856 break;
857 case OP_CAST:
858 output_op_cast(fn, insn, LLVMZExt);
859 break;
860 case OP_SCAST:
861 output_op_cast(fn, insn, LLVMSExt);
862 break;
863 case OP_FPCAST:
864 assert(0);
865 break;
866 case OP_PTRCAST:
867 output_op_ptrcast(fn, insn);
868 break;
869 case OP_BINARY ... OP_BINARY_END:
870 output_op_binary(fn, insn);
871 break;
872 case OP_BINCMP ... OP_BINCMP_END:
873 output_op_compare(fn, insn);
874 break;
875 case OP_SEL:
876 output_op_sel(fn, insn);
877 break;
878 case OP_SLICE:
879 assert(0);
880 break;
881 case OP_NOT: {
882 LLVMValueRef src, target;
883 char target_name[64];
884
885 src = pseudo_to_value(fn, insn, insn->src);
886
887 pseudo_name(insn->target, target_name);
888
889 target = LLVMBuildNot(fn->builder, src, target_name);
890
891 insn->target->priv = target;
892 break;
893 }
894 case OP_NEG:
895 assert(0);
896 break;
897 case OP_CONTEXT:
898 assert(0);
899 break;
900 case OP_RANGE:
901 assert(0);
902 break;
903 case OP_NOP:
904 assert(0);
905 break;
906 case OP_DEATHNOTE:
907 break;
908 case OP_ASM:
909 assert(0);
910 break;
911 case OP_COPY:
912 assert(0);
913 break;
914 default:
915 break;
916 }
917 }
918
919 static void output_bb(struct function *fn, struct basic_block *bb, unsigned long generation)
920 {
921 struct instruction *insn;
922
923 bb->generation = generation;
924
925 FOR_EACH_PTR(bb->insns, insn) {
926 if (!insn->bb)
927 continue;
928
929 output_insn(fn, insn);
930 }
931 END_FOR_EACH_PTR(insn);
932 }
933
934 #define MAX_ARGS 64
935
936 static void output_fn(LLVMModuleRef module, struct entrypoint *ep)
937 {
938 unsigned long generation = ++bb_generation;
939 struct symbol *sym = ep->name;
940 struct symbol *base_type = sym->ctype.base_type;
941 struct symbol *ret_type = sym->ctype.base_type->ctype.base_type;
942 LLVMTypeRef arg_types[MAX_ARGS];
943 LLVMTypeRef return_type;
944 struct function function = { .module = module };
945 struct basic_block *bb;
946 struct symbol *arg;
947 const char *name;
948 int nr_args = 0;
949
950 FOR_EACH_PTR(base_type->arguments, arg) {
951 struct symbol *arg_base_type = arg->ctype.base_type;
952
953 arg_types[nr_args++] = symbol_type(module, arg_base_type);
954 } END_FOR_EACH_PTR(arg);
955
956 name = show_ident(sym->ident);
957
958 return_type = symbol_type(module, ret_type);
959
960 function.type = LLVMFunctionType(return_type, arg_types, nr_args, 0);
961
962 function.fn = LLVMAddFunction(module, name, function.type);
963 LLVMSetFunctionCallConv(function.fn, LLVMCCallConv);
964
965 LLVMSetLinkage(function.fn, function_linkage(sym));
966
967 function.builder = LLVMCreateBuilder();
968
969 static int nr_bb;
970
971 FOR_EACH_PTR(ep->bbs, bb) {
972 if (bb->generation == generation)
973 continue;
974
975 LLVMBasicBlockRef bbr;
976 char bbname[32];
977 struct instruction *insn;
978
979 sprintf(bbname, "L%d", nr_bb++);
980 bbr = LLVMAppendBasicBlock(function.fn, bbname);
981
982 bb->priv = bbr;
983
984 /* allocate alloca for each phi */
985 FOR_EACH_PTR(bb->insns, insn) {
986 LLVMBasicBlockRef entrybbr;
987 LLVMTypeRef phi_type;
988 LLVMValueRef ptr;
989
990 if (!insn->bb || insn->opcode != OP_PHI)
991 continue;
992 /* insert alloca into entry block */
993 entrybbr = LLVMGetEntryBasicBlock(function.fn);
994 LLVMPositionBuilderAtEnd(function.builder, entrybbr);
995 phi_type = insn_symbol_type(module, insn);
996 ptr = LLVMBuildAlloca(function.builder, phi_type, "");
997 /* emit forward load for phi */
998 LLVMClearInsertionPosition(function.builder);
999 insn->target->priv = LLVMBuildLoad(function.builder, ptr, "phi");
1000 } END_FOR_EACH_PTR(insn);
1001 }
1002 END_FOR_EACH_PTR(bb);
1003
1004 FOR_EACH_PTR(ep->bbs, bb) {
1005 if (bb->generation == generation)
1006 continue;
1007
1008 LLVMPositionBuilderAtEnd(function.builder, bb->priv);
1009
1010 output_bb(&function, bb, generation);
1011 }
1012 END_FOR_EACH_PTR(bb);
1013 }
1014
1015 static LLVMValueRef output_data(LLVMModuleRef module, struct symbol *sym)
1016 {
1017 struct expression *initializer = sym->initializer;
1018 LLVMValueRef initial_value;
1019 LLVMValueRef data;
1020 const char *name;
1021
1022 if (initializer) {
1023 switch (initializer->type) {
1024 case EXPR_VALUE:
1025 initial_value = LLVMConstInt(symbol_type(module, sym), initializer->value, 1);
1026 break;
1027 case EXPR_SYMBOL: {
1028 struct symbol *sym = initializer->symbol;
1029
1030 initial_value = LLVMGetNamedGlobal(module, show_ident(sym->ident));
1031 if (!initial_value)
1032 initial_value = output_data(module, sym);
1033 break;
1034 }
1035 case EXPR_STRING: {
1036 const char *s = initializer->string->data;
1037
1038 initial_value = LLVMConstString(strdup(s), strlen(s) + 1, true);
1039 break;
1040 }
1041 default:
1042 assert(0);
1043 }
1044 } else {
1045 LLVMTypeRef type = symbol_type(module, sym);
1046
1047 initial_value = LLVMConstNull(type);
1048 }
1049
1050 name = show_ident(sym->ident);
1051
1052 data = LLVMAddGlobal(module, LLVMTypeOf(initial_value), name);
1053
1054 LLVMSetLinkage(data, data_linkage(sym));
1055 if (sym->ctype.modifiers & MOD_CONST)
1056 LLVMSetGlobalConstant(data, 1);
1057 if (sym->ctype.modifiers & MOD_TLS)
1058 LLVMSetThreadLocal(data, 1);
1059 if (sym->ctype.alignment)
1060 LLVMSetAlignment(data, sym->ctype.alignment);
1061
1062 if (!(sym->ctype.modifiers & MOD_EXTERN))
1063 LLVMSetInitializer(data, initial_value);
1064
1065 return data;
1066 }
1067
1068 static int is_prototype(struct symbol *sym)
1069 {
1070 if (sym->type == SYM_NODE)
1071 sym = sym->ctype.base_type;
1072 return sym && sym->type == SYM_FN && !sym->stmt;
1073 }
1074
1075 static int compile(LLVMModuleRef module, struct symbol_list *list)
1076 {
1077 struct symbol *sym;
1078
1079 FOR_EACH_PTR(list, sym) {
1080 struct entrypoint *ep;
1081 expand_symbol(sym);
1082
1083 if (is_prototype(sym))
1084 continue;
1085
1086 ep = linearize_symbol(sym);
1087 if (ep)
1088 output_fn(module, ep);
1089 else
1090 output_data(module, sym);
1091 }
1092 END_FOR_EACH_PTR(sym);
1093
1094 return 0;
1095 }
1096
1097 #ifndef LLVM_DEFAULT_TARGET_TRIPLE
1098 #define LLVM_DEFAULT_TARGET_TRIPLE LLVM_HOSTTRIPLE
1099 #endif
1100
1101 #define X86_LINUX_LAYOUT \
1102 "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-" \
1103 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-" \
1104 "a0:0:64-f80:32:32-n8:16:32-S128"
1141 LLVMSetTarget(module, triple);
1142 LLVMSetDataLayout(module, layout);
1143 }
1144
1145 int main(int argc, char **argv)
1146 {
1147 struct string_list *filelist = NULL;
1148 struct symbol_list *symlist;
1149 LLVMModuleRef module;
1150 char *file;
1151
1152 symlist = sparse_initialize(argc, argv, &filelist);
1153
1154 module = LLVMModuleCreateWithName("sparse");
1155 set_target(module);
1156
1157 compile(module, symlist);
1158
1159 /* need ->phi_users */
1160 dbg_dead = 1;
1161 FOR_EACH_PTR_NOTAG(filelist, file) {
1162 symlist = sparse(file);
1163 if (die_if_error)
1164 return 1;
1165 compile(module, symlist);
1166 } END_FOR_EACH_PTR_NOTAG(file);
1167
1168 LLVMVerifyModule(module, LLVMPrintMessageAction, NULL);
1169
1170 LLVMWriteBitcodeToFD(module, STDOUT_FILENO, 0, 0);
1171
1172 LLVMDisposeModule(module);
1173
1174 report_stats();
1175 return 0;
1176 }
|
4 */
5
6 #include <llvm-c/Core.h>
7 #include <llvm-c/BitWriter.h>
8 #include <llvm-c/Analysis.h>
9 #include <llvm-c/Target.h>
10
11 #include <stdbool.h>
12 #include <stdio.h>
13 #include <unistd.h>
14 #include <string.h>
15 #include <assert.h>
16
17 #include "symbol.h"
18 #include "expression.h"
19 #include "linearize.h"
20 #include "flow.h"
21
22 struct function {
23 LLVMBuilderRef builder;
24 LLVMValueRef fn;
25 LLVMModuleRef module;
26 };
27
28 static LLVMTypeRef symbol_type(struct symbol *sym);
29
30 static LLVMTypeRef func_return_type(struct symbol *sym)
31 {
32 return symbol_type(sym->ctype.base_type);
33 }
34
35 static LLVMTypeRef sym_func_type(struct symbol *sym)
36 {
37 int n_arg = symbol_list_size(sym->arguments);
38 LLVMTypeRef *arg_type = calloc(n_arg, sizeof(LLVMTypeRef));
39 LLVMTypeRef ret_type = func_return_type(sym);
40 struct symbol *arg;
41 int idx = 0;
42
43 FOR_EACH_PTR(sym->arguments, arg) {
44 struct symbol *arg_sym = arg->ctype.base_type;
45
46 arg_type[idx++] = symbol_type(arg_sym);
47 } END_FOR_EACH_PTR(arg);
48
49 return LLVMFunctionType(ret_type, arg_type, n_arg, sym->variadic);
50 }
51
52 static LLVMTypeRef sym_array_type(struct symbol *sym)
53 {
54 LLVMTypeRef elem_type;
55 struct symbol *base_type;
56
57 base_type = sym->ctype.base_type;
58 /* empty struct is undefined [6.7.2.1(8)] */
59 assert(base_type->bit_size > 0);
60
61 elem_type = symbol_type(base_type);
62 if (!elem_type)
63 return NULL;
64
65 return LLVMArrayType(elem_type, sym->bit_size / base_type->bit_size);
66 }
67
68 #define MAX_STRUCT_MEMBERS 64
69
70 static LLVMTypeRef sym_struct_type(struct symbol *sym)
71 {
72 LLVMTypeRef elem_types[MAX_STRUCT_MEMBERS];
73 struct symbol *member;
74 char buffer[256];
75 LLVMTypeRef ret;
76 unsigned nr = 0;
77
78 snprintf(buffer, sizeof(buffer), "struct.%s", sym->ident ? sym->ident->name : "anno");
79 ret = LLVMStructCreateNamed(LLVMGetGlobalContext(), buffer);
80 /* set ->aux to avoid recursion */
81 sym->aux = ret;
82
83 FOR_EACH_PTR(sym->symbol_list, member) {
84 LLVMTypeRef member_type;
85
86 assert(nr < MAX_STRUCT_MEMBERS);
87
88 member_type = symbol_type(member);
89
90 elem_types[nr++] = member_type;
91 } END_FOR_EACH_PTR(member);
92
93 LLVMStructSetBody(ret, elem_types, nr, 0 /* packed? */);
94 return ret;
95 }
96
97 static LLVMTypeRef sym_union_type(struct symbol *sym)
98 {
99 LLVMTypeRef elements;
100 unsigned union_size;
101
102 /*
103 * There's no union support in the LLVM API so we treat unions as
104 * opaque structs. The downside is that we lose type information on the
105 * members but as LLVM doesn't care, neither do we.
106 */
107 union_size = sym->bit_size / 8;
108
109 elements = LLVMArrayType(LLVMInt8Type(), union_size);
110
111 return LLVMStructType(&elements, 1, 0 /* packed? */);
112 }
113
114 static LLVMTypeRef sym_ptr_type(struct symbol *sym)
115 {
116 LLVMTypeRef type;
117
118 /* 'void *' is treated like 'char *' */
119 if (is_void_type(sym->ctype.base_type))
120 type = LLVMInt8Type();
121 else
122 type = symbol_type(sym->ctype.base_type);
123
124 return LLVMPointerType(type, 0);
125 }
126
127 static LLVMTypeRef sym_basetype_type(struct symbol *sym)
128 {
129 LLVMTypeRef ret = NULL;
130
131 if (is_float_type(sym)) {
132 switch (sym->bit_size) {
133 case 32:
134 ret = LLVMFloatType();
135 break;
136 case 64:
137 ret = LLVMDoubleType();
138 break;
139 case 80:
140 ret = LLVMX86FP80Type();
141 break;
142 default:
143 die("invalid bit size %d for type %d", sym->bit_size, sym->type);
144 break;
145 }
146 } else {
147 switch (sym->bit_size) {
148 case -1:
149 ret = LLVMVoidType();
150 break;
151 case 1:
155 ret = LLVMInt8Type();
156 break;
157 case 16:
158 ret = LLVMInt16Type();
159 break;
160 case 32:
161 ret = LLVMInt32Type();
162 break;
163 case 64:
164 ret = LLVMInt64Type();
165 break;
166 default:
167 die("invalid bit size %d for type %d", sym->bit_size, sym->type);
168 break;
169 }
170 }
171
172 return ret;
173 }
174
175 static LLVMTypeRef symbol_type(struct symbol *sym)
176 {
177 LLVMTypeRef ret = NULL;
178
179 /* don't cache the result for SYM_NODE */
180 if (sym->type == SYM_NODE)
181 return symbol_type(sym->ctype.base_type);
182
183 if (sym->aux)
184 return sym->aux;
185
186 switch (sym->type) {
187 case SYM_BITFIELD:
188 ret = LLVMIntType(sym->bit_size);
189 break;
190 case SYM_RESTRICT:
191 case SYM_ENUM:
192 ret = symbol_type(sym->ctype.base_type);
193 break;
194 case SYM_BASETYPE:
195 ret = sym_basetype_type(sym);
196 break;
197 case SYM_PTR:
198 ret = sym_ptr_type(sym);
199 break;
200 case SYM_UNION:
201 ret = sym_union_type(sym);
202 break;
203 case SYM_STRUCT:
204 ret = sym_struct_type(sym);
205 break;
206 case SYM_ARRAY:
207 ret = sym_array_type(sym);
208 break;
209 case SYM_FN:
210 ret = sym_func_type(sym);
211 break;
212 default:
213 assert(0);
214 }
215
216 /* cache the result */
217 sym->aux = ret;
218 return ret;
219 }
220
221 static LLVMTypeRef insn_symbol_type(struct instruction *insn)
222 {
223 if (insn->type)
224 return symbol_type(insn->type);
225
226 switch (insn->size) {
227 case 8: return LLVMInt8Type();
228 case 16: return LLVMInt16Type();
229 case 32: return LLVMInt32Type();
230 case 64: return LLVMInt64Type();
231
232 default:
233 die("invalid bit size %d", insn->size);
234 break;
235 }
236
237 return NULL; /* not reached */
238 }
239
240 static LLVMLinkage data_linkage(struct symbol *sym)
241 {
242 if (sym->ctype.modifiers & MOD_STATIC)
243 return LLVMPrivateLinkage;
244
245 return LLVMExternalLinkage;
246 }
247
248 static LLVMLinkage function_linkage(struct symbol *sym)
249 {
250 if (sym->ctype.modifiers & MOD_STATIC)
251 return LLVMInternalLinkage;
252
253 return LLVMExternalLinkage;
254 }
255
256 #define MAX_PSEUDO_NAME 64
257
258 static const char *pseudo_name(pseudo_t pseudo, char *buf)
259 {
260 switch (pseudo->type) {
261 case PSEUDO_REG:
262 snprintf(buf, MAX_PSEUDO_NAME, "R%d.", pseudo->nr);
263 break;
264 case PSEUDO_PHI:
265 snprintf(buf, MAX_PSEUDO_NAME, "PHI%d.", pseudo->nr);
266 break;
267 case PSEUDO_SYM:
268 case PSEUDO_VAL:
269 case PSEUDO_ARG:
270 case PSEUDO_VOID:
271 buf[0] = '\0';
272 break;
273 case PSEUDO_UNDEF:
274 assert(0);
275 break;
276 default:
277 assert(0);
278 }
279
280 return buf;
281 }
282
283 static LLVMValueRef get_sym_value(LLVMModuleRef module, struct symbol *sym)
284 {
285 const char *name = show_ident(sym->ident);
286 LLVMTypeRef type = symbol_type(sym);
287 LLVMValueRef result = NULL;
288 struct expression *expr;
289
290 assert(sym->bb_target == NULL);
291
292 expr = sym->initializer;
293 if (expr && !sym->ident) {
294 switch (expr->type) {
295 case EXPR_STRING: {
296 const char *s = expr->string->data;
297 LLVMValueRef indices[] = { LLVMConstInt(LLVMInt64Type(), 0, 0), LLVMConstInt(LLVMInt64Type(), 0, 0) };
298 LLVMValueRef data;
299
300 data = LLVMAddGlobal(module, LLVMArrayType(LLVMInt8Type(), strlen(s) + 1), ".str");
301 LLVMSetLinkage(data, LLVMPrivateLinkage);
302 LLVMSetGlobalConstant(data, 1);
303 LLVMSetInitializer(data, LLVMConstString(strdup(s), strlen(s) + 1, true));
304
305 result = LLVMConstGEP(data, indices, ARRAY_SIZE(indices));
306 return result;
307 }
308 default:
309 break;
310 }
311 }
312
313 if (LLVMGetTypeKind(type) == LLVMFunctionTypeKind) {
314 result = LLVMGetNamedFunction(module, name);
315 if (!result)
316 result = LLVMAddFunction(module, name, type);
317 } else {
318 result = LLVMGetNamedGlobal(module, name);
319 if (!result)
320 result = LLVMAddGlobal(module, type, name);
321 }
322
323 return result;
324 }
325
326 static LLVMValueRef constant_value(unsigned long long val, LLVMTypeRef dtype)
327 {
328 LLVMValueRef result;
329
330 switch (LLVMGetTypeKind(dtype)) {
331 case LLVMPointerTypeKind:
332 if (val != 0) { // for example: ... = (void*) 0x123;
333 LLVMTypeRef itype = LLVMIntType(bits_in_pointer);
334 result = LLVMConstInt(itype, val, 1);
335 result = LLVMConstIntToPtr(result, dtype);
336 } else {
337 result = LLVMConstPointerNull(dtype);
338 }
339 break;
340 case LLVMIntegerTypeKind:
341 result = LLVMConstInt(dtype, val, 1);
342 break;
343 case LLVMArrayTypeKind:
344 case LLVMStructTypeKind:
345 if (val != 0)
346 return NULL;
347 result = LLVMConstNull(dtype);
348 break;
349 default:
350 return NULL;
351 }
352 return result;
353 }
354
355 static LLVMValueRef val_to_value(unsigned long long val, struct symbol *ctype)
356 {
357 LLVMValueRef result;
358 LLVMTypeRef dtype;
359
360 assert(ctype);
361 dtype = symbol_type(ctype);
362 result = constant_value(val, dtype);
363 if (result)
364 return result;
365 sparse_error(ctype->pos, "no value possible for %s", show_typename(ctype));
366 return LLVMGetUndef(symbol_type(ctype));
367 }
368
369 static LLVMValueRef pseudo_to_value(struct function *fn, struct symbol *ctype, pseudo_t pseudo)
370 {
371 LLVMValueRef result = NULL;
372
373 switch (pseudo->type) {
374 case PSEUDO_REG:
375 result = pseudo->priv;
376 break;
377 case PSEUDO_SYM:
378 result = get_sym_value(fn->module, pseudo->sym);
379 break;
380 case PSEUDO_VAL:
381 result = val_to_value(pseudo->value, ctype);
382 break;
383 case PSEUDO_ARG: {
384 result = LLVMGetParam(fn->fn, pseudo->nr - 1);
385 break;
386 }
387 case PSEUDO_PHI:
388 result = pseudo->priv;
389 break;
390 case PSEUDO_VOID:
391 result = NULL;
392 break;
393 case PSEUDO_UNDEF:
394 result = LLVMGetUndef(symbol_type(ctype));
395 break;
396 default:
397 assert(0);
398 }
399
400 return result;
401 }
402
403 static LLVMValueRef pseudo_to_rvalue(struct function *fn, struct symbol *ctype, pseudo_t pseudo)
404 {
405 LLVMValueRef val = pseudo_to_value(fn, ctype, pseudo);
406 LLVMTypeRef dtype = symbol_type(ctype);
407 char name[MAX_PSEUDO_NAME];
408
409 pseudo_name(pseudo, name);
410 return LLVMBuildBitCast(fn->builder, val, dtype, name);
411 }
412
413 static LLVMValueRef value_to_ivalue(struct function *fn, struct symbol *ctype, LLVMValueRef val)
414 {
415 const char *name = LLVMGetValueName(val);
416 LLVMTypeRef dtype = symbol_type(ctype);
417
418 if (LLVMGetTypeKind(LLVMTypeOf(val)) == LLVMPointerTypeKind) {
419 LLVMTypeRef dtype = LLVMIntType(bits_in_pointer);
420 val = LLVMBuildPtrToInt(fn->builder, val, dtype, name);
421 }
422 if (ctype && is_int_type(ctype)) {
423 val = LLVMBuildIntCast(fn->builder, val, dtype, name);
424 }
425 return val;
426 }
427
428 static LLVMValueRef value_to_pvalue(struct function *fn, struct symbol *ctype, LLVMValueRef val)
429 {
430 const char *name = LLVMGetValueName(val);
431 LLVMTypeRef dtype = symbol_type(ctype);
432
433 assert(is_ptr_type(ctype));
434 switch (LLVMGetTypeKind(LLVMTypeOf(val))) {
435 case LLVMIntegerTypeKind:
436 val = LLVMBuildIntToPtr(fn->builder, val, dtype, name);
437 break;
438 case LLVMPointerTypeKind:
439 val = LLVMBuildBitCast(fn->builder, val, dtype, name);
440 break;
441 default:
442 break;
443 }
444 return val;
445 }
446
447 static LLVMValueRef adjust_type(struct function *fn, struct symbol *ctype, LLVMValueRef val)
448 {
449 if (is_int_type(ctype))
450 return value_to_ivalue(fn, ctype, val);
451 if (is_ptr_type(ctype))
452 return value_to_pvalue(fn, ctype, val);
453 return val;
454 }
455
456 /*
457 * Get the LLVMValue corresponding to the pseudo
458 * and force the type corresponding to ctype.
459 */
460 static LLVMValueRef get_operand(struct function *fn, struct symbol *ctype, pseudo_t pseudo)
461 {
462 LLVMValueRef target = pseudo_to_value(fn, ctype, pseudo);
463 return adjust_type(fn, ctype, target);
464 }
465
466 /*
467 * Get the LLVMValue corresponding to the pseudo
468 * and force the type corresponding to ctype but
469 * map all pointers to intptr_t.
470 */
471 static LLVMValueRef get_ioperand(struct function *fn, struct symbol *ctype, pseudo_t pseudo)
472 {
473 LLVMValueRef target = pseudo_to_value(fn, ctype, pseudo);
474 return value_to_ivalue(fn, ctype, target);
475 }
476
477 static LLVMValueRef calc_gep(LLVMBuilderRef builder, LLVMValueRef base, LLVMValueRef off)
478 {
479 LLVMTypeRef type = LLVMTypeOf(base);
480 unsigned int as = LLVMGetPointerAddressSpace(type);
481 LLVMTypeRef bytep = LLVMPointerType(LLVMInt8Type(), as);
482 LLVMValueRef addr;
483 const char *name = LLVMGetValueName(off);
484
485 /* convert base to char* type */
486 base = LLVMBuildPointerCast(builder, base, bytep, name);
487 /* addr = base + off */
488 addr = LLVMBuildInBoundsGEP(builder, base, &off, 1, name);
489 /* convert back to the actual pointer type */
490 addr = LLVMBuildPointerCast(builder, addr, type, name);
491 return addr;
492 }
493
494 static LLVMRealPredicate translate_fop(int opcode)
495 {
496 static const LLVMRealPredicate trans_tbl[] = {
497 [OP_FCMP_ORD] = LLVMRealORD,
498 [OP_FCMP_OEQ] = LLVMRealOEQ,
499 [OP_FCMP_ONE] = LLVMRealONE,
500 [OP_FCMP_OLE] = LLVMRealOLE,
501 [OP_FCMP_OGE] = LLVMRealOGE,
502 [OP_FCMP_OLT] = LLVMRealOLT,
503 [OP_FCMP_OGT] = LLVMRealOGT,
504 [OP_FCMP_UEQ] = LLVMRealUEQ,
505 [OP_FCMP_UNE] = LLVMRealUNE,
506 [OP_FCMP_ULE] = LLVMRealULE,
507 [OP_FCMP_UGE] = LLVMRealUGE,
508 [OP_FCMP_ULT] = LLVMRealULT,
509 [OP_FCMP_UGT] = LLVMRealUGT,
510 [OP_FCMP_UNO] = LLVMRealUNO,
511 };
512
513 return trans_tbl[opcode];
514 }
515
516 static LLVMIntPredicate translate_op(int opcode)
517 {
518 static const LLVMIntPredicate trans_tbl[] = {
519 [OP_SET_EQ] = LLVMIntEQ,
520 [OP_SET_NE] = LLVMIntNE,
521 [OP_SET_LE] = LLVMIntSLE,
522 [OP_SET_GE] = LLVMIntSGE,
523 [OP_SET_LT] = LLVMIntSLT,
524 [OP_SET_GT] = LLVMIntSGT,
525 [OP_SET_B] = LLVMIntULT,
526 [OP_SET_A] = LLVMIntUGT,
527 [OP_SET_BE] = LLVMIntULE,
528 [OP_SET_AE] = LLVMIntUGE,
529 };
530
531 return trans_tbl[opcode];
532 }
533
534 static void output_op_binary(struct function *fn, struct instruction *insn)
535 {
536 LLVMValueRef lhs, rhs, target;
537 char target_name[64];
538
539 lhs = get_ioperand(fn, insn->type, insn->src1);
540 rhs = get_ioperand(fn, insn->type, insn->src2);
541
542 pseudo_name(insn->target, target_name);
543
544 switch (insn->opcode) {
545 /* Binary */
546 case OP_ADD:
547 target = LLVMBuildAdd(fn->builder, lhs, rhs, target_name);
548 break;
549 case OP_SUB:
550 target = LLVMBuildSub(fn->builder, lhs, rhs, target_name);
551 break;
552 case OP_MUL:
553 target = LLVMBuildMul(fn->builder, lhs, rhs, target_name);
554 break;
555 case OP_DIVU:
556 target = LLVMBuildUDiv(fn->builder, lhs, rhs, target_name);
557 break;
558 case OP_DIVS:
559 assert(!is_float_type(insn->type));
560 target = LLVMBuildSDiv(fn->builder, lhs, rhs, target_name);
561 break;
562 case OP_MODU:
563 assert(!is_float_type(insn->type));
564 target = LLVMBuildURem(fn->builder, lhs, rhs, target_name);
565 break;
566 case OP_MODS:
567 assert(!is_float_type(insn->type));
568 target = LLVMBuildSRem(fn->builder, lhs, rhs, target_name);
569 break;
570 case OP_SHL:
571 assert(!is_float_type(insn->type));
572 target = LLVMBuildShl(fn->builder, lhs, rhs, target_name);
573 break;
574 case OP_LSR:
575 assert(!is_float_type(insn->type));
576 target = LLVMBuildLShr(fn->builder, lhs, rhs, target_name);
577 break;
578 case OP_ASR:
579 assert(!is_float_type(insn->type));
580 target = LLVMBuildAShr(fn->builder, lhs, rhs, target_name);
581 break;
582
583 /* floating-point */
584 case OP_FADD:
585 target = LLVMBuildFAdd(fn->builder, lhs, rhs, target_name);
586 break;
587 case OP_FSUB:
588 target = LLVMBuildFSub(fn->builder, lhs, rhs, target_name);
589 break;
590 case OP_FMUL:
591 target = LLVMBuildFMul(fn->builder, lhs, rhs, target_name);
592 break;
593 case OP_FDIV:
594 target = LLVMBuildFDiv(fn->builder, lhs, rhs, target_name);
595 break;
596
597 /* Logical */
598 case OP_AND:
599 assert(!is_float_type(insn->type));
600 target = LLVMBuildAnd(fn->builder, lhs, rhs, target_name);
601 break;
602 case OP_OR:
603 assert(!is_float_type(insn->type));
604 target = LLVMBuildOr(fn->builder, lhs, rhs, target_name);
605 break;
606 case OP_XOR:
607 assert(!is_float_type(insn->type));
608 target = LLVMBuildXor(fn->builder, lhs, rhs, target_name);
609 break;
610 default:
611 assert(0);
612 break;
613 }
614
615 target = adjust_type(fn, insn->type, target);
616 insn->target->priv = target;
617 }
618
619 static void output_op_compare(struct function *fn, struct instruction *insn)
620 {
621 LLVMValueRef lhs, rhs, target;
622 char target_name[64];
623
624 lhs = pseudo_to_value(fn, NULL, insn->src1);
625 if (insn->src2->type == PSEUDO_VAL)
626 rhs = constant_value(insn->src2->value, LLVMTypeOf(lhs));
627 else
628 rhs = pseudo_to_value(fn, NULL, insn->src2);
629 if (!rhs)
630 rhs = LLVMGetUndef(symbol_type(insn->type));
631
632 pseudo_name(insn->target, target_name);
633
634 LLVMTypeRef dst_type = insn_symbol_type(insn);
635
636 switch (LLVMGetTypeKind(LLVMTypeOf(lhs))) {
637 case LLVMPointerTypeKind:
638 lhs = value_to_pvalue(fn, &ptr_ctype, lhs);
639 rhs = value_to_pvalue(fn, &ptr_ctype, rhs);
640 /* fall through */
641
642 case LLVMIntegerTypeKind: {
643 LLVMIntPredicate op = translate_op(insn->opcode);
644
645 if (LLVMGetTypeKind(LLVMTypeOf(rhs)) == LLVMPointerTypeKind) {
646 LLVMTypeRef ltype = LLVMTypeOf(lhs);
647 rhs = LLVMBuildPtrToInt(fn->builder, rhs, ltype, "");
648 }
649 target = LLVMBuildICmp(fn->builder, op, lhs, rhs, target_name);
650 break;
651 }
652 case LLVMHalfTypeKind:
653 case LLVMFloatTypeKind:
654 case LLVMDoubleTypeKind:
655 case LLVMX86_FP80TypeKind:
656 case LLVMFP128TypeKind:
657 case LLVMPPC_FP128TypeKind: {
658 LLVMRealPredicate op = translate_fop(insn->opcode);
659
660 target = LLVMBuildFCmp(fn->builder, op, lhs, rhs, target_name);
661 break;
662 }
663 default:
664 assert(0);
665 }
666
667 target = LLVMBuildZExt(fn->builder, target, dst_type, target_name);
668
669 insn->target->priv = target;
670 }
671
672 static void output_op_ret(struct function *fn, struct instruction *insn)
673 {
674 pseudo_t pseudo = insn->src;
675
676 if (pseudo && pseudo != VOID) {
677 LLVMValueRef result = get_operand(fn, insn->type, pseudo);
678 LLVMBuildRet(fn->builder, result);
679 } else
680 LLVMBuildRetVoid(fn->builder);
681 }
682
683 static LLVMValueRef calc_memop_addr(struct function *fn, struct instruction *insn)
684 {
685 LLVMTypeRef int_type, addr_type;
686 LLVMValueRef src, off, addr;
687 unsigned int as;
688
689 /* int type large enough to hold a pointer */
690 int_type = LLVMIntType(bits_in_pointer);
691 off = LLVMConstInt(int_type, insn->offset, 0);
692
693 /* convert src to the effective pointer type */
694 src = pseudo_to_value(fn, insn->type, insn->src);
695 as = LLVMGetPointerAddressSpace(LLVMTypeOf(src));
696 addr_type = LLVMPointerType(insn_symbol_type(insn), as);
697 src = LLVMBuildPointerCast(fn->builder, src, addr_type, LLVMGetValueName(src));
698
699 /* addr = src + off */
700 addr = calc_gep(fn->builder, src, off);
701 return addr;
702 }
703
704
705 static void output_op_load(struct function *fn, struct instruction *insn)
706 {
707 LLVMValueRef addr, target;
708 char name[MAX_PSEUDO_NAME];
709
710 addr = calc_memop_addr(fn, insn);
711
712 /* perform load */
713 pseudo_name(insn->target, name);
714 target = LLVMBuildLoad(fn->builder, addr, name);
715
716 insn->target->priv = target;
717 }
718
719 static void output_op_store(struct function *fn, struct instruction *insn)
720 {
721 LLVMValueRef addr, target_in;
722
723 addr = calc_memop_addr(fn, insn);
724
725 target_in = pseudo_to_rvalue(fn, insn->type, insn->target);
726
727 /* perform store */
728 LLVMBuildStore(fn->builder, target_in, addr);
729 }
730
731 static LLVMValueRef bool_value(struct function *fn, LLVMValueRef value)
732 {
733 if (LLVMTypeOf(value) != LLVMInt1Type())
734 value = LLVMBuildIsNotNull(fn->builder, value, LLVMGetValueName(value));
735
736 return value;
737 }
738
739 static void output_op_cbr(struct function *fn, struct instruction *br)
740 {
741 LLVMValueRef cond = bool_value(fn,
742 pseudo_to_value(fn, NULL, br->cond));
743
744 LLVMBuildCondBr(fn->builder, cond,
745 br->bb_true->priv,
746 br->bb_false->priv);
747 }
748
749 static void output_op_br(struct function *fn, struct instruction *br)
750 {
751 LLVMBuildBr(fn->builder, br->bb_true->priv);
752 }
753
754 static void output_op_sel(struct function *fn, struct instruction *insn)
755 {
756 LLVMValueRef target, src1, src2, src3;
757 char name[MAX_PSEUDO_NAME];
758
759 src1 = bool_value(fn, pseudo_to_value(fn, NULL, insn->src1));
760 src2 = get_operand(fn, insn->type, insn->src2);
761 src3 = get_operand(fn, insn->type, insn->src3);
762
763 pseudo_name(insn->target, name);
764 target = LLVMBuildSelect(fn->builder, src1, src2, src3, name);
765
766 insn->target->priv = adjust_type(fn, insn->type, target);
767 }
768
769 static void output_op_switch(struct function *fn, struct instruction *insn)
770 {
771 LLVMValueRef sw_val, target;
772 struct basic_block *def = NULL;
773 struct multijmp *jmp;
774 int n_jmp = 0;
775
776 FOR_EACH_PTR(insn->multijmp_list, jmp) {
777 if (jmp->begin <= jmp->end) {
778 n_jmp += (jmp->end - jmp->begin) + 1;
779 } else /* default case */
780 def = jmp->target;
781 } END_FOR_EACH_PTR(jmp);
782
783 sw_val = get_ioperand(fn, insn->type, insn->cond);
784 target = LLVMBuildSwitch(fn->builder, sw_val,
785 def ? def->priv : NULL, n_jmp);
786
787 FOR_EACH_PTR(insn->multijmp_list, jmp) {
788 long long val;
789
790 for (val = jmp->begin; val <= jmp->end; val++) {
791 LLVMValueRef Val = val_to_value(val, insn->type);
792 LLVMAddCase(target, Val, jmp->target->priv);
793 }
794 } END_FOR_EACH_PTR(jmp);
795 }
796
797 static void output_op_call(struct function *fn, struct instruction *insn)
798 {
799 LLVMValueRef target, func;
800 struct symbol *ctype;
801 int n_arg = 0, i;
802 struct pseudo *arg;
803 LLVMValueRef *args;
804 char name[64];
805
806 n_arg = pseudo_list_size(insn->arguments);
807 args = calloc(n_arg, sizeof(LLVMValueRef));
808
809 PREPARE_PTR_LIST(insn->fntypes, ctype);
810 if (insn->func->type == PSEUDO_REG || insn->func->type == PSEUDO_PHI)
811 func = get_operand(fn, ctype, insn->func);
812 else
813 func = pseudo_to_value(fn, ctype, insn->func);
814 i = 0;
815 FOR_EACH_PTR(insn->arguments, arg) {
816 NEXT_PTR_LIST(ctype);
817 args[i++] = pseudo_to_rvalue(fn, ctype, arg);
818 } END_FOR_EACH_PTR(arg);
819 FINISH_PTR_LIST(ctype);
820
821 pseudo_name(insn->target, name);
822 target = LLVMBuildCall(fn->builder, func, args, n_arg, name);
823
824 insn->target->priv = target;
825 }
826
827 static void output_op_phisrc(struct function *fn, struct instruction *insn)
828 {
829 LLVMValueRef v;
830 struct instruction *phi;
831
832 assert(insn->target->priv == NULL);
833
834 /* target = src */
835 v = get_operand(fn, insn->type, insn->phi_src);
836
837 FOR_EACH_PTR(insn->phi_users, phi) {
838 LLVMValueRef load, ptr;
839
840 assert(phi->opcode == OP_PHI);
841 /* phi must be load from alloca */
842 load = phi->target->priv;
843 assert(LLVMGetInstructionOpcode(load) == LLVMLoad);
844 ptr = LLVMGetOperand(load, 0);
845 /* store v to alloca */
846 LLVMBuildStore(fn->builder, v, ptr);
847 } END_FOR_EACH_PTR(phi);
848 }
849
850 static void output_op_phi(struct function *fn, struct instruction *insn)
851 {
852 LLVMValueRef load = insn->target->priv;
853
854 /* forward load */
855 assert(LLVMGetInstructionOpcode(load) == LLVMLoad);
856 /* forward load has no parent block */
857 assert(!LLVMGetInstructionParent(load));
858 /* finalize load in current block */
859 LLVMInsertIntoBuilder(fn->builder, load);
860 }
861
862 static void output_op_ptrcast(struct function *fn, struct instruction *insn)
863 {
864 LLVMValueRef src, target;
865 LLVMTypeRef dtype;
866 struct symbol *otype = insn->orig_type;
867 LLVMOpcode op;
868 char target_name[64];
869
870 src = get_operand(fn, otype, insn->src);
871 pseudo_name(insn->target, target_name);
872
873 dtype = symbol_type(insn->type);
874 switch (insn->opcode) {
875 case OP_UTPTR:
876 case OP_SEXT: // FIXME
877 assert(is_int_type(otype));
878 assert(is_ptr_type(insn->type));
879 op = LLVMIntToPtr;
880 break;
881 case OP_PTRTU:
882 assert(is_ptr_type(otype));
883 assert(is_int_type(insn->type));
884 op = LLVMPtrToInt;
885 break;
886 case OP_PTRCAST:
887 case OP_ZEXT: // FIXME
888 assert(is_ptr_type(otype));
889 assert(is_ptr_type(insn->type));
890 op = LLVMBitCast;
891 break;
892 default:
893 assert(0);
894 }
895
896 target = LLVMBuildCast(fn->builder, op, src, dtype, target_name);
897 insn->target->priv = target;
898 }
899
900 static void output_op_cast(struct function *fn, struct instruction *insn, LLVMOpcode op)
901 {
902 LLVMValueRef src, target;
903 LLVMTypeRef dtype;
904 struct symbol *otype = insn->orig_type;
905 char target_name[64];
906
907 if (is_ptr_type(insn->type)) // cast to void* is OP_CAST ...
908 return output_op_ptrcast(fn, insn);
909
910 assert(is_int_type(insn->type));
911
912 src = get_operand(fn, otype, insn->src);
913 pseudo_name(insn->target, target_name);
914
915 dtype = symbol_type(insn->type);
916 if (is_ptr_type(otype)) {
917 op = LLVMPtrToInt;
918 } else if (is_float_type(otype)) {
919 assert(op == LLVMFPToUI || op == LLVMFPToSI);
920 } else if (is_int_type(otype)) {
921 unsigned int width = otype->bit_size;
922 if (insn->size < width)
923 op = LLVMTrunc;
924 else if (insn->size == width)
925 op = LLVMBitCast;
926 } else {
927 assert(0);
928 }
929
930 target = LLVMBuildCast(fn->builder, op, src, dtype, target_name);
931 insn->target->priv = target;
932 }
933
934 static void output_op_fpcast(struct function *fn, struct instruction *insn)
935 {
936 LLVMTypeRef dtype = symbol_type(insn->type);
937 LLVMValueRef src, target;
938 struct symbol *otype = insn->orig_type;
939 char name[64];
940
941 assert(is_float_type(insn->type));
942
943 pseudo_name(insn->target, name);
944 src = get_operand(fn, otype, insn->src);
945 switch (insn->opcode) {
946 case OP_FCVTF:
947 target = LLVMBuildFPCast(fn->builder, src, dtype, name);
948 break;
949 case OP_SCVTF:
950 target = LLVMBuildSIToFP(fn->builder, src, dtype, name);
951 break;
952 case OP_UCVTF:
953 target = LLVMBuildUIToFP(fn->builder, src, dtype, name);
954 break;
955 default:
956 assert(0);
957 }
958 insn->target->priv = target;
959 }
960
961 static void output_op_setval(struct function *fn, struct instruction *insn)
962 {
963 struct expression *val = insn->val;
964 LLVMValueRef target;
965
966 switch (val->type) {
967 case EXPR_LABEL:
968 target = LLVMBlockAddress(fn->fn, val->symbol->bb_target->priv);
969 break;
970 default:
971 assert(0);
972 }
973
974 insn->target->priv = target;
975 }
976
977 static void output_op_setfval(struct function *fn, struct instruction *insn)
978 {
979 LLVMTypeRef dtype = symbol_type(insn->type);
980 LLVMValueRef target;
981
982 target = LLVMConstReal(dtype, insn->fvalue);
983 insn->target->priv = target;
984 }
985
986 static void output_insn(struct function *fn, struct instruction *insn)
987 {
988 switch (insn->opcode) {
989 case OP_RET:
990 output_op_ret(fn, insn);
991 break;
992 case OP_BR:
993 output_op_br(fn, insn);
994 break;
995 case OP_CBR:
996 output_op_cbr(fn, insn);
997 break;
998 case OP_SYMADDR:
999 assert(0);
1000 break;
1001 case OP_SETVAL:
1002 output_op_setval(fn, insn);
1003 break;
1004 case OP_SETFVAL:
1005 output_op_setfval(fn, insn);
1006 break;
1007 case OP_SWITCH:
1008 output_op_switch(fn, insn);
1009 break;
1010 case OP_COMPUTEDGOTO:
1011 assert(0);
1012 break;
1013 case OP_PHISOURCE:
1014 output_op_phisrc(fn, insn);
1015 break;
1016 case OP_PHI:
1017 output_op_phi(fn, insn);
1018 break;
1019 case OP_LOAD:
1020 output_op_load(fn, insn);
1021 break;
1022 case OP_STORE:
1023 output_op_store(fn, insn);
1024 break;
1025 case OP_INLINED_CALL:
1026 break;
1027 case OP_CALL:
1028 output_op_call(fn, insn);
1029 break;
1030 case OP_ZEXT:
1031 output_op_cast(fn, insn, LLVMZExt);
1032 break;
1033 case OP_SEXT:
1034 output_op_cast(fn, insn, LLVMSExt);
1035 break;
1036 case OP_TRUNC:
1037 output_op_cast(fn, insn, LLVMTrunc);
1038 break;
1039 case OP_FCVTU:
1040 output_op_cast(fn, insn, LLVMFPToUI);
1041 break;
1042 case OP_FCVTS:
1043 output_op_cast(fn, insn, LLVMFPToSI);
1044 break;
1045 case OP_UCVTF: case OP_SCVTF:
1046 case OP_FCVTF:
1047 output_op_fpcast(fn, insn);
1048 break;
1049 case OP_UTPTR:
1050 case OP_PTRTU:
1051 case OP_PTRCAST:
1052 output_op_ptrcast(fn, insn);
1053 break;
1054 case OP_BINARY ... OP_BINARY_END:
1055 output_op_binary(fn, insn);
1056 break;
1057 case OP_FPCMP ... OP_BINCMP_END:
1058 output_op_compare(fn, insn);
1059 break;
1060 case OP_SEL:
1061 output_op_sel(fn, insn);
1062 break;
1063 case OP_SLICE:
1064 assert(0);
1065 break;
1066 case OP_NOT: {
1067 LLVMValueRef src, target;
1068 char target_name[64];
1069
1070 src = pseudo_to_value(fn, insn->type, insn->src);
1071
1072 pseudo_name(insn->target, target_name);
1073
1074 target = LLVMBuildNot(fn->builder, src, target_name);
1075
1076 insn->target->priv = target;
1077 break;
1078 }
1079 case OP_FNEG:
1080 case OP_NEG: {
1081 LLVMValueRef src, target;
1082 char target_name[64];
1083
1084 src = pseudo_to_value(fn, insn->type, insn->src);
1085
1086 pseudo_name(insn->target, target_name);
1087
1088 if (insn->opcode == OP_FNEG)
1089 target = LLVMBuildFNeg(fn->builder, src, target_name);
1090 else
1091 target = LLVMBuildNeg(fn->builder, src, target_name);
1092
1093 insn->target->priv = target;
1094 break;
1095 }
1096 case OP_CONTEXT:
1097 assert(0);
1098 break;
1099 case OP_RANGE:
1100 assert(0);
1101 break;
1102 case OP_NOP:
1103 assert(0);
1104 break;
1105 case OP_DEATHNOTE:
1106 break;
1107 case OP_ASM:
1108 assert(0);
1109 break;
1110 case OP_COPY:
1111 assert(0);
1112 break;
1113 default:
1114 break;
1115 }
1116 }
1117
1118 static void output_bb(struct function *fn, struct basic_block *bb)
1119 {
1120 struct instruction *insn;
1121
1122 FOR_EACH_PTR(bb->insns, insn) {
1123 if (!insn->bb)
1124 continue;
1125
1126 output_insn(fn, insn);
1127 }
1128 END_FOR_EACH_PTR(insn);
1129 }
1130
1131 #define MAX_ARGS 64
1132
1133 static void output_fn(LLVMModuleRef module, struct entrypoint *ep)
1134 {
1135 struct symbol *sym = ep->name;
1136 struct symbol *base_type = sym->ctype.base_type;
1137 struct function function = { .module = module };
1138 struct basic_block *bb;
1139 int nr_args = 0;
1140 int i;
1141
1142 function.fn = get_sym_value(module, sym);
1143 LLVMSetFunctionCallConv(function.fn, LLVMCCallConv);
1144 LLVMSetLinkage(function.fn, function_linkage(sym));
1145
1146 function.builder = LLVMCreateBuilder();
1147
1148 /* give a name to each argument */
1149 nr_args = symbol_list_size(base_type->arguments);
1150 for (i = 0; i < nr_args; i++) {
1151 char name[MAX_PSEUDO_NAME];
1152 LLVMValueRef arg;
1153
1154 arg = LLVMGetParam(function.fn, i);
1155 snprintf(name, sizeof(name), "ARG%d.", i+1);
1156 LLVMSetValueName(arg, name);
1157 }
1158
1159 /* create the BBs */
1160 FOR_EACH_PTR(ep->bbs, bb) {
1161 static int nr_bb;
1162 LLVMBasicBlockRef bbr;
1163 char bbname[32];
1164 struct instruction *insn;
1165
1166 sprintf(bbname, "L%d", nr_bb++);
1167 bbr = LLVMAppendBasicBlock(function.fn, bbname);
1168
1169 bb->priv = bbr;
1170
1171 /* allocate alloca for each phi */
1172 FOR_EACH_PTR(bb->insns, insn) {
1173 LLVMBasicBlockRef entrybbr;
1174 LLVMTypeRef phi_type;
1175 LLVMValueRef ptr;
1176
1177 if (!insn->bb || insn->opcode != OP_PHI)
1178 continue;
1179 /* insert alloca into entry block */
1180 entrybbr = LLVMGetEntryBasicBlock(function.fn);
1181 LLVMPositionBuilderAtEnd(function.builder, entrybbr);
1182 phi_type = insn_symbol_type(insn);
1183 ptr = LLVMBuildAlloca(function.builder, phi_type, "");
1184 /* emit forward load for phi */
1185 LLVMClearInsertionPosition(function.builder);
1186 insn->target->priv = LLVMBuildLoad(function.builder, ptr, "phi");
1187 } END_FOR_EACH_PTR(insn);
1188 }
1189 END_FOR_EACH_PTR(bb);
1190
1191 FOR_EACH_PTR(ep->bbs, bb) {
1192 LLVMPositionBuilderAtEnd(function.builder, bb->priv);
1193
1194 output_bb(&function, bb);
1195 }
1196 END_FOR_EACH_PTR(bb);
1197 }
1198
1199 static LLVMValueRef output_data(LLVMModuleRef module, struct symbol *sym)
1200 {
1201 struct expression *initializer = sym->initializer;
1202 LLVMValueRef initial_value;
1203 LLVMValueRef data;
1204 const char *name;
1205
1206 if (initializer) {
1207 switch (initializer->type) {
1208 case EXPR_VALUE:
1209 initial_value = LLVMConstInt(symbol_type(sym), initializer->value, 1);
1210 break;
1211 case EXPR_FVALUE:
1212 initial_value = LLVMConstReal(symbol_type(sym), initializer->fvalue);
1213 break;
1214 case EXPR_SYMBOL: {
1215 struct symbol *sym = initializer->symbol;
1216
1217 initial_value = LLVMGetNamedGlobal(module, show_ident(sym->ident));
1218 if (!initial_value)
1219 initial_value = output_data(module, sym);
1220 break;
1221 }
1222 case EXPR_STRING: {
1223 const char *s = initializer->string->data;
1224
1225 initial_value = LLVMConstString(strdup(s), strlen(s) + 1, true);
1226 break;
1227 }
1228 default:
1229 warning(initializer->pos, "can't initialize type: %s", show_typename(sym));
1230 initial_value = NULL;
1231 break;
1232 }
1233 } else {
1234 LLVMTypeRef type = symbol_type(sym);
1235
1236 initial_value = LLVMConstNull(type);
1237 }
1238
1239 if (!initial_value)
1240 return NULL;
1241
1242 name = sym->ident ? show_ident(sym->ident) : "" ;
1243
1244 data = LLVMAddGlobal(module, LLVMTypeOf(initial_value), name);
1245
1246 LLVMSetLinkage(data, data_linkage(sym));
1247 if (sym->ctype.modifiers & MOD_CONST)
1248 LLVMSetGlobalConstant(data, 1);
1249 if (sym->ctype.modifiers & MOD_TLS)
1250 LLVMSetThreadLocal(data, 1);
1251 if (sym->ctype.alignment)
1252 LLVMSetAlignment(data, sym->ctype.alignment);
1253
1254 if (!(sym->ctype.modifiers & MOD_EXTERN))
1255 LLVMSetInitializer(data, initial_value);
1256
1257 return data;
1258 }
1259
1260 static int is_prototype(struct symbol *sym)
1261 {
1262 if (sym->type == SYM_NODE)
1263 sym = sym->ctype.base_type;
1264 return sym && sym->type == SYM_FN && !sym->stmt;
1265 }
1266
1267 static int compile(LLVMModuleRef module, struct symbol_list *list)
1268 {
1269 struct symbol *sym;
1270
1271 FOR_EACH_PTR(list, sym) {
1272 struct entrypoint *ep;
1273 expand_symbol(sym);
1274
1275 if (is_prototype(sym)) {
1276 // this will do the LLVMAddFunction() we want
1277 get_sym_value(module, sym);
1278 continue;
1279 }
1280
1281 ep = linearize_symbol(sym);
1282 if (ep)
1283 output_fn(module, ep);
1284 else
1285 output_data(module, sym);
1286 }
1287 END_FOR_EACH_PTR(sym);
1288
1289 return 0;
1290 }
1291
1292 #ifndef LLVM_DEFAULT_TARGET_TRIPLE
1293 #define LLVM_DEFAULT_TARGET_TRIPLE LLVM_HOSTTRIPLE
1294 #endif
1295
1296 #define X86_LINUX_LAYOUT \
1297 "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-" \
1298 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-" \
1299 "a0:0:64-f80:32:32-n8:16:32-S128"
1336 LLVMSetTarget(module, triple);
1337 LLVMSetDataLayout(module, layout);
1338 }
1339
1340 int main(int argc, char **argv)
1341 {
1342 struct string_list *filelist = NULL;
1343 struct symbol_list *symlist;
1344 LLVMModuleRef module;
1345 char *file;
1346
1347 symlist = sparse_initialize(argc, argv, &filelist);
1348
1349 module = LLVMModuleCreateWithName("sparse");
1350 set_target(module);
1351
1352 compile(module, symlist);
1353
1354 /* need ->phi_users */
1355 dbg_dead = 1;
1356 FOR_EACH_PTR(filelist, file) {
1357 symlist = sparse(file);
1358 if (die_if_error)
1359 return 1;
1360 compile(module, symlist);
1361 } END_FOR_EACH_PTR(file);
1362
1363 LLVMVerifyModule(module, LLVMPrintMessageAction, NULL);
1364
1365 LLVMWriteBitcodeToFD(module, STDOUT_FILENO, 0, 0);
1366
1367 LLVMDisposeModule(module);
1368
1369 report_stats();
1370 return 0;
1371 }
|