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         outs () << (*unwrap<Value> (value)) << "\n";
  55         fflush (stdout);
  56 }
  57
  58 void
  59 mono_llvm_dump_module (LLVMModuleRef module)
  60 {
  61         /* Same as LLVMDumpModule (), but print to stdout */
  62         outs () << (*unwrap (module));
  63         fflush (stdout);
  64 }
  65
  66 /* Missing overload for building an alloca with an alignment */
  67 LLVMValueRef
  68 mono_llvm_build_alloca (LLVMBuilderRef builder, LLVMTypeRef Ty,
  69                                                 LLVMValueRef ArraySize,
  70                                                 int alignment, const char *Name)
  71 {
  72         return wrap (unwrap (builder)->Insert (new AllocaInst (unwrap (Ty), 0, unwrap (ArraySize), alignment), Name));
  73 }
  74
  75 LLVMValueRef
  76 mono_llvm_build_load (LLVMBuilderRef builder, LLVMValueRef PointerVal,
  77                                           const char *Name, gboolean is_volatile)
  78 {
  79         LoadInst *ins = unwrap(builder)->CreateLoad(unwrap(PointerVal), is_volatile, Name);
  80
  81         return wrap(ins);
  82 }
  83
  84 LLVMValueRef
  85 mono_llvm_build_atomic_load (LLVMBuilderRef builder, LLVMValueRef PointerVal,
  86                                                          const char *Name, gboolean is_volatile, int alignment, BarrierKind barrier)
  87 {
  88         LoadInst *ins = unwrap(builder)->CreateLoad(unwrap(PointerVal), is_volatile, Name);
  89
  90         ins->setAlignment (alignment);
  91         switch (barrier) {
  92         case LLVM_BARRIER_NONE:
  93                 break;
  94         case LLVM_BARRIER_ACQ:
  95                 ins->setOrdering(Acquire);
  96                 break;
  97         case LLVM_BARRIER_SEQ:
  98                 ins->setOrdering(SequentiallyConsistent);
  99                 break;
 100         default:
 101                 g_assert_not_reached ();
 102                 break;
 103         }
 104
 105         return wrap(ins);
 106 }
 107
 108 LLVMValueRef
 109 mono_llvm_build_aligned_load (LLVMBuilderRef builder, LLVMValueRef PointerVal,
 110                                                           const char *Name, gboolean is_volatile, int alignment)
 111 {
 112         LoadInst *ins;
 113
 114         ins = unwrap(builder)->CreateLoad(unwrap(PointerVal), is_volatile, Name);
 115         ins->setAlignment (alignment);
 116
 117         return wrap(ins);
 118 }
 119
 120 LLVMValueRef
 121 mono_llvm_build_store (LLVMBuilderRef builder, LLVMValueRef Val, LLVMValueRef PointerVal,
 122                                           gboolean is_volatile, BarrierKind barrier)
 123 {
 124         StoreInst *ins = unwrap(builder)->CreateStore(unwrap(Val), unwrap(PointerVal), is_volatile);
 125
 126         switch (barrier) {
 127         case LLVM_BARRIER_NONE:
 128                 break;
 129         case LLVM_BARRIER_REL:
 130                 ins->setOrdering(Release);
 131                 break;
 132         case LLVM_BARRIER_SEQ:
 133                 ins->setOrdering(SequentiallyConsistent);
 134                 break;
 135         default:
 136                 g_assert_not_reached ();
 137                 break;
 138         }
 139
 140         return wrap(ins);
 141 }
 142
 143 LLVMValueRef
 144 mono_llvm_build_aligned_store (LLVMBuilderRef builder, LLVMValueRef Val, LLVMValueRef PointerVal,
 145                                                            gboolean is_volatile, int alignment)
 146 {
 147         StoreInst *ins;
 148
 149         ins = unwrap(builder)->CreateStore(unwrap(Val), unwrap(PointerVal), is_volatile);
 150         ins->setAlignment (alignment);
 151
 152         return wrap (ins);
 153 }
 154
 155 LLVMValueRef
 156 mono_llvm_build_cmpxchg (LLVMBuilderRef builder, LLVMValueRef ptr, LLVMValueRef cmp, LLVMValueRef val)
 157 {
 158         AtomicCmpXchgInst *ins;
 159
 160         ins = unwrap(builder)->CreateAtomicCmpXchg (unwrap(ptr), unwrap (cmp), unwrap (val), SequentiallyConsistent, SequentiallyConsistent);
 161         return wrap (ins);
 162 }
 163
 164 LLVMValueRef
 165 mono_llvm_build_atomic_rmw (LLVMBuilderRef builder, AtomicRMWOp op, LLVMValueRef ptr, LLVMValueRef val)
 166 {
 167         AtomicRMWInst::BinOp aop = AtomicRMWInst::Xchg;
 168         AtomicRMWInst *ins;
 169
 170         switch (op) {
 171         case LLVM_ATOMICRMW_OP_XCHG:
 172                 aop = AtomicRMWInst::Xchg;
 173                 break;
 174         case LLVM_ATOMICRMW_OP_ADD:
 175                 aop = AtomicRMWInst::Add;
 176                 break;
 177         default:
 178                 g_assert_not_reached ();
 179                 break;
 180         }
 181
 182         ins = unwrap (builder)->CreateAtomicRMW (aop, unwrap (ptr), unwrap (val), SequentiallyConsistent);
 183         return wrap (ins);
 184 }
 185
 186 LLVMValueRef
 187 mono_llvm_build_fence (LLVMBuilderRef builder, BarrierKind kind)
 188 {
 189         FenceInst *ins;
 190         AtomicOrdering ordering;
 191
 192         g_assert (kind != LLVM_BARRIER_NONE);
 193
 194         switch (kind) {
 195         case LLVM_BARRIER_ACQ:
 196                 ordering = Acquire;
 197                 break;
 198         case LLVM_BARRIER_REL:
 199                 ordering = Release;
 200                 break;
 201         case LLVM_BARRIER_SEQ:
 202                 ordering = SequentiallyConsistent;
 203                 break;
 204         default:
 205                 g_assert_not_reached ();
 206                 break;
 207         }
 208
 209         ins = unwrap (builder)->CreateFence (ordering);
 210         return wrap (ins);
 211 }
 212
 213 LLVMValueRef
 214 mono_llvm_build_weighted_branch (LLVMBuilderRef builder, LLVMValueRef cond, LLVMBasicBlockRef t, LLVMBasicBlockRef f, uint32_t t_weight, uint32_t f_weight)
 215 {
 216         auto b = unwrap (builder);
 217         auto &ctx = b->getContext ();
 218         MDBuilder mdb{ctx};
 219         auto weights = mdb.createBranchWeights (t_weight, f_weight);
 220         auto ins = b->CreateCondBr (unwrap (cond), unwrap (t), unwrap (f), weights);
 221         return wrap (ins);
 222 }
 223
 224 void
 225 mono_llvm_add_string_metadata (LLVMValueRef insref, const char* label, const char* text)
 226 {
 227         auto ins = unwrap<Instruction> (insref);
 228         auto &ctx = ins->getContext ();
 229         ins->setMetadata (label, MDNode::get (ctx, MDString::get (ctx, text)));
 230 }
 231
 232 void
 233 mono_llvm_set_implicit_branch (LLVMBuilderRef builder, LLVMValueRef branch)
 234 {
 235         auto b = unwrap (builder);
 236         auto &ctx = b->getContext ();
 237         auto ins = unwrap<Instruction> (branch);
 238         ins->setMetadata (LLVMContext::MD_make_implicit, MDNode::get (ctx, {}));
 239 }
 240
 241 void
 242 mono_llvm_set_must_tailcall (LLVMValueRef call_ins)
 243 {
 244         CallInst *ins = (CallInst*)unwrap (call_ins);
 245
 246         ins->setTailCallKind (CallInst::TailCallKind::TCK_MustTail);
 247 }
 248
 249 void
 250 mono_llvm_replace_uses_of (LLVMValueRef var, LLVMValueRef v)
 251 {
 252         Value *V = ConstantExpr::getTruncOrBitCast (unwrap<Constant> (v), unwrap (var)->getType ());
 253         unwrap (var)->replaceAllUsesWith (V);
 254 }
 255
 256 LLVMValueRef
 257 mono_llvm_create_constant_data_array (const uint8_t *data, int len)
 258 {
 259         return wrap(ConstantDataArray::get (*unwrap(LLVMGetGlobalContext ()), makeArrayRef(data, len)));
 260 }
 261
 262 void
 263 mono_llvm_set_is_constant (LLVMValueRef global_var)
 264 {
 265         unwrap<GlobalVariable>(global_var)->setConstant (true);
 266 }
 267
 268 // Note that in future versions of LLVM, CallInst and InvokeInst
 269 // share a CallBase parent class that would make the below methods
 270 // look much better
 271
 272 void
 273 mono_llvm_set_call_nonnull_arg (LLVMValueRef wrapped_calli, int argNo)
 274 {
 275         Instruction *calli = unwrap<Instruction> (wrapped_calli);
 276
 277         if (isa<CallInst> (calli))
 278                 dyn_cast<CallInst>(calli)->addParamAttr (argNo, Attribute::NonNull);
 279         else
 280                 dyn_cast<InvokeInst>(calli)->addParamAttr (argNo, Attribute::NonNull);
 281 }
 282
 283 void
 284 mono_llvm_set_call_nonnull_ret (LLVMValueRef wrapped_calli)
 285 {
 286         Instruction *calli = unwrap<Instruction> (wrapped_calli);
 287
 288         if (isa<CallInst> (calli))
 289                 dyn_cast<CallInst>(calli)->addAttribute (AttributeList::ReturnIndex, Attribute::NonNull);
 290         else
 291                 dyn_cast<InvokeInst>(calli)->addAttribute (AttributeList::ReturnIndex, Attribute::NonNull);
 292 }
 293
 294 void
 295 mono_llvm_set_func_nonnull_arg (LLVMValueRef func, int argNo)
 296 {
 297         unwrap<Function>(func)->addParamAttr (argNo, Attribute::NonNull);
 298 }
 299
 300 gboolean
 301 mono_llvm_can_be_gep (LLVMValueRef base, LLVMValueRef* gep_base, LLVMValueRef* gep_offset)
 302 {
 303 #ifdef ENABLE_NETCORE
 304         // Look for a pattern like this:
 305         //   %1 = ptrtoint i8* %gep_base to i64
 306         //   %2 = add i64 %1, %gep_offset
 307         if (Instruction *base_inst = dyn_cast<Instruction> (unwrap (base))) {
 308                 if (base_inst->getOpcode () == Instruction::Add) {
 309                         if (Instruction *base_ptr_ins = dyn_cast<Instruction> (base_inst->getOperand (0))) {
 310                                 if (base_ptr_ins->getOpcode () == Instruction::PtrToInt) {
 311                                         *gep_base = wrap (base_ptr_ins->getOperand (0));
 312                                         *gep_offset = wrap (base_inst->getOperand (1));
 313                                         return TRUE;
 314                                 }
 315                         }
 316                 }
 317         }
 318 #endif
 319         return FALSE;
 320 }
 321
 322 gboolean
 323 mono_llvm_is_nonnull (LLVMValueRef wrapped)
 324 {
 325         // Argument to function
 326         Value *val = unwrap (wrapped);
 327
 328         while (val) {
 329                 if (Argument *arg = dyn_cast<Argument> (val)) {
 330                         return arg->hasNonNullAttr ();
 331                 } else if (CallInst *calli = dyn_cast<CallInst> (val)) {
 332                         return calli->hasRetAttr (Attribute::NonNull);
 333                 } else if (InvokeInst *calli = dyn_cast<InvokeInst> (val)) {
 334                         return calli->hasRetAttr (Attribute::NonNull);
 335                 } else if (LoadInst *loadi = dyn_cast<LoadInst> (val)) {
 336                         return loadi->getMetadata("nonnull") != nullptr; // nonnull <index>
 337                 } else if (Instruction *inst = dyn_cast<Instruction> (val)) {
 338                         // If not a load or a function argument, the only case for us to
 339                         // consider is that it's a bitcast. If so, recurse on what was casted.
 340                         if (inst->getOpcode () == LLVMBitCast) {
 341                                 val = inst->getOperand (0);
 342                                 continue;
 343                         }
 344
 345                         return FALSE;
 346                 } else {
 347                         return FALSE;
 348                 }
 349         }
 350         return FALSE;
 351 }
 352
 353 GSList *
 354 mono_llvm_calls_using (LLVMValueRef wrapped_local)
 355 {
 356         GSList *usages = NULL;
 357         Value *local = unwrap (wrapped_local);
 358
 359         for (User *user : local->users ()) {
 360                 if (isa<CallInst> (user) || isa<InvokeInst> (user)) {
 361                         usages = g_slist_prepend (usages, wrap (user));
 362                 }
 363         }
 364
 365         return usages;
 366 }
 367
 368 LLVMValueRef *
 369 mono_llvm_call_args (LLVMValueRef wrapped_calli)
 370 {
 371         Value *calli = unwrap(wrapped_calli);
 372         CallInst *call = dyn_cast <CallInst> (calli);
 373         InvokeInst *invoke = dyn_cast <InvokeInst> (calli);
 374         g_assert (call || invoke);
 375
 376         unsigned int numOperands = 0;
 377
 378         if (call)
 379                 numOperands = call->getNumArgOperands ();
 380         else
 381                 numOperands = invoke->getNumArgOperands ();
 382
 383         LLVMValueRef *ret = g_malloc (sizeof (LLVMValueRef) * numOperands);
 384
 385         for (int i=0; i < numOperands; i++) {
 386                 if (call)
 387                         ret [i] = wrap (call->getArgOperand (i));
 388                 else
 389                         ret [i] = wrap (invoke->getArgOperand (i));
 390         }
 391
 392         return ret;
 393 }
 394
 395 void
 396 mono_llvm_set_call_notailcall (LLVMValueRef func)
 397 {
 398         unwrap<CallInst>(func)->setTailCallKind (CallInst::TailCallKind::TCK_NoTail);
 399 }
 400
 401 void
 402 mono_llvm_set_call_noalias_ret (LLVMValueRef wrapped_calli)
 403 {
 404         Instruction *calli = unwrap<Instruction> (wrapped_calli);
 405
 406         if (isa<CallInst> (calli))
 407                 dyn_cast<CallInst>(calli)->addAttribute (AttributeList::ReturnIndex, Attribute::NoAlias);
 408         else
 409                 dyn_cast<InvokeInst>(calli)->addAttribute (AttributeList::ReturnIndex, Attribute::NoAlias);
 410 }
 411
 412 void
 413 mono_llvm_set_alignment_ret (LLVMValueRef call, int alignment)
 414 {
 415         Instruction *ins = unwrap<Instruction> (call);
 416         auto &ctx = ins->getContext ();
 417         if (isa<CallInst> (ins))
 418                 dyn_cast<CallInst>(ins)->addAttribute (AttributeList::ReturnIndex, Attribute::getWithAlignment(ctx, alignment));
 419         else
 420                 dyn_cast<InvokeInst>(ins)->addAttribute (AttributeList::ReturnIndex, Attribute::getWithAlignment(ctx, alignment));
 421 }
 422
 423 static Attribute::AttrKind
 424 convert_attr (AttrKind kind)
 425 {
 426         switch (kind) {
 427         case LLVM_ATTR_NO_UNWIND:
 428                 return Attribute::NoUnwind;
 429         case LLVM_ATTR_NO_INLINE:
 430                 return Attribute::NoInline;
 431         case LLVM_ATTR_OPTIMIZE_FOR_SIZE:
 432                 return Attribute::OptimizeForSize;
 433         case LLVM_ATTR_OPTIMIZE_NONE:
 434                 return Attribute::OptimizeNone;
 435         case LLVM_ATTR_IN_REG:
 436                 return Attribute::InReg;
 437         case LLVM_ATTR_STRUCT_RET:
 438                 return Attribute::StructRet;
 439         case LLVM_ATTR_NO_ALIAS:
 440                 return Attribute::NoAlias;
 441         case LLVM_ATTR_BY_VAL:
 442                 return Attribute::ByVal;
 443         case LLVM_ATTR_UW_TABLE:
 444                 return Attribute::UWTable;
 445         default:
 446                 assert (0);
 447                 return Attribute::NoUnwind;
 448         }
 449 }
 450
 451 void
 452 mono_llvm_add_func_attr (LLVMValueRef func, AttrKind kind)
 453 {
 454         unwrap<Function> (func)->addAttribute (AttributeList::FunctionIndex, convert_attr (kind));
 455 }
 456
 457 void
 458 mono_llvm_add_param_attr (LLVMValueRef param, AttrKind kind)
 459 {
 460         Function *func = unwrap<Argument> (param)->getParent ();
 461         int n = unwrap<Argument> (param)->getArgNo ();
 462         func->addParamAttr (n, convert_attr (kind));
 463 }
 464
 465 void
 466 mono_llvm_add_instr_attr (LLVMValueRef val, int index, AttrKind kind)
 467 {
 468         CallSite (unwrap<Instruction> (val)).addAttribute (index, convert_attr (kind));
 469 }
 470
 471 void*
 472 mono_llvm_create_di_builder (LLVMModuleRef module)
 473 {
 474         return new DIBuilder (*unwrap(module));
 475 }
 476
 477 void*
 478 mono_llvm_di_create_compile_unit (void *di_builder, const char *cu_name, const char *dir, const char *producer)
 479 {
 480         DIBuilder *builder = (DIBuilder*)di_builder;
 481
 482         DIFile *di_file;
 483
 484         di_file = builder->createFile (cu_name, dir);
 485         return builder->createCompileUnit (dwarf::DW_LANG_C99, di_file, producer, true, "", 0);
 486 }
 487
 488 void*
 489 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)
 490 {
 491         DIBuilder *builder = (DIBuilder*)di_builder;
 492         DIFile *di_file;
 493         DISubroutineType *type;
 494         DISubprogram *di_func;
 495
 496         // FIXME: Share DIFile
 497         di_file = builder->createFile (file, dir);
 498         type = builder->createSubroutineType (builder->getOrCreateTypeArray (ArrayRef<Metadata*> ()));
 499 #if LLVM_API_VERSION >= 900
 500         di_func = builder->createFunction (di_file, name, mangled_name, di_file, line, type, 0);
 501 #else
 502         di_func = builder->createFunction (di_file, name, mangled_name, di_file, line, type, true, true, 0);
 503 #endif
 504
 505         unwrap<Function>(func)->setMetadata ("dbg", di_func);
 506
 507         return di_func;
 508 }
 509
 510 void*
 511 mono_llvm_di_create_file (void *di_builder, const char *dir, const char *file)
 512 {
 513         DIBuilder *builder = (DIBuilder*)di_builder;
 514
 515         return builder->createFile (file, dir);
 516 }
 517
 518 void*
 519 mono_llvm_di_create_location (void *di_builder, void *scope, int row, int column)
 520 {
 521         return DILocation::get (*unwrap(LLVMGetGlobalContext ()), row, column, (Metadata*)scope);
 522 }
 523
 524 void
 525 mono_llvm_set_fast_math (LLVMBuilderRef builder)
 526 {
 527         FastMathFlags flags;
 528         flags.setFast ();
 529         unwrap(builder)->setFastMathFlags (flags);
 530 }
 531
 532 void
 533 mono_llvm_di_set_location (LLVMBuilderRef builder, void *loc_md)
 534 {
 535         unwrap(builder)->SetCurrentDebugLocation ((DILocation*)loc_md);
 536 }
 537
 538 void
 539 mono_llvm_di_builder_finalize (void *di_builder)
 540 {
 541         DIBuilder *builder = (DIBuilder*)di_builder;
 542
 543         builder->finalize ();
 544 }
 545
 546 LLVMValueRef
 547 mono_llvm_get_or_insert_gc_safepoint_poll (LLVMModuleRef module)
 548 {
 549 #if LLVM_API_VERSION >= 900
 550
 551         llvm::FunctionCallee callee = unwrap(module)->getOrInsertFunction("gc.safepoint_poll", FunctionType::get(unwrap(LLVMVoidType()), false));
 552         return wrap (dyn_cast<llvm::Function> (callee.getCallee ()));
 553 #else
 554         llvm::Function *SafepointPoll;
 555         llvm::Constant *SafepointPollConstant;
 556
 557         SafepointPollConstant = unwrap(module)->getOrInsertFunction("gc.safepoint_poll", FunctionType::get(unwrap(LLVMVoidType()), false));
 558         g_assert (SafepointPollConstant);
 559
 560         SafepointPoll = dyn_cast<llvm::Function>(SafepointPollConstant);
 561         g_assert (SafepointPoll);
 562         g_assert (SafepointPoll->empty());
 563
 564         return wrap(SafepointPoll);
 565 #endif
 566 }
 567
 568 gboolean
 569 mono_llvm_remove_gc_safepoint_poll (LLVMModuleRef module)
 570 {
 571         llvm::Function *func = unwrap (module)->getFunction ("gc.safepoint_poll");
 572         if (func == nullptr)
 573                 return FALSE;
 574         func->eraseFromParent ();
 575         return TRUE;
 576 }
 577
 578 int
 579 mono_llvm_check_cpu_features (const CpuFeatureAliasFlag *features, int length)
 580 {
 581         int flags = 0;
 582         llvm::StringMap<bool> HostFeatures;
 583         if (llvm::sys::getHostCPUFeatures (HostFeatures)) {
 584                 for (int i=0; i<length; i++) {
 585                         CpuFeatureAliasFlag feature = features [i];
 586                         if (HostFeatures [feature.alias])
 587                                 flags |= feature.flag;
 588                 }
 589                 /*
 590                 for (auto &F : HostFeatures)
 591                         if (F.second)
 592                                 outs () << "X: " << F.first () << "\n";
 593                 */
 594         }
 595         return flags;
 596 }