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