sparse-llvm.c

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