mono/mini/mini-llvm-cpp.cpp

   1 //
   2 // mini-llvm-cpp.cpp: C++ support classes for the mono LLVM integration
   3 //
   4 // (C) 2009-2011 Novell, Inc.
   5 // Copyright 2011 Xamarin, Inc (http://www.xamarin.com)
   6 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
   7 //
   8
   9 //
  10 // We need to override some stuff in LLVM, but this cannot be done using the C
  11 // interface, so we have to use some C++ code here.
  12 // The things which we override are:
  13 // - the default JIT code manager used by LLVM doesn't allocate memory using
  14 //   MAP_32BIT, we require it.
  15 // - add some callbacks so we can obtain the size of methods and their exception
  16 //   tables.
  17 //
  18
  19 //
  20 // Mono's internal header files are not C++ clean, so avoid including them if
  21 // possible
  22 //
  23
  24 #ifdef _MSC_VER
  25 // Disable warnings generated by LLVM headers.
  26 #pragma warning(disable:4141) // modifier' : used more than once
  27 #pragma warning(disable:4800) // type' : forcing value to bool 'true' or 'false' (performance warning)
  28 #endif
  29
  30 #include "config.h"
  31
  32 #include <stdint.h>
  33
  34 #include <llvm/Support/raw_ostream.h>
  35 #include <llvm/IR/Function.h>
  36 #include <llvm/IR/IRBuilder.h>
  37 #include <llvm/IR/Module.h>
  38 #include <llvm/IR/DIBuilder.h>
  39 #include <llvm/IR/CallSite.h>
  40 #include <llvm/IR/MDBuilder.h>
  41
  42 #include "mini-llvm-cpp.h"
  43
  44 using namespace llvm;
  45
  46 #define Acquire AtomicOrdering::Acquire
  47 #define Release AtomicOrdering::Release
  48 #define SequentiallyConsistent AtomicOrdering::SequentiallyConsistent
  49
  50 void
  51 mono_llvm_dump_value (LLVMValueRef value)
  52 {
  53         /* Same as LLVMDumpValue (), but print to stdout */
  54         fflush (stdout);
  55         outs () << (*unwrap<Value> (value)) << "\n";
  56         outs ().flush ();
  57 }
  58
  59 void
  60 mono_llvm_dump_module (LLVMModuleRef module)
  61 {
  62         /* Same as LLVMDumpModule (), but print to stdout */
  63         fflush (stdout);
  64         outs () << (*unwrap (module));
  65         outs ().flush ();
  66 }
  67
  68 /* Missing overload for building an alloca with an alignment */
  69 LLVMValueRef
  70 mono_llvm_build_alloca (LLVMBuilderRef builder, LLVMTypeRef Ty,
  71                                                 LLVMValueRef ArraySize,
  72                                                 int alignment, const char *Name)
  73 {
  74         return wrap (unwrap (builder)->Insert (new AllocaInst (unwrap (Ty), 0, unwrap (ArraySize), alignment), Name));
  75 }
  76
  77 LLVMValueRef
  78 mono_llvm_build_load (LLVMBuilderRef builder, LLVMValueRef PointerVal,
  79                                           const char *Name, gboolean is_volatile)
  80 {
  81         LoadInst *ins = unwrap(builder)->CreateLoad(unwrap(PointerVal), is_volatile, Name);
  82
  83         return wrap(ins);
  84 }
  85
  86 LLVMValueRef
  87 mono_llvm_build_atomic_load (LLVMBuilderRef builder, LLVMValueRef PointerVal,
  88                                                          const char *Name, gboolean is_volatile, int alignment, BarrierKind barrier)
  89 {
  90         LoadInst *ins = unwrap(builder)->CreateLoad(unwrap(PointerVal), is_volatile, Name);
  91
  92         ins->setAlignment (alignment);
  93         switch (barrier) {
  94         case LLVM_BARRIER_NONE:
  95                 break;
  96         case LLVM_BARRIER_ACQ:
  97                 ins->setOrdering(Acquire);
  98                 break;
  99         case LLVM_BARRIER_SEQ:
 100                 ins->setOrdering(SequentiallyConsistent);
 101                 break;
 102         default:
 103                 g_assert_not_reached ();
 104                 break;
 105         }
 106
 107         return wrap(ins);
 108 }
 109
 110 LLVMValueRef
 111 mono_llvm_build_aligned_load (LLVMBuilderRef builder, LLVMValueRef PointerVal,
 112                                                           const char *Name, gboolean is_volatile, int alignment)
 113 {
 114         LoadInst *ins;
 115
 116         ins = unwrap(builder)->CreateLoad(unwrap(PointerVal), is_volatile, Name);
 117         ins->setAlignment (alignment);
 118
 119         return wrap(ins);
 120 }
 121
 122 LLVMValueRef
 123 mono_llvm_build_store (LLVMBuilderRef builder, LLVMValueRef Val, LLVMValueRef PointerVal,
 124                                           gboolean is_volatile, BarrierKind barrier)
 125 {
 126         StoreInst *ins = unwrap(builder)->CreateStore(unwrap(Val), unwrap(PointerVal), is_volatile);
 127
 128         switch (barrier) {
 129         case LLVM_BARRIER_NONE:
 130                 break;
 131         case LLVM_BARRIER_REL:
 132                 ins->setOrdering(Release);
 133                 break;
 134         case LLVM_BARRIER_SEQ:
 135                 ins->setOrdering(SequentiallyConsistent);
 136                 break;
 137         default:
 138                 g_assert_not_reached ();
 139                 break;
 140         }
 141
 142         return wrap(ins);
 143 }
 144
 145 LLVMValueRef
 146 mono_llvm_build_aligned_store (LLVMBuilderRef builder, LLVMValueRef Val, LLVMValueRef PointerVal,
 147                                                            gboolean is_volatile, int alignment)
 148 {
 149         StoreInst *ins;
 150
 151         ins = unwrap(builder)->CreateStore(unwrap(Val), unwrap(PointerVal), is_volatile);
 152         ins->setAlignment (alignment);
 153
 154         return wrap (ins);
 155 }
 156
 157 LLVMValueRef
 158 mono_llvm_build_cmpxchg (LLVMBuilderRef builder, LLVMValueRef ptr, LLVMValueRef cmp, LLVMValueRef val)
 159 {
 160         AtomicCmpXchgInst *ins;
 161
 162         ins = unwrap(builder)->CreateAtomicCmpXchg (unwrap(ptr), unwrap (cmp), unwrap (val), SequentiallyConsistent, SequentiallyConsistent);
 163         return wrap (ins);
 164 }
 165
 166 LLVMValueRef
 167 mono_llvm_build_atomic_rmw (LLVMBuilderRef builder, AtomicRMWOp op, LLVMValueRef ptr, LLVMValueRef val)
 168 {
 169         AtomicRMWInst::BinOp aop = AtomicRMWInst::Xchg;
 170         AtomicRMWInst *ins;
 171
 172         switch (op) {
 173         case LLVM_ATOMICRMW_OP_XCHG:
 174                 aop = AtomicRMWInst::Xchg;
 175                 break;
 176         case LLVM_ATOMICRMW_OP_ADD:
 177                 aop = AtomicRMWInst::Add;
 178                 break;
 179         case LLVM_ATOMICRMW_OP_AND:
 180                 aop = AtomicRMWInst::And;
 181                 break;
 182         case LLVM_ATOMICRMW_OP_OR:
 183                 aop = AtomicRMWInst::Or;
 184                 break;
 185         default:
 186                 g_assert_not_reached ();
 187                 break;
 188         }
 189
 190         ins = unwrap (builder)->CreateAtomicRMW (aop, unwrap (ptr), unwrap (val), SequentiallyConsistent);
 191         return wrap (ins);
 192 }
 193
 194 LLVMValueRef
 195 mono_llvm_build_fence (LLVMBuilderRef builder, BarrierKind kind)
 196 {
 197         FenceInst *ins;
 198         AtomicOrdering ordering;
 199
 200         g_assert (kind != LLVM_BARRIER_NONE);
 201
 202         switch (kind) {
 203         case LLVM_BARRIER_ACQ:
 204                 ordering = Acquire;
 205                 break;
 206         case LLVM_BARRIER_REL:
 207                 ordering = Release;
 208                 break;
 209         case LLVM_BARRIER_SEQ:
 210                 ordering = SequentiallyConsistent;
 211                 break;
 212         default:
 213                 g_assert_not_reached ();
 214                 break;
 215         }
 216
 217         ins = unwrap (builder)->CreateFence (ordering);
 218         return wrap (ins);
 219 }
 220
 221 LLVMValueRef
 222 mono_llvm_build_weighted_branch (LLVMBuilderRef builder, LLVMValueRef cond, LLVMBasicBlockRef t, LLVMBasicBlockRef f, uint32_t t_weight, uint32_t f_weight)
 223 {
 224         auto b = unwrap (builder);
 225         auto &ctx = b->getContext ();
 226         MDBuilder mdb{ctx};
 227         auto weights = mdb.createBranchWeights (t_weight, f_weight);
 228         auto ins = b->CreateCondBr (unwrap (cond), unwrap (t), unwrap (f), weights);
 229         return wrap (ins);
 230 }
 231
 232 LLVMValueRef
 233 mono_llvm_build_exact_ashr (LLVMBuilderRef builder, LLVMValueRef lhs, LLVMValueRef rhs) {
 234         auto b = unwrap (builder);
 235         auto ins = b->CreateAShr (unwrap (lhs), unwrap (rhs), "", true);
 236         return wrap (ins);
 237 }
 238
 239 void
 240 mono_llvm_add_string_metadata (LLVMValueRef insref, const char* label, const char* text)
 241 {
 242         auto ins = unwrap<Instruction> (insref);
 243         auto &ctx = ins->getContext ();
 244         ins->setMetadata (label, MDNode::get (ctx, MDString::get (ctx, text)));
 245 }
 246
 247 void
 248 mono_llvm_set_implicit_branch (LLVMBuilderRef builder, LLVMValueRef branch)
 249 {
 250         auto b = unwrap (builder);
 251         auto &ctx = b->getContext ();
 252         auto ins = unwrap<Instruction> (branch);
 253         ins->setMetadata (LLVMContext::MD_make_implicit, MDNode::get (ctx, {}));
 254 }
 255
 256 void
 257 mono_llvm_set_must_tailcall (LLVMValueRef call_ins)
 258 {
 259         CallInst *ins = (CallInst*)unwrap (call_ins);
 260
 261         ins->setTailCallKind (CallInst::TailCallKind::TCK_MustTail);
 262 }
 263
 264 void
 265 mono_llvm_replace_uses_of (LLVMValueRef var, LLVMValueRef v)
 266 {
 267         Value *V = ConstantExpr::getTruncOrBitCast (unwrap<Constant> (v), unwrap (var)->getType ());
 268         unwrap (var)->replaceAllUsesWith (V);
 269 }
 270
 271 LLVMValueRef
 272 mono_llvm_create_constant_data_array (const uint8_t *data, int len)
 273 {
 274         return wrap(ConstantDataArray::get (*unwrap(LLVMGetGlobalContext ()), makeArrayRef(data, len)));
 275 }
 276
 277 void
 278 mono_llvm_set_is_constant (LLVMValueRef global_var)
 279 {
 280         unwrap<GlobalVariable>(global_var)->setConstant (true);
 281 }
 282
 283 // Note that in future versions of LLVM, CallInst and InvokeInst
 284 // share a CallBase parent class that would make the below methods
 285 // look much better
 286
 287 void
 288 mono_llvm_set_call_nonnull_arg (LLVMValueRef wrapped_calli, int argNo)
 289 {
 290         Instruction *calli = unwrap<Instruction> (wrapped_calli);
 291
 292         if (isa<CallInst> (calli))
 293                 dyn_cast<CallInst>(calli)->addParamAttr (argNo, Attribute::NonNull);
 294         else
 295                 dyn_cast<InvokeInst>(calli)->addParamAttr (argNo, Attribute::NonNull);
 296 }
 297
 298 void
 299 mono_llvm_set_call_nonnull_ret (LLVMValueRef wrapped_calli)
 300 {
 301         Instruction *calli = unwrap<Instruction> (wrapped_calli);
 302
 303         if (isa<CallInst> (calli))
 304                 dyn_cast<CallInst>(calli)->addAttribute (AttributeList::ReturnIndex, Attribute::NonNull);
 305         else
 306                 dyn_cast<InvokeInst>(calli)->addAttribute (AttributeList::ReturnIndex, Attribute::NonNull);
 307 }
 308
 309 void
 310 mono_llvm_set_func_nonnull_arg (LLVMValueRef func, int argNo)
 311 {
 312         unwrap<Function>(func)->addParamAttr (argNo, Attribute::NonNull);
 313 }
 314
 315 gboolean
 316 mono_llvm_can_be_gep (LLVMValueRef base, LLVMValueRef* gep_base, LLVMValueRef* gep_offset)
 317 {
 318 #ifdef ENABLE_NETCORE
 319         // Look for a pattern like this:
 320         //   %1 = ptrtoint i8* %gep_base to i64
 321         //   %2 = add i64 %1, %gep_offset
 322         if (Instruction *base_inst = dyn_cast<Instruction> (unwrap (base))) {
 323                 if (base_inst->getOpcode () == Instruction::Add) {
 324                         if (Instruction *base_ptr_ins = dyn_cast<Instruction> (base_inst->getOperand (0))) {
 325                                 if (base_ptr_ins->getOpcode () == Instruction::PtrToInt) {
 326                                         *gep_base = wrap (base_ptr_ins->getOperand (0));
 327                                         *gep_offset = wrap (base_inst->getOperand (1));
 328                                         return TRUE;
 329                                 }
 330                         }
 331                 }
 332         }
 333 #endif
 334         return FALSE;
 335 }
 336
 337 gboolean
 338 mono_llvm_is_nonnull (LLVMValueRef wrapped)
 339 {
 340         // Argument to function
 341         Value *val = unwrap (wrapped);
 342
 343         while (val) {
 344                 if (Argument *arg = dyn_cast<Argument> (val)) {
 345                         return arg->hasNonNullAttr ();
 346                 } else if (CallInst *calli = dyn_cast<CallInst> (val)) {
 347                         return calli->hasRetAttr (Attribute::NonNull);
 348                 } else if (InvokeInst *calli = dyn_cast<InvokeInst> (val)) {
 349                         return calli->hasRetAttr (Attribute::NonNull);
 350                 } else if (LoadInst *loadi = dyn_cast<LoadInst> (val)) {
 351                         return loadi->getMetadata("nonnull") != nullptr; // nonnull <index>
 352                 } else if (Instruction *inst = dyn_cast<Instruction> (val)) {
 353                         // If not a load or a function argument, the only case for us to
 354                         // consider is that it's a bitcast. If so, recurse on what was casted.
 355                         if (inst->getOpcode () == LLVMBitCast) {
 356                                 val = inst->getOperand (0);
 357                                 continue;
 358                         }
 359
 360                         return FALSE;
 361                 } else {
 362                         return FALSE;
 363                 }
 364         }
 365         return FALSE;
 366 }
 367
 368 GSList *
 369 mono_llvm_calls_using (LLVMValueRef wrapped_local)
 370 {
 371         GSList *usages = NULL;
 372         Value *local = unwrap (wrapped_local);
 373
 374         for (User *user : local->users ()) {
 375                 if (isa<CallInst> (user) || isa<InvokeInst> (user)) {
 376                         usages = g_slist_prepend (usages, wrap (user));
 377                 }
 378         }
 379
 380         return usages;
 381 }
 382
 383 LLVMValueRef *
 384 mono_llvm_call_args (LLVMValueRef wrapped_calli)
 385 {
 386         Value *calli = unwrap(wrapped_calli);
 387         CallInst *call = dyn_cast <CallInst> (calli);
 388         InvokeInst *invoke = dyn_cast <InvokeInst> (calli);
 389         g_assert (call || invoke);
 390
 391         unsigned int numOperands;
 392
 393         if (call)
 394                 numOperands = call->getNumArgOperands ();
 395         else
 396                 numOperands = invoke->getNumArgOperands ();
 397
 398         LLVMValueRef *ret = g_malloc (sizeof (LLVMValueRef) * numOperands);
 399
 400         for (unsigned int i = 0; i < numOperands; i++) {
 401                 if (call)
 402                         ret [i] = wrap (call->getArgOperand (i));
 403                 else
 404                         ret [i] = wrap (invoke->getArgOperand (i));
 405         }
 406
 407         return ret;
 408 }
 409
 410 void
 411 mono_llvm_set_call_notailcall (LLVMValueRef func)
 412 {
 413         unwrap<CallInst>(func)->setTailCallKind (CallInst::TailCallKind::TCK_NoTail);
 414 }
 415
 416 void
 417 mono_llvm_set_call_noalias_ret (LLVMValueRef wrapped_calli)
 418 {
 419         Instruction *calli = unwrap<Instruction> (wrapped_calli);
 420
 421         if (isa<CallInst> (calli))
 422                 dyn_cast<CallInst>(calli)->addAttribute (AttributeList::ReturnIndex, Attribute::NoAlias);
 423         else
 424                 dyn_cast<InvokeInst>(calli)->addAttribute (AttributeList::ReturnIndex, Attribute::NoAlias);
 425 }
 426
 427 void
 428 mono_llvm_set_alignment_ret (LLVMValueRef call, int alignment)
 429 {
 430         Instruction *ins = unwrap<Instruction> (call);
 431         auto &ctx = ins->getContext ();
 432         if (isa<CallInst> (ins))
 433                 dyn_cast<CallInst>(ins)->addAttribute (AttributeList::ReturnIndex, Attribute::getWithAlignment(ctx, alignment));
 434         else
 435                 dyn_cast<InvokeInst>(ins)->addAttribute (AttributeList::ReturnIndex, Attribute::getWithAlignment(ctx, alignment));
 436 }
 437
 438 static Attribute::AttrKind
 439 convert_attr (AttrKind kind)
 440 {
 441         switch (kind) {
 442         case LLVM_ATTR_NO_UNWIND:
 443                 return Attribute::NoUnwind;
 444         case LLVM_ATTR_NO_INLINE:
 445                 return Attribute::NoInline;
 446         case LLVM_ATTR_OPTIMIZE_FOR_SIZE:
 447                 return Attribute::OptimizeForSize;
 448         case LLVM_ATTR_OPTIMIZE_NONE:
 449                 return Attribute::OptimizeNone;
 450         case LLVM_ATTR_IN_REG:
 451                 return Attribute::InReg;
 452         case LLVM_ATTR_STRUCT_RET:
 453                 return Attribute::StructRet;
 454         case LLVM_ATTR_NO_ALIAS:
 455                 return Attribute::NoAlias;
 456         case LLVM_ATTR_BY_VAL:
 457                 return Attribute::ByVal;
 458         case LLVM_ATTR_UW_TABLE:
 459                 return Attribute::UWTable;
 460         default:
 461                 assert (0);
 462                 return Attribute::NoUnwind;
 463         }
 464 }
 465
 466 void
 467 mono_llvm_add_func_attr (LLVMValueRef func, AttrKind kind)
 468 {
 469         unwrap<Function> (func)->addAttribute (AttributeList::FunctionIndex, convert_attr (kind));
 470 }
 471
 472 void
 473 mono_llvm_add_func_attr_nv (LLVMValueRef func, const char *attr_name, const char *attr_value)
 474 {
 475         AttrBuilder NewAttrs;
 476         NewAttrs.addAttribute (attr_name, attr_value);
 477         unwrap<Function> (func)->addAttributes (AttributeList::FunctionIndex, NewAttrs);
 478 }
 479
 480 void
 481 mono_llvm_add_param_attr (LLVMValueRef param, AttrKind kind)
 482 {
 483         Function *func = unwrap<Argument> (param)->getParent ();
 484         int n = unwrap<Argument> (param)->getArgNo ();
 485         func->addParamAttr (n, convert_attr (kind));
 486 }
 487
 488 void
 489 mono_llvm_add_instr_attr (LLVMValueRef val, int index, AttrKind kind)
 490 {
 491         CallSite (unwrap<Instruction> (val)).addAttribute (index, convert_attr (kind));
 492 }
 493
 494 void*
 495 mono_llvm_create_di_builder (LLVMModuleRef module)
 496 {
 497         return new DIBuilder (*unwrap(module));
 498 }
 499
 500 void*
 501 mono_llvm_di_create_compile_unit (void *di_builder, const char *cu_name, const char *dir, const char *producer)
 502 {
 503         DIBuilder *builder = (DIBuilder*)di_builder;
 504
 505         DIFile *di_file;
 506
 507         di_file = builder->createFile (cu_name, dir);
 508         return builder->createCompileUnit (dwarf::DW_LANG_C99, di_file, producer, true, "", 0);
 509 }
 510
 511 void*
 512 mono_llvm_di_create_function (void *di_builder, void *cu, LLVMValueRef func, const char *name, const char *mangled_name, const char *dir, const char *file, int line)
 513 {
 514         DIBuilder *builder = (DIBuilder*)di_builder;
 515         DIFile *di_file;
 516         DISubroutineType *type;
 517         DISubprogram *di_func;
 518
 519         // FIXME: Share DIFile
 520         di_file = builder->createFile (file, dir);
 521         type = builder->createSubroutineType (builder->getOrCreateTypeArray (ArrayRef<Metadata*> ()));
 522 #if LLVM_API_VERSION >= 900
 523         di_func = builder->createFunction (
 524                 di_file, name, mangled_name, di_file, line, type, 0,
 525                 DINode::FlagZero, DISubprogram::SPFlagDefinition | DISubprogram::SPFlagLocalToUnit);
 526 #else
 527         di_func = builder->createFunction (di_file, name, mangled_name, di_file, line, type, true, true, 0);
 528 #endif
 529
 530         unwrap<Function>(func)->setMetadata ("dbg", di_func);
 531
 532         return di_func;
 533 }
 534
 535 void*
 536 mono_llvm_di_create_file (void *di_builder, const char *dir, const char *file)
 537 {
 538         DIBuilder *builder = (DIBuilder*)di_builder;
 539
 540         return builder->createFile (file, dir);
 541 }
 542
 543 void*
 544 mono_llvm_di_create_location (void *di_builder, void *scope, int row, int column)
 545 {
 546         return DILocation::get (*unwrap(LLVMGetGlobalContext ()), row, column, (Metadata*)scope);
 547 }
 548
 549 void
 550 mono_llvm_set_fast_math (LLVMBuilderRef builder)
 551 {
 552         FastMathFlags flags;
 553         flags.setFast ();
 554         unwrap(builder)->setFastMathFlags (flags);
 555 }
 556
 557 void
 558 mono_llvm_di_set_location (LLVMBuilderRef builder, void *loc_md)
 559 {
 560         unwrap(builder)->SetCurrentDebugLocation ((DILocation*)loc_md);
 561 }
 562
 563 void
 564 mono_llvm_di_builder_finalize (void *di_builder)
 565 {
 566         DIBuilder *builder = (DIBuilder*)di_builder;
 567
 568         builder->finalize ();
 569 }
 570
 571 LLVMValueRef
 572 mono_llvm_get_or_insert_gc_safepoint_poll (LLVMModuleRef module)
 573 {
 574 #if LLVM_API_VERSION >= 900
 575
 576         llvm::FunctionCallee callee = unwrap(module)->getOrInsertFunction("gc.safepoint_poll", FunctionType::get(unwrap(LLVMVoidType()), false));
 577         return wrap (dyn_cast<llvm::Function> (callee.getCallee ()));
 578 #else
 579         llvm::Function *SafepointPoll;
 580         llvm::Constant *SafepointPollConstant;
 581
 582         SafepointPollConstant = unwrap(module)->getOrInsertFunction("gc.safepoint_poll", FunctionType::get(unwrap(LLVMVoidType()), false));
 583         g_assert (SafepointPollConstant);
 584
 585         SafepointPoll = dyn_cast<llvm::Function>(SafepointPollConstant);
 586         g_assert (SafepointPoll);
 587         g_assert (SafepointPoll->empty());
 588
 589         return wrap(SafepointPoll);
 590 #endif
 591 }
 592
 593 gboolean
 594 mono_llvm_remove_gc_safepoint_poll (LLVMModuleRef module)
 595 {
 596         llvm::Function *func = unwrap (module)->getFunction ("gc.safepoint_poll");
 597         if (func == nullptr)
 598                 return FALSE;
 599         func->eraseFromParent ();
 600         return TRUE;
 601 }
 602
 603 int
 604 mono_llvm_check_cpu_features (const CpuFeatureAliasFlag *features, int length)
 605 {
 606         int flags = 0;
 607         llvm::StringMap<bool> HostFeatures;
 608         if (llvm::sys::getHostCPUFeatures (HostFeatures)) {
 609                 for (int i=0; i<length; i++) {
 610                         CpuFeatureAliasFlag feature = features [i];
 611                         if (HostFeatures [feature.alias])
 612                                 flags |= feature.flag;
 613                 }
 614                 /*
 615                 for (auto &F : HostFeatures)
 616                         if (F.second)
 617                                 outs () << "X: " << F.first () << "\n";
 618                 */
 619         }
 620         return flags;
 621 }
 622
 623 /* Map our intrinsic ID to the LLVM intrinsic id */
 624 static Intrinsic::ID
 625 get_intrins_id (IntrinsicId id)
 626 {
 627         Intrinsic::ID intrins_id = Intrinsic::ID::not_intrinsic;
 628         switch (id) {
 629 #define INTRINS(id, llvm_id) case INTRINS_ ## id: intrins_id = Intrinsic::ID::llvm_id; break;
 630 #define INTRINS_OVR(id, llvm_id) case INTRINS_ ## id: intrins_id = Intrinsic::ID::llvm_id; break;
 631 #include "llvm-intrinsics.h"
 632         default:
 633                 break;
 634         }
 635         return intrins_id;
 636 }
 637
 638 static bool
 639 is_overloaded_intrins (IntrinsicId id)
 640 {
 641         switch (id) {
 642 #define INTRINS(id, llvm_id)
 643 #define INTRINS_OVR(id, llvm_id) case INTRINS_ ## id: return true;
 644 #include "llvm-intrinsics.h"
 645         default:
 646                 break;
 647         }
 648         return false;
 649 }
 650
 651 /*
 652  * mono_llvm_register_intrinsic:
 653  *
 654  *   Register an LLVM intrinsic identified by ID.
 655  */
 656 LLVMValueRef
 657 mono_llvm_register_intrinsic (LLVMModuleRef module, IntrinsicId id)
 658 {
 659         if (is_overloaded_intrins (id))
 660                 return NULL;
 661
 662         auto intrins_id = get_intrins_id (id);
 663         if (intrins_id != Intrinsic::ID::not_intrinsic) {
 664                 Function *f = Intrinsic::getDeclaration (unwrap (module), intrins_id);
 665                 if (!f) {
 666                         outs () << id << "\n";
 667                         g_assert_not_reached ();
 668                 }
 669                 return wrap (f);
 670         } else {
 671                 return NULL;
 672         }
 673 }
 674
 675 /*
 676  * mono_llvm_register_intrinsic:
 677  *
 678  *   Register an overloaded LLVM intrinsic identified by ID using the supplied types.
 679  */
 680 LLVMValueRef
 681 mono_llvm_register_overloaded_intrinsic (LLVMModuleRef module, IntrinsicId id, LLVMTypeRef *types, int ntypes)
 682 {
 683         auto intrins_id = get_intrins_id (id);
 684
 685         const int max_types = 5;
 686         g_assert (ntypes <= max_types);
 687     Type *arr [max_types];
 688     for (int i = 0; i < ntypes; ++i)
 689                 arr [i] = unwrap (types [i]);
 690     auto f = Intrinsic::getDeclaration (unwrap (module), intrins_id, { arr, (size_t)ntypes });
 691     return wrap (f);
 692 }