3 * ./sparse-llvm hello.c | llc | as -o hello.o
6 #include <llvm-c/Core.h>
7 #include <llvm-c/BitWriter.h>
8 #include <llvm-c/Analysis.h>
9 #include <llvm-c/Target.h>
18 #include "expression.h"
19 #include "linearize.h"
23 LLVMBuilderRef builder
;
28 static LLVMTypeRef
symbol_type(struct symbol
*sym
);
30 static LLVMTypeRef
func_return_type(struct symbol
*sym
)
32 if (sym
->type
== SYM_NODE
)
33 sym
= sym
->ctype
.base_type
;
34 return symbol_type(sym
->ctype
.base_type
);
37 // A call can be done either with a SYM_FN or a SYM_PTR (pointing to a SYM_FN).
38 // Return the type corresponding to the SYM_FN.
39 static LLVMTypeRef
func_full_type(struct symbol
*type
)
41 if (type
->type
== SYM_NODE
) {
42 struct symbol
*btype
= type
->ctype
.base_type
;
43 if (btype
->type
== SYM_PTR
)
44 type
= btype
->ctype
.base_type
;
46 return symbol_type(type
);
49 static LLVMTypeRef
sym_func_type(struct symbol
*sym
)
51 int n_arg
= symbol_list_size(sym
->arguments
);
52 LLVMTypeRef
*arg_type
= calloc(n_arg
, sizeof(LLVMTypeRef
));
53 LLVMTypeRef ret_type
= func_return_type(sym
);
57 FOR_EACH_PTR(sym
->arguments
, arg
) {
58 struct symbol
*arg_sym
= arg
->ctype
.base_type
;
60 arg_type
[idx
++] = symbol_type(arg_sym
);
61 } END_FOR_EACH_PTR(arg
);
63 return LLVMFunctionType(ret_type
, arg_type
, n_arg
, sym
->variadic
);
66 static LLVMTypeRef
sym_array_type(struct symbol
*sym
)
68 LLVMTypeRef elem_type
;
69 struct symbol
*base_type
;
71 base_type
= sym
->ctype
.base_type
;
72 /* empty struct is undefined [6.7.2.1(8)] */
73 assert(base_type
->bit_size
> 0);
75 elem_type
= symbol_type(base_type
);
79 return LLVMArrayType(elem_type
, sym
->bit_size
/ base_type
->bit_size
);
82 #define MAX_STRUCT_MEMBERS 64
84 static LLVMTypeRef
sym_struct_type(struct symbol
*sym
)
86 LLVMTypeRef elem_types
[MAX_STRUCT_MEMBERS
];
87 struct symbol
*member
;
92 snprintf(buffer
, sizeof(buffer
), "struct.%s", sym
->ident
? sym
->ident
->name
: "anno");
93 ret
= LLVMStructCreateNamed(LLVMGetGlobalContext(), buffer
);
94 /* set ->aux to avoid recursion */
97 FOR_EACH_PTR(sym
->symbol_list
, member
) {
98 LLVMTypeRef member_type
;
100 assert(nr
< MAX_STRUCT_MEMBERS
);
102 member_type
= symbol_type(member
);
104 elem_types
[nr
++] = member_type
;
105 } END_FOR_EACH_PTR(member
);
107 LLVMStructSetBody(ret
, elem_types
, nr
, 0 /* packed? */);
111 static LLVMTypeRef
sym_union_type(struct symbol
*sym
)
113 LLVMTypeRef elements
;
117 * There's no union support in the LLVM API so we treat unions as
118 * opaque structs. The downside is that we lose type information on the
119 * members but as LLVM doesn't care, neither do we.
121 union_size
= sym
->bit_size
/ 8;
123 elements
= LLVMArrayType(LLVMInt8Type(), union_size
);
125 return LLVMStructType(&elements
, 1, 0 /* packed? */);
128 static LLVMTypeRef
sym_ptr_type(struct symbol
*sym
)
132 /* 'void *' is treated like 'char *' */
133 if (is_void_type(sym
->ctype
.base_type
))
134 type
= LLVMInt8Type();
136 type
= symbol_type(sym
->ctype
.base_type
);
138 return LLVMPointerType(type
, 0);
141 static LLVMTypeRef
sym_basetype_type(struct symbol
*sym
)
143 LLVMTypeRef ret
= NULL
;
145 if (is_float_type(sym
)) {
146 switch (sym
->bit_size
) {
148 ret
= LLVMFloatType();
151 ret
= LLVMDoubleType();
154 ret
= LLVMX86FP80Type();
157 die("invalid bit size %d for type %d", sym
->bit_size
, sym
->type
);
161 switch (sym
->bit_size
) {
163 ret
= LLVMVoidType();
166 ret
= LLVMInt1Type();
169 ret
= LLVMInt8Type();
172 ret
= LLVMInt16Type();
175 ret
= LLVMInt32Type();
178 ret
= LLVMInt64Type();
181 die("invalid bit size %d for type %d", sym
->bit_size
, sym
->type
);
189 static LLVMTypeRef
symbol_type(struct symbol
*sym
)
191 LLVMTypeRef ret
= NULL
;
193 /* don't cache the result for SYM_NODE */
194 if (sym
->type
== SYM_NODE
)
195 return symbol_type(sym
->ctype
.base_type
);
202 ret
= LLVMIntType(sym
->bit_size
);
206 ret
= symbol_type(sym
->ctype
.base_type
);
209 ret
= sym_basetype_type(sym
);
212 ret
= sym_ptr_type(sym
);
215 ret
= sym_union_type(sym
);
218 ret
= sym_struct_type(sym
);
221 ret
= sym_array_type(sym
);
224 ret
= sym_func_type(sym
);
230 /* cache the result */
235 static LLVMTypeRef
insn_symbol_type(struct instruction
*insn
)
238 return symbol_type(insn
->type
);
240 switch (insn
->size
) {
241 case 8: return LLVMInt8Type();
242 case 16: return LLVMInt16Type();
243 case 32: return LLVMInt32Type();
244 case 64: return LLVMInt64Type();
247 die("invalid bit size %d", insn
->size
);
251 return NULL
; /* not reached */
254 static LLVMLinkage
data_linkage(struct symbol
*sym
)
256 if (sym
->ctype
.modifiers
& MOD_STATIC
)
257 return LLVMPrivateLinkage
;
259 return LLVMExternalLinkage
;
262 static LLVMLinkage
function_linkage(struct symbol
*sym
)
264 if (sym
->ctype
.modifiers
& MOD_STATIC
)
265 return LLVMInternalLinkage
;
267 return LLVMExternalLinkage
;
270 #define MAX_PSEUDO_NAME 64
272 static const char *pseudo_name(pseudo_t pseudo
, char *buf
)
274 switch (pseudo
->type
) {
276 snprintf(buf
, MAX_PSEUDO_NAME
, "R%d.", pseudo
->nr
);
279 snprintf(buf
, MAX_PSEUDO_NAME
, "PHI%d.", pseudo
->nr
);
297 static LLVMValueRef
get_sym_value(LLVMModuleRef module
, struct symbol
*sym
)
299 const char *name
= show_ident(sym
->ident
);
300 LLVMTypeRef type
= symbol_type(sym
);
301 LLVMValueRef result
= NULL
;
302 struct expression
*expr
;
304 assert(sym
->bb_target
== NULL
);
306 expr
= sym
->initializer
;
307 if (expr
&& !sym
->ident
) {
308 switch (expr
->type
) {
310 const char *s
= expr
->string
->data
;
311 size_t len
= expr
->string
->length
;
312 LLVMValueRef indices
[] = { LLVMConstInt(LLVMInt64Type(), 0, 0), LLVMConstInt(LLVMInt64Type(), 0, 0) };
315 data
= LLVMAddGlobal(module
, LLVMArrayType(LLVMInt8Type(), len
), ".str");
316 LLVMSetLinkage(data
, LLVMPrivateLinkage
);
317 LLVMSetGlobalConstant(data
, 1);
318 LLVMSetInitializer(data
, LLVMConstString(s
, len
, true));
320 #if LLVM_VERSION_MAJOR > 14
321 result
= LLVMConstGEP2(LLVMTypeOf(data
), data
, indices
, ARRAY_SIZE(indices
));
323 result
= LLVMConstGEP(data
, indices
, ARRAY_SIZE(indices
));
332 if (LLVMGetTypeKind(type
) == LLVMFunctionTypeKind
) {
333 result
= LLVMGetNamedFunction(module
, name
);
335 result
= LLVMAddFunction(module
, name
, type
);
337 result
= LLVMGetNamedGlobal(module
, name
);
339 result
= LLVMAddGlobal(module
, type
, name
);
345 static LLVMValueRef
constant_value(unsigned long long val
, LLVMTypeRef dtype
)
349 switch (LLVMGetTypeKind(dtype
)) {
350 case LLVMPointerTypeKind
:
351 if (val
!= 0) { // for example: ... = (void*) 0x123;
352 LLVMTypeRef itype
= LLVMIntType(bits_in_pointer
);
353 result
= LLVMConstInt(itype
, val
, 1);
354 result
= LLVMConstIntToPtr(result
, dtype
);
356 result
= LLVMConstPointerNull(dtype
);
359 case LLVMIntegerTypeKind
:
360 result
= LLVMConstInt(dtype
, val
, 1);
362 case LLVMArrayTypeKind
:
363 case LLVMStructTypeKind
:
366 result
= LLVMConstNull(dtype
);
374 static LLVMValueRef
val_to_value(unsigned long long val
, struct symbol
*ctype
)
380 dtype
= symbol_type(ctype
);
381 result
= constant_value(val
, dtype
);
384 sparse_error(ctype
->pos
, "no value possible for %s", show_typename(ctype
));
385 return LLVMGetUndef(symbol_type(ctype
));
388 static LLVMValueRef
pseudo_to_value(struct function
*fn
, struct symbol
*ctype
, pseudo_t pseudo
)
390 LLVMValueRef result
= NULL
;
392 switch (pseudo
->type
) {
394 result
= pseudo
->priv
;
397 result
= get_sym_value(fn
->module
, pseudo
->sym
);
400 result
= val_to_value(pseudo
->value
, ctype
);
403 result
= LLVMGetParam(fn
->fn
, pseudo
->nr
- 1);
407 result
= pseudo
->priv
;
413 result
= LLVMGetUndef(symbol_type(ctype
));
422 static LLVMValueRef
pseudo_to_rvalue(struct function
*fn
, struct symbol
*ctype
, pseudo_t pseudo
)
424 LLVMValueRef val
= pseudo_to_value(fn
, ctype
, pseudo
);
425 LLVMTypeRef dtype
= symbol_type(ctype
);
426 char name
[MAX_PSEUDO_NAME
];
428 pseudo_name(pseudo
, name
);
429 return LLVMBuildBitCast(fn
->builder
, val
, dtype
, name
);
432 static LLVMValueRef
value_to_ivalue(struct function
*fn
, struct symbol
*ctype
, LLVMValueRef val
)
434 const char *name
= LLVMGetValueName(val
);
435 LLVMTypeRef dtype
= symbol_type(ctype
);
437 if (LLVMGetTypeKind(LLVMTypeOf(val
)) == LLVMPointerTypeKind
) {
438 LLVMTypeRef dtype
= LLVMIntType(bits_in_pointer
);
439 val
= LLVMBuildPtrToInt(fn
->builder
, val
, dtype
, name
);
441 if (ctype
&& is_int_type(ctype
)) {
442 val
= LLVMBuildIntCast(fn
->builder
, val
, dtype
, name
);
447 static LLVMValueRef
value_to_pvalue(struct function
*fn
, struct symbol
*ctype
, LLVMValueRef val
)
449 const char *name
= LLVMGetValueName(val
);
450 LLVMTypeRef dtype
= symbol_type(ctype
);
452 assert(is_ptr_type(ctype
));
453 switch (LLVMGetTypeKind(LLVMTypeOf(val
))) {
454 case LLVMIntegerTypeKind
:
455 val
= LLVMBuildIntToPtr(fn
->builder
, val
, dtype
, name
);
457 case LLVMPointerTypeKind
:
458 val
= LLVMBuildBitCast(fn
->builder
, val
, dtype
, name
);
466 static LLVMValueRef
adjust_type(struct function
*fn
, struct symbol
*ctype
, LLVMValueRef val
)
468 if (is_int_type(ctype
))
469 return value_to_ivalue(fn
, ctype
, val
);
470 if (is_ptr_type(ctype
))
471 return value_to_pvalue(fn
, ctype
, val
);
476 * Get the LLVMValue corresponding to the pseudo
477 * and force the type corresponding to ctype.
479 static LLVMValueRef
get_operand(struct function
*fn
, struct symbol
*ctype
, pseudo_t pseudo
)
481 LLVMValueRef target
= pseudo_to_value(fn
, ctype
, pseudo
);
482 return adjust_type(fn
, ctype
, target
);
486 * Get the LLVMValue corresponding to the pseudo
487 * and force the type corresponding to ctype but
488 * map all pointers to intptr_t.
490 static LLVMValueRef
get_ioperand(struct function
*fn
, struct symbol
*ctype
, pseudo_t pseudo
)
492 LLVMValueRef target
= pseudo_to_value(fn
, ctype
, pseudo
);
493 return value_to_ivalue(fn
, ctype
, target
);
496 static LLVMValueRef
calc_gep(LLVMBuilderRef builder
, LLVMValueRef base
, LLVMValueRef off
)
498 LLVMTypeRef type
= LLVMTypeOf(base
);
499 unsigned int as
= LLVMGetPointerAddressSpace(type
);
500 LLVMTypeRef bytep
= LLVMPointerType(LLVMInt8Type(), as
);
502 const char *name
= LLVMGetValueName(off
);
504 /* convert base to char* type */
505 base
= LLVMBuildPointerCast(builder
, base
, bytep
, name
);
506 /* addr = base + off */
507 #if LLVM_VERSION_MAJOR > 14
508 addr
= LLVMBuildInBoundsGEP2(builder
, LLVMTypeOf(base
), base
, &off
, 1, name
);
510 addr
= LLVMBuildInBoundsGEP(builder
, base
, &off
, 1, name
);
512 /* convert back to the actual pointer type */
513 addr
= LLVMBuildPointerCast(builder
, addr
, type
, name
);
517 static LLVMRealPredicate
translate_fop(int opcode
)
519 static const LLVMRealPredicate trans_tbl
[] = {
520 [OP_FCMP_ORD
] = LLVMRealORD
,
521 [OP_FCMP_OEQ
] = LLVMRealOEQ
,
522 [OP_FCMP_ONE
] = LLVMRealONE
,
523 [OP_FCMP_OLE
] = LLVMRealOLE
,
524 [OP_FCMP_OGE
] = LLVMRealOGE
,
525 [OP_FCMP_OLT
] = LLVMRealOLT
,
526 [OP_FCMP_OGT
] = LLVMRealOGT
,
527 [OP_FCMP_UEQ
] = LLVMRealUEQ
,
528 [OP_FCMP_UNE
] = LLVMRealUNE
,
529 [OP_FCMP_ULE
] = LLVMRealULE
,
530 [OP_FCMP_UGE
] = LLVMRealUGE
,
531 [OP_FCMP_ULT
] = LLVMRealULT
,
532 [OP_FCMP_UGT
] = LLVMRealUGT
,
533 [OP_FCMP_UNO
] = LLVMRealUNO
,
536 return trans_tbl
[opcode
];
539 static LLVMIntPredicate
translate_op(int opcode
)
541 static const LLVMIntPredicate trans_tbl
[] = {
542 [OP_SET_EQ
] = LLVMIntEQ
,
543 [OP_SET_NE
] = LLVMIntNE
,
544 [OP_SET_LE
] = LLVMIntSLE
,
545 [OP_SET_GE
] = LLVMIntSGE
,
546 [OP_SET_LT
] = LLVMIntSLT
,
547 [OP_SET_GT
] = LLVMIntSGT
,
548 [OP_SET_B
] = LLVMIntULT
,
549 [OP_SET_A
] = LLVMIntUGT
,
550 [OP_SET_BE
] = LLVMIntULE
,
551 [OP_SET_AE
] = LLVMIntUGE
,
554 return trans_tbl
[opcode
];
557 static void output_op_binary(struct function
*fn
, struct instruction
*insn
)
559 LLVMValueRef lhs
, rhs
, target
;
560 char target_name
[64];
562 lhs
= get_ioperand(fn
, insn
->type
, insn
->src1
);
563 rhs
= get_ioperand(fn
, insn
->type
, insn
->src2
);
565 pseudo_name(insn
->target
, target_name
);
567 switch (insn
->opcode
) {
570 target
= LLVMBuildAdd(fn
->builder
, lhs
, rhs
, target_name
);
573 target
= LLVMBuildSub(fn
->builder
, lhs
, rhs
, target_name
);
576 target
= LLVMBuildMul(fn
->builder
, lhs
, rhs
, target_name
);
579 target
= LLVMBuildUDiv(fn
->builder
, lhs
, rhs
, target_name
);
582 assert(!is_float_type(insn
->type
));
583 target
= LLVMBuildSDiv(fn
->builder
, lhs
, rhs
, target_name
);
586 assert(!is_float_type(insn
->type
));
587 target
= LLVMBuildURem(fn
->builder
, lhs
, rhs
, target_name
);
590 assert(!is_float_type(insn
->type
));
591 target
= LLVMBuildSRem(fn
->builder
, lhs
, rhs
, target_name
);
594 assert(!is_float_type(insn
->type
));
595 target
= LLVMBuildShl(fn
->builder
, lhs
, rhs
, target_name
);
598 assert(!is_float_type(insn
->type
));
599 target
= LLVMBuildLShr(fn
->builder
, lhs
, rhs
, target_name
);
602 assert(!is_float_type(insn
->type
));
603 target
= LLVMBuildAShr(fn
->builder
, lhs
, rhs
, target_name
);
608 target
= LLVMBuildFAdd(fn
->builder
, lhs
, rhs
, target_name
);
611 target
= LLVMBuildFSub(fn
->builder
, lhs
, rhs
, target_name
);
614 target
= LLVMBuildFMul(fn
->builder
, lhs
, rhs
, target_name
);
617 target
= LLVMBuildFDiv(fn
->builder
, lhs
, rhs
, target_name
);
622 assert(!is_float_type(insn
->type
));
623 target
= LLVMBuildAnd(fn
->builder
, lhs
, rhs
, target_name
);
626 assert(!is_float_type(insn
->type
));
627 target
= LLVMBuildOr(fn
->builder
, lhs
, rhs
, target_name
);
630 assert(!is_float_type(insn
->type
));
631 target
= LLVMBuildXor(fn
->builder
, lhs
, rhs
, target_name
);
638 target
= adjust_type(fn
, insn
->type
, target
);
639 insn
->target
->priv
= target
;
642 static void output_op_compare(struct function
*fn
, struct instruction
*insn
)
644 LLVMValueRef lhs
, rhs
, target
;
645 char target_name
[64];
647 lhs
= pseudo_to_value(fn
, NULL
, insn
->src1
);
648 if (insn
->src2
->type
== PSEUDO_VAL
)
649 rhs
= constant_value(insn
->src2
->value
, LLVMTypeOf(lhs
));
651 rhs
= pseudo_to_value(fn
, NULL
, insn
->src2
);
653 rhs
= LLVMGetUndef(symbol_type(insn
->type
));
655 pseudo_name(insn
->target
, target_name
);
657 LLVMTypeRef dst_type
= insn_symbol_type(insn
);
659 switch (LLVMGetTypeKind(LLVMTypeOf(lhs
))) {
660 case LLVMPointerTypeKind
:
661 lhs
= value_to_pvalue(fn
, &ptr_ctype
, lhs
);
662 rhs
= value_to_pvalue(fn
, &ptr_ctype
, rhs
);
665 case LLVMIntegerTypeKind
: {
666 LLVMIntPredicate op
= translate_op(insn
->opcode
);
668 if (LLVMGetTypeKind(LLVMTypeOf(rhs
)) == LLVMPointerTypeKind
) {
669 LLVMTypeRef ltype
= LLVMTypeOf(lhs
);
670 rhs
= LLVMBuildPtrToInt(fn
->builder
, rhs
, ltype
, "");
672 target
= LLVMBuildICmp(fn
->builder
, op
, lhs
, rhs
, target_name
);
675 case LLVMHalfTypeKind
:
676 case LLVMFloatTypeKind
:
677 case LLVMDoubleTypeKind
:
678 case LLVMX86_FP80TypeKind
:
679 case LLVMFP128TypeKind
:
680 case LLVMPPC_FP128TypeKind
: {
681 LLVMRealPredicate op
= translate_fop(insn
->opcode
);
683 target
= LLVMBuildFCmp(fn
->builder
, op
, lhs
, rhs
, target_name
);
690 target
= LLVMBuildZExt(fn
->builder
, target
, dst_type
, target_name
);
692 insn
->target
->priv
= target
;
695 static void output_op_ret(struct function
*fn
, struct instruction
*insn
)
697 pseudo_t pseudo
= insn
->src
;
699 if (pseudo
&& pseudo
!= VOID
) {
700 LLVMValueRef result
= get_operand(fn
, insn
->type
, pseudo
);
701 LLVMBuildRet(fn
->builder
, result
);
703 LLVMBuildRetVoid(fn
->builder
);
706 static LLVMValueRef
calc_memop_addr(struct function
*fn
, struct instruction
*insn
)
708 LLVMTypeRef int_type
, addr_type
;
709 LLVMValueRef src
, off
, addr
;
712 /* int type large enough to hold a pointer */
713 int_type
= LLVMIntType(bits_in_pointer
);
714 off
= LLVMConstInt(int_type
, insn
->offset
, 0);
716 /* convert src to the effective pointer type */
717 src
= pseudo_to_value(fn
, insn
->type
, insn
->src
);
718 as
= LLVMGetPointerAddressSpace(LLVMTypeOf(src
));
719 addr_type
= LLVMPointerType(insn_symbol_type(insn
), as
);
720 src
= LLVMBuildPointerCast(fn
->builder
, src
, addr_type
, LLVMGetValueName(src
));
722 /* addr = src + off */
723 addr
= calc_gep(fn
->builder
, src
, off
);
728 static void output_op_load(struct function
*fn
, struct instruction
*insn
)
730 LLVMValueRef addr
, target
;
731 char name
[MAX_PSEUDO_NAME
];
733 addr
= calc_memop_addr(fn
, insn
);
736 pseudo_name(insn
->target
, name
);
737 #if LLVM_VERSION_MAJOR > 14
738 target
= LLVMBuildLoad2(fn
->builder
, symbol_type(insn
->type
), addr
, name
);
740 target
= LLVMBuildLoad(fn
->builder
, addr
, name
);
743 insn
->target
->priv
= target
;
746 static void output_op_store(struct function
*fn
, struct instruction
*insn
)
748 LLVMValueRef addr
, target_in
;
750 addr
= calc_memop_addr(fn
, insn
);
752 target_in
= pseudo_to_rvalue(fn
, insn
->type
, insn
->target
);
755 LLVMBuildStore(fn
->builder
, target_in
, addr
);
758 static LLVMValueRef
bool_value(struct function
*fn
, LLVMValueRef value
)
760 if (LLVMTypeOf(value
) != LLVMInt1Type())
761 value
= LLVMBuildIsNotNull(fn
->builder
, value
, LLVMGetValueName(value
));
766 static void output_op_cbr(struct function
*fn
, struct instruction
*br
)
768 LLVMValueRef cond
= bool_value(fn
,
769 pseudo_to_value(fn
, NULL
, br
->cond
));
771 LLVMBuildCondBr(fn
->builder
, cond
,
776 static void output_op_br(struct function
*fn
, struct instruction
*br
)
778 LLVMBuildBr(fn
->builder
, br
->bb_true
->priv
);
781 static void output_op_sel(struct function
*fn
, struct instruction
*insn
)
783 LLVMValueRef target
, src1
, src2
, src3
;
784 char name
[MAX_PSEUDO_NAME
];
786 src1
= bool_value(fn
, pseudo_to_value(fn
, NULL
, insn
->src1
));
787 src2
= get_operand(fn
, insn
->type
, insn
->src2
);
788 src3
= get_operand(fn
, insn
->type
, insn
->src3
);
790 pseudo_name(insn
->target
, name
);
791 target
= LLVMBuildSelect(fn
->builder
, src1
, src2
, src3
, name
);
793 insn
->target
->priv
= adjust_type(fn
, insn
->type
, target
);
796 static void output_op_switch(struct function
*fn
, struct instruction
*insn
)
798 LLVMValueRef sw_val
, target
;
799 struct basic_block
*def
= NULL
;
800 struct multijmp
*jmp
;
803 FOR_EACH_PTR(insn
->multijmp_list
, jmp
) {
804 if (jmp
->begin
<= jmp
->end
) {
805 n_jmp
+= (jmp
->end
- jmp
->begin
) + 1;
806 } else /* default case */
808 } END_FOR_EACH_PTR(jmp
);
810 sw_val
= get_ioperand(fn
, insn
->type
, insn
->cond
);
811 target
= LLVMBuildSwitch(fn
->builder
, sw_val
,
812 def
? def
->priv
: NULL
, n_jmp
);
814 FOR_EACH_PTR(insn
->multijmp_list
, jmp
) {
817 for (val
= jmp
->begin
; val
<= jmp
->end
; val
++) {
818 LLVMValueRef Val
= val_to_value(val
, insn
->type
);
819 LLVMAddCase(target
, Val
, jmp
->target
->priv
);
821 } END_FOR_EACH_PTR(jmp
);
824 static void output_op_call(struct function
*fn
, struct instruction
*insn
)
826 LLVMValueRef target
, func
;
827 struct symbol
*fntype
;
828 struct symbol
*ctype
;
834 n_arg
= pseudo_list_size(insn
->arguments
);
835 args
= calloc(n_arg
, sizeof(LLVMValueRef
));
837 PREPARE_PTR_LIST(insn
->fntypes
, ctype
);
838 if (insn
->func
->type
== PSEUDO_REG
|| insn
->func
->type
== PSEUDO_PHI
)
839 func
= get_operand(fn
, ctype
, insn
->func
);
841 func
= pseudo_to_value(fn
, ctype
, insn
->func
);
843 fntype
= ctype
; // first symbol in the list is the function 'true' type
844 FOR_EACH_PTR(insn
->arguments
, arg
) {
845 NEXT_PTR_LIST(ctype
); // the remaining ones are the arguments' type
846 args
[i
++] = pseudo_to_rvalue(fn
, ctype
, arg
);
847 } END_FOR_EACH_PTR(arg
);
848 FINISH_PTR_LIST(ctype
);
850 pseudo_name(insn
->target
, name
);
851 #if LLVM_VERSION_MAJOR > 14
852 target
= LLVMBuildCall2(fn
->builder
, func_full_type(fntype
), func
, args
, n_arg
, name
);
855 target
= LLVMBuildCall(fn
->builder
, func
, args
, n_arg
, name
);
858 insn
->target
->priv
= target
;
861 static void output_op_phisrc(struct function
*fn
, struct instruction
*insn
)
863 insn
->src
->priv
= get_operand(fn
, insn
->type
, insn
->src
);
866 static void output_op_phi(struct function
*fn
, struct instruction
*insn
)
868 LLVMTypeRef dst_type
= insn_symbol_type(insn
);
870 insn
->target
->priv
= LLVMBuildPhi(fn
->builder
, dst_type
, "");
873 static void output_op_ptrcast(struct function
*fn
, struct instruction
*insn
)
875 LLVMValueRef src
, target
;
877 struct symbol
*otype
= insn
->orig_type
;
879 char target_name
[64];
881 src
= get_operand(fn
, otype
, insn
->src
);
882 pseudo_name(insn
->target
, target_name
);
884 dtype
= symbol_type(insn
->type
);
885 switch (insn
->opcode
) {
887 case OP_SEXT
: // FIXME
888 assert(is_int_type(otype
));
889 assert(is_ptr_type(insn
->type
));
893 assert(is_ptr_type(otype
));
894 assert(is_int_type(insn
->type
));
898 case OP_ZEXT
: // FIXME
899 assert(is_ptr_type(otype
));
900 assert(is_ptr_type(insn
->type
));
907 target
= LLVMBuildCast(fn
->builder
, op
, src
, dtype
, target_name
);
908 insn
->target
->priv
= target
;
911 static void output_op_cast(struct function
*fn
, struct instruction
*insn
, LLVMOpcode op
)
913 LLVMValueRef src
, target
;
915 struct symbol
*otype
= insn
->orig_type
;
916 char target_name
[64];
918 if (is_ptr_type(insn
->type
)) // cast to void* is OP_CAST ...
919 return output_op_ptrcast(fn
, insn
);
921 assert(is_int_type(insn
->type
));
923 src
= get_operand(fn
, otype
, insn
->src
);
924 pseudo_name(insn
->target
, target_name
);
926 dtype
= symbol_type(insn
->type
);
927 if (is_ptr_type(otype
)) {
929 } else if (is_float_type(otype
)) {
930 assert(op
== LLVMFPToUI
|| op
== LLVMFPToSI
);
931 } else if (is_int_type(otype
)) {
932 unsigned int width
= otype
->bit_size
;
933 if (insn
->size
< width
)
935 else if (insn
->size
== width
)
941 target
= LLVMBuildCast(fn
->builder
, op
, src
, dtype
, target_name
);
942 insn
->target
->priv
= target
;
945 static void output_op_fpcast(struct function
*fn
, struct instruction
*insn
)
947 LLVMTypeRef dtype
= symbol_type(insn
->type
);
948 LLVMValueRef src
, target
;
949 struct symbol
*otype
= insn
->orig_type
;
952 assert(is_float_type(insn
->type
));
954 pseudo_name(insn
->target
, name
);
955 src
= get_operand(fn
, otype
, insn
->src
);
956 switch (insn
->opcode
) {
958 target
= LLVMBuildFPCast(fn
->builder
, src
, dtype
, name
);
961 target
= LLVMBuildSIToFP(fn
->builder
, src
, dtype
, name
);
964 target
= LLVMBuildUIToFP(fn
->builder
, src
, dtype
, name
);
969 insn
->target
->priv
= target
;
972 static void output_op_label(struct function
*fn
, struct instruction
*insn
)
974 insn
->target
->priv
= LLVMBlockAddress(fn
->fn
, insn
->bb_true
->priv
);
977 static void output_op_setval(struct function
*fn
, struct instruction
*insn
)
979 struct expression
*val
= insn
->val
;
984 target
= LLVMBlockAddress(fn
->fn
, val
->symbol
->bb_target
->priv
);
990 insn
->target
->priv
= target
;
993 static void output_op_setfval(struct function
*fn
, struct instruction
*insn
)
995 LLVMTypeRef dtype
= symbol_type(insn
->type
);
998 target
= LLVMConstReal(dtype
, insn
->fvalue
);
999 insn
->target
->priv
= target
;
1002 static void output_insn(struct function
*fn
, struct instruction
*insn
)
1004 switch (insn
->opcode
) {
1006 output_op_ret(fn
, insn
);
1009 output_op_br(fn
, insn
);
1012 output_op_cbr(fn
, insn
);
1018 output_op_label(fn
, insn
);
1021 output_op_setval(fn
, insn
);
1024 output_op_setfval(fn
, insn
);
1027 output_op_switch(fn
, insn
);
1029 case OP_COMPUTEDGOTO
:
1033 output_op_phisrc(fn
, insn
);
1036 output_op_phi(fn
, insn
);
1039 output_op_load(fn
, insn
);
1042 output_op_store(fn
, insn
);
1044 case OP_INLINED_CALL
:
1047 output_op_call(fn
, insn
);
1050 output_op_cast(fn
, insn
, LLVMZExt
);
1053 output_op_cast(fn
, insn
, LLVMSExt
);
1056 output_op_cast(fn
, insn
, LLVMTrunc
);
1059 output_op_cast(fn
, insn
, LLVMFPToUI
);
1062 output_op_cast(fn
, insn
, LLVMFPToSI
);
1064 case OP_UCVTF
: case OP_SCVTF
:
1066 output_op_fpcast(fn
, insn
);
1071 output_op_ptrcast(fn
, insn
);
1073 case OP_BINARY
... OP_BINARY_END
:
1074 output_op_binary(fn
, insn
);
1076 case OP_FPCMP
... OP_BINCMP_END
:
1077 output_op_compare(fn
, insn
);
1080 output_op_sel(fn
, insn
);
1086 LLVMValueRef src
, target
;
1087 char target_name
[64];
1089 src
= pseudo_to_value(fn
, insn
->type
, insn
->src
);
1091 pseudo_name(insn
->target
, target_name
);
1093 target
= LLVMBuildNot(fn
->builder
, src
, target_name
);
1095 insn
->target
->priv
= target
;
1100 LLVMValueRef src
, target
;
1101 char target_name
[64];
1103 src
= pseudo_to_value(fn
, insn
->type
, insn
->src
);
1105 pseudo_name(insn
->target
, target_name
);
1107 if (insn
->opcode
== OP_FNEG
)
1108 target
= LLVMBuildFNeg(fn
->builder
, src
, target_name
);
1110 target
= LLVMBuildNeg(fn
->builder
, src
, target_name
);
1112 insn
->target
->priv
= target
;
1137 static void output_bb(struct function
*fn
, struct basic_block
*bb
)
1139 struct instruction
*insn
;
1141 FOR_EACH_PTR(bb
->insns
, insn
) {
1145 output_insn(fn
, insn
);
1147 END_FOR_EACH_PTR(insn
);
1152 static void output_fn(LLVMModuleRef module
, struct entrypoint
*ep
)
1154 struct symbol
*sym
= ep
->name
;
1155 struct symbol
*base_type
= sym
->ctype
.base_type
;
1156 struct function function
= { .module
= module
};
1157 struct basic_block
*bb
;
1161 function
.fn
= get_sym_value(module
, sym
);
1162 LLVMSetFunctionCallConv(function
.fn
, LLVMCCallConv
);
1163 LLVMSetLinkage(function
.fn
, function_linkage(sym
));
1165 function
.builder
= LLVMCreateBuilder();
1167 /* give a name to each argument */
1168 nr_args
= symbol_list_size(base_type
->arguments
);
1169 for (i
= 0; i
< nr_args
; i
++) {
1170 char name
[MAX_PSEUDO_NAME
];
1173 arg
= LLVMGetParam(function
.fn
, i
);
1174 snprintf(name
, sizeof(name
), "ARG%d.", i
+1);
1175 LLVMSetValueName(arg
, name
);
1178 /* create the BBs */
1179 FOR_EACH_PTR(ep
->bbs
, bb
) {
1181 LLVMBasicBlockRef bbr
;
1184 sprintf(bbname
, "L%d", nr_bb
++);
1185 bbr
= LLVMAppendBasicBlock(function
.fn
, bbname
);
1189 END_FOR_EACH_PTR(bb
);
1191 FOR_EACH_PTR(ep
->bbs
, bb
) {
1192 LLVMPositionBuilderAtEnd(function
.builder
, bb
->priv
);
1194 output_bb(&function
, bb
);
1196 END_FOR_EACH_PTR(bb
);
1198 FOR_EACH_PTR(ep
->bbs
, bb
) { // complete the OP_PHIs
1199 struct instruction
*insn
;
1201 FOR_EACH_PTR(bb
->insns
, insn
) {
1204 if (!insn
->bb
|| insn
->opcode
!= OP_PHI
)
1207 FOR_EACH_PTR(insn
->phi_list
, phi
) {
1208 struct instruction
*phisrc
;
1209 LLVMBasicBlockRef bref
;
1216 bref
= phisrc
->bb
->priv
;
1217 vref
= phisrc
->src
->priv
;
1218 LLVMAddIncoming(insn
->target
->priv
, &vref
, &bref
, 1);
1219 } END_FOR_EACH_PTR(phi
);
1220 } END_FOR_EACH_PTR(insn
);
1221 } END_FOR_EACH_PTR(bb
);
1224 static LLVMValueRef
output_data(LLVMModuleRef module
, struct symbol
*sym
)
1226 struct expression
*initializer
= sym
->initializer
;
1227 LLVMValueRef initial_value
;
1232 switch (initializer
->type
) {
1234 initial_value
= LLVMConstInt(symbol_type(sym
), initializer
->value
, 1);
1237 initial_value
= LLVMConstReal(symbol_type(sym
), initializer
->fvalue
);
1240 struct symbol
*sym
= initializer
->symbol
;
1242 initial_value
= LLVMGetNamedGlobal(module
, show_ident(sym
->ident
));
1244 initial_value
= output_data(module
, sym
);
1248 const char *s
= initializer
->string
->data
;
1249 size_t len
= initializer
->string
->length
;
1251 initial_value
= LLVMConstString(s
, len
, true);
1255 warning(initializer
->pos
, "can't initialize type: %s", show_typename(sym
));
1256 initial_value
= NULL
;
1260 LLVMTypeRef type
= symbol_type(sym
);
1262 initial_value
= LLVMConstNull(type
);
1268 name
= sym
->ident
? show_ident(sym
->ident
) : "" ;
1270 data
= LLVMAddGlobal(module
, LLVMTypeOf(initial_value
), name
);
1272 LLVMSetLinkage(data
, data_linkage(sym
));
1273 if (sym
->ctype
.modifiers
& MOD_CONST
)
1274 LLVMSetGlobalConstant(data
, 1);
1275 if (sym
->ctype
.modifiers
& MOD_TLS
)
1276 LLVMSetThreadLocal(data
, 1);
1277 if (sym
->ctype
.alignment
)
1278 LLVMSetAlignment(data
, sym
->ctype
.alignment
);
1280 if (!(sym
->ctype
.modifiers
& MOD_EXTERN
))
1281 LLVMSetInitializer(data
, initial_value
);
1286 static int is_prototype(struct symbol
*sym
)
1288 if (sym
->type
== SYM_NODE
)
1289 sym
= sym
->ctype
.base_type
;
1290 return sym
&& sym
->type
== SYM_FN
&& !sym
->stmt
;
1293 static int compile(LLVMModuleRef module
, struct symbol_list
*list
)
1297 FOR_EACH_PTR(list
, sym
) {
1298 struct entrypoint
*ep
;
1301 if (is_prototype(sym
)) {
1302 // this will do the LLVMAddFunction() we want
1303 get_sym_value(module
, sym
);
1307 ep
= linearize_symbol(sym
);
1309 output_fn(module
, ep
);
1311 output_data(module
, sym
);
1313 END_FOR_EACH_PTR(sym
);
1318 #ifndef LLVM_DEFAULT_TARGET_TRIPLE
1319 #define LLVM_DEFAULT_TARGET_TRIPLE LLVM_HOSTTRIPLE
1322 #define X86_LINUX_LAYOUT \
1323 "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-" \
1324 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-" \
1325 "a0:0:64-f80:32:32-n8:16:32-S128"
1327 #define X86_64_LINUX_LAYOUT \
1328 "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-" \
1329 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-" \
1330 "a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
1332 static void set_target(LLVMModuleRef module
)
1334 char target
[] = LLVM_DEFAULT_TARGET_TRIPLE
;
1335 const char *arch
, *vendor
, *os
, *env
, *layout
= NULL
;
1338 arch
= strtok(target
, "-");
1339 vendor
= strtok(NULL
, "-");
1340 os
= strtok(NULL
, "-");
1341 env
= strtok(NULL
, "-");
1348 if (!strcmp(arch
, "x86_64") && !strcmp(os
, "linux")) {
1350 layout
= X86_64_LINUX_LAYOUT
;
1353 layout
= X86_LINUX_LAYOUT
;
1357 /* unsupported target */
1361 snprintf(triple
, sizeof(triple
), "%s-%s-%s-%s", arch
, vendor
, os
, env
);
1362 LLVMSetTarget(module
, triple
);
1363 LLVMSetDataLayout(module
, layout
);
1366 int main(int argc
, char **argv
)
1368 struct string_list
*filelist
= NULL
;
1369 struct symbol_list
*symlist
;
1370 LLVMModuleRef module
;
1373 symlist
= sparse_initialize(argc
, argv
, &filelist
);
1375 module
= LLVMModuleCreateWithName("sparse");
1378 compile(module
, symlist
);
1380 FOR_EACH_PTR(filelist
, file
) {
1381 symlist
= sparse(file
);
1384 compile(module
, symlist
);
1385 } END_FOR_EACH_PTR(file
);
1387 LLVMVerifyModule(module
, LLVMPrintMessageAction
, NULL
);
1389 LLVMWriteBitcodeToFD(module
, STDOUT_FILENO
, 0, 0);
1391 LLVMDisposeModule(module
);