sparse-llvm.c 32 KB

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