llvm/lib/IR/Core.cpp

   1 //===-- Core.cpp ----------------------------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // This file implements the common infrastructure (including the C bindings)
  10 // for libLLVMCore.a, which implements the LLVM intermediate representation.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "llvm-c/Core.h"
  15 #include "llvm/IR/Attributes.h"
  16 #include "llvm/IR/BasicBlock.h"
  17 #include "llvm/IR/Constants.h"
  18 #include "llvm/IR/DebugInfoMetadata.h"
  19 #include "llvm/IR/DerivedTypes.h"
  20 #include "llvm/IR/DiagnosticInfo.h"
  21 #include "llvm/IR/DiagnosticPrinter.h"
  22 #include "llvm/IR/GlobalAlias.h"
  23 #include "llvm/IR/GlobalVariable.h"
  24 #include "llvm/IR/IRBuilder.h"
  25 #include "llvm/IR/InlineAsm.h"
  26 #include "llvm/IR/IntrinsicInst.h"
  27 #include "llvm/IR/LLVMContext.h"
  28 #include "llvm/IR/LegacyPassManager.h"
  29 #include "llvm/IR/Module.h"
  30 #include "llvm/InitializePasses.h"
  31 #include "llvm/PassRegistry.h"
  32 #include "llvm/Support/Debug.h"
  33 #include "llvm/Support/ErrorHandling.h"
  34 #include "llvm/Support/FileSystem.h"
  35 #include "llvm/Support/ManagedStatic.h"
  36 #include "llvm/Support/MemoryBuffer.h"
  37 #include "llvm/Support/Threading.h"
  38 #include "llvm/Support/raw_ostream.h"
  39 #include <cassert>
  40 #include <cstdlib>
  41 #include <cstring>
  42 #include <system_error>
  43
  44 using namespace llvm;
  45
  46 #define DEBUG_TYPE "ir"
  47
  48 void llvm::initializeCore(PassRegistry &Registry) {
  49   initializeDominatorTreeWrapperPassPass(Registry);
  50   initializePrintModulePassWrapperPass(Registry);
  51   initializePrintFunctionPassWrapperPass(Registry);
  52   initializeSafepointIRVerifierPass(Registry);
  53   initializeVerifierLegacyPassPass(Registry);
  54 }
  55
  56 void LLVMShutdown() {
  57   llvm_shutdown();
  58 }
  59
  60 /*===-- Version query -----------------------------------------------------===*/
  61
  62 void LLVMGetVersion(unsigned *Major, unsigned *Minor, unsigned *Patch) {
  63     if (Major)
  64         *Major = LLVM_VERSION_MAJOR;
  65     if (Minor)
  66         *Minor = LLVM_VERSION_MINOR;
  67     if (Patch)
  68         *Patch = LLVM_VERSION_PATCH;
  69 }
  70
  71 /*===-- Error handling ----------------------------------------------------===*/
  72
  73 char *LLVMCreateMessage(const char *Message) {
  74   return strdup(Message);
  75 }
  76
  77 void LLVMDisposeMessage(char *Message) {
  78   free(Message);
  79 }
  80
  81
  82 /*===-- Operations on contexts --------------------------------------------===*/
  83
  84 static LLVMContext &getGlobalContext() {
  85   static LLVMContext GlobalContext;
  86   return GlobalContext;
  87 }
  88
  89 LLVMContextRef LLVMContextCreate() {
  90   return wrap(new LLVMContext());
  91 }
  92
  93 LLVMContextRef LLVMGetGlobalContext() { return wrap(&getGlobalContext()); }
  94
  95 void LLVMContextSetDiagnosticHandler(LLVMContextRef C,
  96                                      LLVMDiagnosticHandler Handler,
  97                                      void *DiagnosticContext) {
  98   unwrap(C)->setDiagnosticHandlerCallBack(
  99       LLVM_EXTENSION reinterpret_cast<DiagnosticHandler::DiagnosticHandlerTy>(
 100           Handler),
 101       DiagnosticContext);
 102 }
 103
 104 LLVMDiagnosticHandler LLVMContextGetDiagnosticHandler(LLVMContextRef C) {
 105   return LLVM_EXTENSION reinterpret_cast<LLVMDiagnosticHandler>(
 106       unwrap(C)->getDiagnosticHandlerCallBack());
 107 }
 108
 109 void *LLVMContextGetDiagnosticContext(LLVMContextRef C) {
 110   return unwrap(C)->getDiagnosticContext();
 111 }
 112
 113 void LLVMContextSetYieldCallback(LLVMContextRef C, LLVMYieldCallback Callback,
 114                                  void *OpaqueHandle) {
 115   auto YieldCallback =
 116     LLVM_EXTENSION reinterpret_cast<LLVMContext::YieldCallbackTy>(Callback);
 117   unwrap(C)->setYieldCallback(YieldCallback, OpaqueHandle);
 118 }
 119
 120 LLVMBool LLVMContextShouldDiscardValueNames(LLVMContextRef C) {
 121   return unwrap(C)->shouldDiscardValueNames();
 122 }
 123
 124 void LLVMContextSetDiscardValueNames(LLVMContextRef C, LLVMBool Discard) {
 125   unwrap(C)->setDiscardValueNames(Discard);
 126 }
 127
 128 void LLVMContextDispose(LLVMContextRef C) {
 129   delete unwrap(C);
 130 }
 131
 132 unsigned LLVMGetMDKindIDInContext(LLVMContextRef C, const char *Name,
 133                                   unsigned SLen) {
 134   return unwrap(C)->getMDKindID(StringRef(Name, SLen));
 135 }
 136
 137 unsigned LLVMGetMDKindID(const char *Name, unsigned SLen) {
 138   return LLVMGetMDKindIDInContext(LLVMGetGlobalContext(), Name, SLen);
 139 }
 140
 141 unsigned LLVMGetEnumAttributeKindForName(const char *Name, size_t SLen) {
 142   return Attribute::getAttrKindFromName(StringRef(Name, SLen));
 143 }
 144
 145 unsigned LLVMGetLastEnumAttributeKind(void) {
 146   return Attribute::AttrKind::EndAttrKinds;
 147 }
 148
 149 LLVMAttributeRef LLVMCreateEnumAttribute(LLVMContextRef C, unsigned KindID,
 150                                          uint64_t Val) {
 151   auto &Ctx = *unwrap(C);
 152   auto AttrKind = (Attribute::AttrKind)KindID;
 153   return wrap(Attribute::get(Ctx, AttrKind, Val));
 154 }
 155
 156 unsigned LLVMGetEnumAttributeKind(LLVMAttributeRef A) {
 157   return unwrap(A).getKindAsEnum();
 158 }
 159
 160 uint64_t LLVMGetEnumAttributeValue(LLVMAttributeRef A) {
 161   auto Attr = unwrap(A);
 162   if (Attr.isEnumAttribute())
 163     return 0;
 164   return Attr.getValueAsInt();
 165 }
 166
 167 LLVMAttributeRef LLVMCreateTypeAttribute(LLVMContextRef C, unsigned KindID,
 168                                          LLVMTypeRef type_ref) {
 169   auto &Ctx = *unwrap(C);
 170   auto AttrKind = (Attribute::AttrKind)KindID;
 171   return wrap(Attribute::get(Ctx, AttrKind, unwrap(type_ref)));
 172 }
 173
 174 LLVMTypeRef LLVMGetTypeAttributeValue(LLVMAttributeRef A) {
 175   auto Attr = unwrap(A);
 176   return wrap(Attr.getValueAsType());
 177 }
 178
 179 LLVMAttributeRef LLVMCreateStringAttribute(LLVMContextRef C,
 180                                            const char *K, unsigned KLength,
 181                                            const char *V, unsigned VLength) {
 182   return wrap(Attribute::get(*unwrap(C), StringRef(K, KLength),
 183                              StringRef(V, VLength)));
 184 }
 185
 186 const char *LLVMGetStringAttributeKind(LLVMAttributeRef A,
 187                                        unsigned *Length) {
 188   auto S = unwrap(A).getKindAsString();
 189   *Length = S.size();
 190   return S.data();
 191 }
 192
 193 const char *LLVMGetStringAttributeValue(LLVMAttributeRef A,
 194                                         unsigned *Length) {
 195   auto S = unwrap(A).getValueAsString();
 196   *Length = S.size();
 197   return S.data();
 198 }
 199
 200 LLVMBool LLVMIsEnumAttribute(LLVMAttributeRef A) {
 201   auto Attr = unwrap(A);
 202   return Attr.isEnumAttribute() || Attr.isIntAttribute();
 203 }
 204
 205 LLVMBool LLVMIsStringAttribute(LLVMAttributeRef A) {
 206   return unwrap(A).isStringAttribute();
 207 }
 208
 209 LLVMBool LLVMIsTypeAttribute(LLVMAttributeRef A) {
 210   return unwrap(A).isTypeAttribute();
 211 }
 212
 213 char *LLVMGetDiagInfoDescription(LLVMDiagnosticInfoRef DI) {
 214   std::string MsgStorage;
 215   raw_string_ostream Stream(MsgStorage);
 216   DiagnosticPrinterRawOStream DP(Stream);
 217
 218   unwrap(DI)->print(DP);
 219   Stream.flush();
 220
 221   return LLVMCreateMessage(MsgStorage.c_str());
 222 }
 223
 224 LLVMDiagnosticSeverity LLVMGetDiagInfoSeverity(LLVMDiagnosticInfoRef DI) {
 225     LLVMDiagnosticSeverity severity;
 226
 227     switch(unwrap(DI)->getSeverity()) {
 228     default:
 229       severity = LLVMDSError;
 230       break;
 231     case DS_Warning:
 232       severity = LLVMDSWarning;
 233       break;
 234     case DS_Remark:
 235       severity = LLVMDSRemark;
 236       break;
 237     case DS_Note:
 238       severity = LLVMDSNote;
 239       break;
 240     }
 241
 242     return severity;
 243 }
 244
 245 /*===-- Operations on modules ---------------------------------------------===*/
 246
 247 LLVMModuleRef LLVMModuleCreateWithName(const char *ModuleID) {
 248   return wrap(new Module(ModuleID, getGlobalContext()));
 249 }
 250
 251 LLVMModuleRef LLVMModuleCreateWithNameInContext(const char *ModuleID,
 252                                                 LLVMContextRef C) {
 253   return wrap(new Module(ModuleID, *unwrap(C)));
 254 }
 255
 256 void LLVMDisposeModule(LLVMModuleRef M) {
 257   delete unwrap(M);
 258 }
 259
 260 const char *LLVMGetModuleIdentifier(LLVMModuleRef M, size_t *Len) {
 261   auto &Str = unwrap(M)->getModuleIdentifier();
 262   *Len = Str.length();
 263   return Str.c_str();
 264 }
 265
 266 void LLVMSetModuleIdentifier(LLVMModuleRef M, const char *Ident, size_t Len) {
 267   unwrap(M)->setModuleIdentifier(StringRef(Ident, Len));
 268 }
 269
 270 const char *LLVMGetSourceFileName(LLVMModuleRef M, size_t *Len) {
 271   auto &Str = unwrap(M)->getSourceFileName();
 272   *Len = Str.length();
 273   return Str.c_str();
 274 }
 275
 276 void LLVMSetSourceFileName(LLVMModuleRef M, const char *Name, size_t Len) {
 277   unwrap(M)->setSourceFileName(StringRef(Name, Len));
 278 }
 279
 280 /*--.. Data layout .........................................................--*/
 281 const char *LLVMGetDataLayoutStr(LLVMModuleRef M) {
 282   return unwrap(M)->getDataLayoutStr().c_str();
 283 }
 284
 285 const char *LLVMGetDataLayout(LLVMModuleRef M) {
 286   return LLVMGetDataLayoutStr(M);
 287 }
 288
 289 void LLVMSetDataLayout(LLVMModuleRef M, const char *DataLayoutStr) {
 290   unwrap(M)->setDataLayout(DataLayoutStr);
 291 }
 292
 293 /*--.. Target triple .......................................................--*/
 294 const char * LLVMGetTarget(LLVMModuleRef M) {
 295   return unwrap(M)->getTargetTriple().c_str();
 296 }
 297
 298 void LLVMSetTarget(LLVMModuleRef M, const char *Triple) {
 299   unwrap(M)->setTargetTriple(Triple);
 300 }
 301
 302 /*--.. Module flags ........................................................--*/
 303 struct LLVMOpaqueModuleFlagEntry {
 304   LLVMModuleFlagBehavior Behavior;
 305   const char *Key;
 306   size_t KeyLen;
 307   LLVMMetadataRef Metadata;
 308 };
 309
 310 static Module::ModFlagBehavior
 311 map_to_llvmModFlagBehavior(LLVMModuleFlagBehavior Behavior) {
 312   switch (Behavior) {
 313   case LLVMModuleFlagBehaviorError:
 314     return Module::ModFlagBehavior::Error;
 315   case LLVMModuleFlagBehaviorWarning:
 316     return Module::ModFlagBehavior::Warning;
 317   case LLVMModuleFlagBehaviorRequire:
 318     return Module::ModFlagBehavior::Require;
 319   case LLVMModuleFlagBehaviorOverride:
 320     return Module::ModFlagBehavior::Override;
 321   case LLVMModuleFlagBehaviorAppend:
 322     return Module::ModFlagBehavior::Append;
 323   case LLVMModuleFlagBehaviorAppendUnique:
 324     return Module::ModFlagBehavior::AppendUnique;
 325   }
 326   llvm_unreachable("Unknown LLVMModuleFlagBehavior");
 327 }
 328
 329 static LLVMModuleFlagBehavior
 330 map_from_llvmModFlagBehavior(Module::ModFlagBehavior Behavior) {
 331   switch (Behavior) {
 332   case Module::ModFlagBehavior::Error:
 333     return LLVMModuleFlagBehaviorError;
 334   case Module::ModFlagBehavior::Warning:
 335     return LLVMModuleFlagBehaviorWarning;
 336   case Module::ModFlagBehavior::Require:
 337     return LLVMModuleFlagBehaviorRequire;
 338   case Module::ModFlagBehavior::Override:
 339     return LLVMModuleFlagBehaviorOverride;
 340   case Module::ModFlagBehavior::Append:
 341     return LLVMModuleFlagBehaviorAppend;
 342   case Module::ModFlagBehavior::AppendUnique:
 343     return LLVMModuleFlagBehaviorAppendUnique;
 344   default:
 345     llvm_unreachable("Unhandled Flag Behavior");
 346   }
 347 }
 348
 349 LLVMModuleFlagEntry *LLVMCopyModuleFlagsMetadata(LLVMModuleRef M, size_t *Len) {
 350   SmallVector<Module::ModuleFlagEntry, 8> MFEs;
 351   unwrap(M)->getModuleFlagsMetadata(MFEs);
 352
 353   LLVMOpaqueModuleFlagEntry *Result = static_cast<LLVMOpaqueModuleFlagEntry *>(
 354       safe_malloc(MFEs.size() * sizeof(LLVMOpaqueModuleFlagEntry)));
 355   for (unsigned i = 0; i < MFEs.size(); ++i) {
 356     const auto &ModuleFlag = MFEs[i];
 357     Result[i].Behavior = map_from_llvmModFlagBehavior(ModuleFlag.Behavior);
 358     Result[i].Key = ModuleFlag.Key->getString().data();
 359     Result[i].KeyLen = ModuleFlag.Key->getString().size();
 360     Result[i].Metadata = wrap(ModuleFlag.Val);
 361   }
 362   *Len = MFEs.size();
 363   return Result;
 364 }
 365
 366 void LLVMDisposeModuleFlagsMetadata(LLVMModuleFlagEntry *Entries) {
 367   free(Entries);
 368 }
 369
 370 LLVMModuleFlagBehavior
 371 LLVMModuleFlagEntriesGetFlagBehavior(LLVMModuleFlagEntry *Entries,
 372                                      unsigned Index) {
 373   LLVMOpaqueModuleFlagEntry MFE =
 374       static_cast<LLVMOpaqueModuleFlagEntry>(Entries[Index]);
 375   return MFE.Behavior;
 376 }
 377
 378 const char *LLVMModuleFlagEntriesGetKey(LLVMModuleFlagEntry *Entries,
 379                                         unsigned Index, size_t *Len) {
 380   LLVMOpaqueModuleFlagEntry MFE =
 381       static_cast<LLVMOpaqueModuleFlagEntry>(Entries[Index]);
 382   *Len = MFE.KeyLen;
 383   return MFE.Key;
 384 }
 385
 386 LLVMMetadataRef LLVMModuleFlagEntriesGetMetadata(LLVMModuleFlagEntry *Entries,
 387                                                  unsigned Index) {
 388   LLVMOpaqueModuleFlagEntry MFE =
 389       static_cast<LLVMOpaqueModuleFlagEntry>(Entries[Index]);
 390   return MFE.Metadata;
 391 }
 392
 393 LLVMMetadataRef LLVMGetModuleFlag(LLVMModuleRef M,
 394                                   const char *Key, size_t KeyLen) {
 395   return wrap(unwrap(M)->getModuleFlag({Key, KeyLen}));
 396 }
 397
 398 void LLVMAddModuleFlag(LLVMModuleRef M, LLVMModuleFlagBehavior Behavior,
 399                        const char *Key, size_t KeyLen,
 400                        LLVMMetadataRef Val) {
 401   unwrap(M)->addModuleFlag(map_to_llvmModFlagBehavior(Behavior),
 402                            {Key, KeyLen}, unwrap(Val));
 403 }
 404
 405 /*--.. Printing modules ....................................................--*/
 406
 407 void LLVMDumpModule(LLVMModuleRef M) {
 408   unwrap(M)->print(errs(), nullptr,
 409                    /*ShouldPreserveUseListOrder=*/false, /*IsForDebug=*/true);
 410 }
 411
 412 LLVMBool LLVMPrintModuleToFile(LLVMModuleRef M, const char *Filename,
 413                                char **ErrorMessage) {
 414   std::error_code EC;
 415   raw_fd_ostream dest(Filename, EC, sys::fs::OF_TextWithCRLF);
 416   if (EC) {
 417     *ErrorMessage = strdup(EC.message().c_str());
 418     return true;
 419   }
 420
 421   unwrap(M)->print(dest, nullptr);
 422
 423   dest.close();
 424
 425   if (dest.has_error()) {
 426     std::string E = "Error printing to file: " + dest.error().message();
 427     *ErrorMessage = strdup(E.c_str());
 428     return true;
 429   }
 430
 431   return false;
 432 }
 433
 434 char *LLVMPrintModuleToString(LLVMModuleRef M) {
 435   std::string buf;
 436   raw_string_ostream os(buf);
 437
 438   unwrap(M)->print(os, nullptr);
 439   os.flush();
 440
 441   return strdup(buf.c_str());
 442 }
 443
 444 /*--.. Operations on inline assembler ......................................--*/
 445 void LLVMSetModuleInlineAsm2(LLVMModuleRef M, const char *Asm, size_t Len) {
 446   unwrap(M)->setModuleInlineAsm(StringRef(Asm, Len));
 447 }
 448
 449 void LLVMSetModuleInlineAsm(LLVMModuleRef M, const char *Asm) {
 450   unwrap(M)->setModuleInlineAsm(StringRef(Asm));
 451 }
 452
 453 void LLVMAppendModuleInlineAsm(LLVMModuleRef M, const char *Asm, size_t Len) {
 454   unwrap(M)->appendModuleInlineAsm(StringRef(Asm, Len));
 455 }
 456
 457 const char *LLVMGetModuleInlineAsm(LLVMModuleRef M, size_t *Len) {
 458   auto &Str = unwrap(M)->getModuleInlineAsm();
 459   *Len = Str.length();
 460   return Str.c_str();
 461 }
 462
 463 LLVMValueRef LLVMGetInlineAsm(LLVMTypeRef Ty, const char *AsmString,
 464                               size_t AsmStringSize, const char *Constraints,
 465                               size_t ConstraintsSize, LLVMBool HasSideEffects,
 466                               LLVMBool IsAlignStack,
 467                               LLVMInlineAsmDialect Dialect, LLVMBool CanThrow) {
 468   InlineAsm::AsmDialect AD;
 469   switch (Dialect) {
 470   case LLVMInlineAsmDialectATT:
 471     AD = InlineAsm::AD_ATT;
 472     break;
 473   case LLVMInlineAsmDialectIntel:
 474     AD = InlineAsm::AD_Intel;
 475     break;
 476   }
 477   return wrap(InlineAsm::get(unwrap<FunctionType>(Ty),
 478                              StringRef(AsmString, AsmStringSize),
 479                              StringRef(Constraints, ConstraintsSize),
 480                              HasSideEffects, IsAlignStack, AD, CanThrow));
 481 }
 482
 483 const char *LLVMGetInlineAsmAsmString(LLVMValueRef InlineAsmVal, size_t *Len) {
 484
 485   Value *Val = unwrap<Value>(InlineAsmVal);
 486   const std::string &AsmString = cast<InlineAsm>(Val)->getAsmString();
 487
 488   *Len = AsmString.length();
 489   return AsmString.c_str();
 490 }
 491
 492 const char *LLVMGetInlineAsmConstraintString(LLVMValueRef InlineAsmVal,
 493                                              size_t *Len) {
 494   Value *Val = unwrap<Value>(InlineAsmVal);
 495   const std::string &ConstraintString =
 496       cast<InlineAsm>(Val)->getConstraintString();
 497
 498   *Len = ConstraintString.length();
 499   return ConstraintString.c_str();
 500 }
 501
 502 LLVMInlineAsmDialect LLVMGetInlineAsmDialect(LLVMValueRef InlineAsmVal) {
 503
 504   Value *Val = unwrap<Value>(InlineAsmVal);
 505   InlineAsm::AsmDialect Dialect = cast<InlineAsm>(Val)->getDialect();
 506
 507   switch (Dialect) {
 508   case InlineAsm::AD_ATT:
 509     return LLVMInlineAsmDialectATT;
 510   case InlineAsm::AD_Intel:
 511     return LLVMInlineAsmDialectIntel;
 512   }
 513
 514   llvm_unreachable("Unrecognized inline assembly dialect");
 515   return LLVMInlineAsmDialectATT;
 516 }
 517
 518 LLVMTypeRef LLVMGetInlineAsmFunctionType(LLVMValueRef InlineAsmVal) {
 519   Value *Val = unwrap<Value>(InlineAsmVal);
 520   return (LLVMTypeRef)cast<InlineAsm>(Val)->getFunctionType();
 521 }
 522
 523 LLVMBool LLVMGetInlineAsmHasSideEffects(LLVMValueRef InlineAsmVal) {
 524   Value *Val = unwrap<Value>(InlineAsmVal);
 525   return cast<InlineAsm>(Val)->hasSideEffects();
 526 }
 527
 528 LLVMBool LLVMGetInlineAsmNeedsAlignedStack(LLVMValueRef InlineAsmVal) {
 529   Value *Val = unwrap<Value>(InlineAsmVal);
 530   return cast<InlineAsm>(Val)->isAlignStack();
 531 }
 532
 533 LLVMBool LLVMGetInlineAsmCanUnwind(LLVMValueRef InlineAsmVal) {
 534   Value *Val = unwrap<Value>(InlineAsmVal);
 535   return cast<InlineAsm>(Val)->canThrow();
 536 }
 537
 538 /*--.. Operations on module contexts ......................................--*/
 539 LLVMContextRef LLVMGetModuleContext(LLVMModuleRef M) {
 540   return wrap(&unwrap(M)->getContext());
 541 }
 542
 543
 544 /*===-- Operations on types -----------------------------------------------===*/
 545
 546 /*--.. Operations on all types (mostly) ....................................--*/
 547
 548 LLVMTypeKind LLVMGetTypeKind(LLVMTypeRef Ty) {
 549   switch (unwrap(Ty)->getTypeID()) {
 550   case Type::VoidTyID:
 551     return LLVMVoidTypeKind;
 552   case Type::HalfTyID:
 553     return LLVMHalfTypeKind;
 554   case Type::BFloatTyID:
 555     return LLVMBFloatTypeKind;
 556   case Type::FloatTyID:
 557     return LLVMFloatTypeKind;
 558   case Type::DoubleTyID:
 559     return LLVMDoubleTypeKind;
 560   case Type::X86_FP80TyID:
 561     return LLVMX86_FP80TypeKind;
 562   case Type::FP128TyID:
 563     return LLVMFP128TypeKind;
 564   case Type::PPC_FP128TyID:
 565     return LLVMPPC_FP128TypeKind;
 566   case Type::LabelTyID:
 567     return LLVMLabelTypeKind;
 568   case Type::MetadataTyID:
 569     return LLVMMetadataTypeKind;
 570   case Type::IntegerTyID:
 571     return LLVMIntegerTypeKind;
 572   case Type::FunctionTyID:
 573     return LLVMFunctionTypeKind;
 574   case Type::StructTyID:
 575     return LLVMStructTypeKind;
 576   case Type::ArrayTyID:
 577     return LLVMArrayTypeKind;
 578   case Type::PointerTyID:
 579     return LLVMPointerTypeKind;
 580   case Type::FixedVectorTyID:
 581     return LLVMVectorTypeKind;
 582   case Type::X86_MMXTyID:
 583     return LLVMX86_MMXTypeKind;
 584   case Type::X86_AMXTyID:
 585     return LLVMX86_AMXTypeKind;
 586   case Type::TokenTyID:
 587     return LLVMTokenTypeKind;
 588   case Type::ScalableVectorTyID:
 589     return LLVMScalableVectorTypeKind;
 590   case Type::TargetExtTyID:
 591     return LLVMTargetExtTypeKind;
 592   case Type::TypedPointerTyID:
 593     llvm_unreachable("Typed pointers are unsupported via the C API");
 594   }
 595   llvm_unreachable("Unhandled TypeID.");
 596 }
 597
 598 LLVMBool LLVMTypeIsSized(LLVMTypeRef Ty)
 599 {
 600     return unwrap(Ty)->isSized();
 601 }
 602
 603 LLVMContextRef LLVMGetTypeContext(LLVMTypeRef Ty) {
 604   return wrap(&unwrap(Ty)->getContext());
 605 }
 606
 607 void LLVMDumpType(LLVMTypeRef Ty) {
 608   return unwrap(Ty)->print(errs(), /*IsForDebug=*/true);
 609 }
 610
 611 char *LLVMPrintTypeToString(LLVMTypeRef Ty) {
 612   std::string buf;
 613   raw_string_ostream os(buf);
 614
 615   if (unwrap(Ty))
 616     unwrap(Ty)->print(os);
 617   else
 618     os << "Printing <null> Type";
 619
 620   os.flush();
 621
 622   return strdup(buf.c_str());
 623 }
 624
 625 /*--.. Operations on integer types .........................................--*/
 626
 627 LLVMTypeRef LLVMInt1TypeInContext(LLVMContextRef C)  {
 628   return (LLVMTypeRef) Type::getInt1Ty(*unwrap(C));
 629 }
 630 LLVMTypeRef LLVMInt8TypeInContext(LLVMContextRef C)  {
 631   return (LLVMTypeRef) Type::getInt8Ty(*unwrap(C));
 632 }
 633 LLVMTypeRef LLVMInt16TypeInContext(LLVMContextRef C) {
 634   return (LLVMTypeRef) Type::getInt16Ty(*unwrap(C));
 635 }
 636 LLVMTypeRef LLVMInt32TypeInContext(LLVMContextRef C) {
 637   return (LLVMTypeRef) Type::getInt32Ty(*unwrap(C));
 638 }
 639 LLVMTypeRef LLVMInt64TypeInContext(LLVMContextRef C) {
 640   return (LLVMTypeRef) Type::getInt64Ty(*unwrap(C));
 641 }
 642 LLVMTypeRef LLVMInt128TypeInContext(LLVMContextRef C) {
 643   return (LLVMTypeRef) Type::getInt128Ty(*unwrap(C));
 644 }
 645 LLVMTypeRef LLVMIntTypeInContext(LLVMContextRef C, unsigned NumBits) {
 646   return wrap(IntegerType::get(*unwrap(C), NumBits));
 647 }
 648
 649 LLVMTypeRef LLVMInt1Type(void)  {
 650   return LLVMInt1TypeInContext(LLVMGetGlobalContext());
 651 }
 652 LLVMTypeRef LLVMInt8Type(void)  {
 653   return LLVMInt8TypeInContext(LLVMGetGlobalContext());
 654 }
 655 LLVMTypeRef LLVMInt16Type(void) {
 656   return LLVMInt16TypeInContext(LLVMGetGlobalContext());
 657 }
 658 LLVMTypeRef LLVMInt32Type(void) {
 659   return LLVMInt32TypeInContext(LLVMGetGlobalContext());
 660 }
 661 LLVMTypeRef LLVMInt64Type(void) {
 662   return LLVMInt64TypeInContext(LLVMGetGlobalContext());
 663 }
 664 LLVMTypeRef LLVMInt128Type(void) {
 665   return LLVMInt128TypeInContext(LLVMGetGlobalContext());
 666 }
 667 LLVMTypeRef LLVMIntType(unsigned NumBits) {
 668   return LLVMIntTypeInContext(LLVMGetGlobalContext(), NumBits);
 669 }
 670
 671 unsigned LLVMGetIntTypeWidth(LLVMTypeRef IntegerTy) {
 672   return unwrap<IntegerType>(IntegerTy)->getBitWidth();
 673 }
 674
 675 /*--.. Operations on real types ............................................--*/
 676
 677 LLVMTypeRef LLVMHalfTypeInContext(LLVMContextRef C) {
 678   return (LLVMTypeRef) Type::getHalfTy(*unwrap(C));
 679 }
 680 LLVMTypeRef LLVMBFloatTypeInContext(LLVMContextRef C) {
 681   return (LLVMTypeRef) Type::getBFloatTy(*unwrap(C));
 682 }
 683 LLVMTypeRef LLVMFloatTypeInContext(LLVMContextRef C) {
 684   return (LLVMTypeRef) Type::getFloatTy(*unwrap(C));
 685 }
 686 LLVMTypeRef LLVMDoubleTypeInContext(LLVMContextRef C) {
 687   return (LLVMTypeRef) Type::getDoubleTy(*unwrap(C));
 688 }
 689 LLVMTypeRef LLVMX86FP80TypeInContext(LLVMContextRef C) {
 690   return (LLVMTypeRef) Type::getX86_FP80Ty(*unwrap(C));
 691 }
 692 LLVMTypeRef LLVMFP128TypeInContext(LLVMContextRef C) {
 693   return (LLVMTypeRef) Type::getFP128Ty(*unwrap(C));
 694 }
 695 LLVMTypeRef LLVMPPCFP128TypeInContext(LLVMContextRef C) {
 696   return (LLVMTypeRef) Type::getPPC_FP128Ty(*unwrap(C));
 697 }
 698 LLVMTypeRef LLVMX86MMXTypeInContext(LLVMContextRef C) {
 699   return (LLVMTypeRef) Type::getX86_MMXTy(*unwrap(C));
 700 }
 701 LLVMTypeRef LLVMX86AMXTypeInContext(LLVMContextRef C) {
 702   return (LLVMTypeRef) Type::getX86_AMXTy(*unwrap(C));
 703 }
 704
 705 LLVMTypeRef LLVMHalfType(void) {
 706   return LLVMHalfTypeInContext(LLVMGetGlobalContext());
 707 }
 708 LLVMTypeRef LLVMBFloatType(void) {
 709   return LLVMBFloatTypeInContext(LLVMGetGlobalContext());
 710 }
 711 LLVMTypeRef LLVMFloatType(void) {
 712   return LLVMFloatTypeInContext(LLVMGetGlobalContext());
 713 }
 714 LLVMTypeRef LLVMDoubleType(void) {
 715   return LLVMDoubleTypeInContext(LLVMGetGlobalContext());
 716 }
 717 LLVMTypeRef LLVMX86FP80Type(void) {
 718   return LLVMX86FP80TypeInContext(LLVMGetGlobalContext());
 719 }
 720 LLVMTypeRef LLVMFP128Type(void) {
 721   return LLVMFP128TypeInContext(LLVMGetGlobalContext());
 722 }
 723 LLVMTypeRef LLVMPPCFP128Type(void) {
 724   return LLVMPPCFP128TypeInContext(LLVMGetGlobalContext());
 725 }
 726 LLVMTypeRef LLVMX86MMXType(void) {
 727   return LLVMX86MMXTypeInContext(LLVMGetGlobalContext());
 728 }
 729 LLVMTypeRef LLVMX86AMXType(void) {
 730   return LLVMX86AMXTypeInContext(LLVMGetGlobalContext());
 731 }
 732
 733 /*--.. Operations on function types ........................................--*/
 734
 735 LLVMTypeRef LLVMFunctionType(LLVMTypeRef ReturnType,
 736                              LLVMTypeRef *ParamTypes, unsigned ParamCount,
 737                              LLVMBool IsVarArg) {
 738   ArrayRef<Type*> Tys(unwrap(ParamTypes), ParamCount);
 739   return wrap(FunctionType::get(unwrap(ReturnType), Tys, IsVarArg != 0));
 740 }
 741
 742 LLVMBool LLVMIsFunctionVarArg(LLVMTypeRef FunctionTy) {
 743   return unwrap<FunctionType>(FunctionTy)->isVarArg();
 744 }
 745
 746 LLVMTypeRef LLVMGetReturnType(LLVMTypeRef FunctionTy) {
 747   return wrap(unwrap<FunctionType>(FunctionTy)->getReturnType());
 748 }
 749
 750 unsigned LLVMCountParamTypes(LLVMTypeRef FunctionTy) {
 751   return unwrap<FunctionType>(FunctionTy)->getNumParams();
 752 }
 753
 754 void LLVMGetParamTypes(LLVMTypeRef FunctionTy, LLVMTypeRef *Dest) {
 755   FunctionType *Ty = unwrap<FunctionType>(FunctionTy);
 756   for (Type *T : Ty->params())
 757     *Dest++ = wrap(T);
 758 }
 759
 760 /*--.. Operations on struct types ..........................................--*/
 761
 762 LLVMTypeRef LLVMStructTypeInContext(LLVMContextRef C, LLVMTypeRef *ElementTypes,
 763                            unsigned ElementCount, LLVMBool Packed) {
 764   ArrayRef<Type*> Tys(unwrap(ElementTypes), ElementCount);
 765   return wrap(StructType::get(*unwrap(C), Tys, Packed != 0));
 766 }
 767
 768 LLVMTypeRef LLVMStructType(LLVMTypeRef *ElementTypes,
 769                            unsigned ElementCount, LLVMBool Packed) {
 770   return LLVMStructTypeInContext(LLVMGetGlobalContext(), ElementTypes,
 771                                  ElementCount, Packed);
 772 }
 773
 774 LLVMTypeRef LLVMStructCreateNamed(LLVMContextRef C, const char *Name)
 775 {
 776   return wrap(StructType::create(*unwrap(C), Name));
 777 }
 778
 779 const char *LLVMGetStructName(LLVMTypeRef Ty)
 780 {
 781   StructType *Type = unwrap<StructType>(Ty);
 782   if (!Type->hasName())
 783     return nullptr;
 784   return Type->getName().data();
 785 }
 786
 787 void LLVMStructSetBody(LLVMTypeRef StructTy, LLVMTypeRef *ElementTypes,
 788                        unsigned ElementCount, LLVMBool Packed) {
 789   ArrayRef<Type*> Tys(unwrap(ElementTypes), ElementCount);
 790   unwrap<StructType>(StructTy)->setBody(Tys, Packed != 0);
 791 }
 792
 793 unsigned LLVMCountStructElementTypes(LLVMTypeRef StructTy) {
 794   return unwrap<StructType>(StructTy)->getNumElements();
 795 }
 796
 797 void LLVMGetStructElementTypes(LLVMTypeRef StructTy, LLVMTypeRef *Dest) {
 798   StructType *Ty = unwrap<StructType>(StructTy);
 799   for (Type *T : Ty->elements())
 800     *Dest++ = wrap(T);
 801 }
 802
 803 LLVMTypeRef LLVMStructGetTypeAtIndex(LLVMTypeRef StructTy, unsigned i) {
 804   StructType *Ty = unwrap<StructType>(StructTy);
 805   return wrap(Ty->getTypeAtIndex(i));
 806 }
 807
 808 LLVMBool LLVMIsPackedStruct(LLVMTypeRef StructTy) {
 809   return unwrap<StructType>(StructTy)->isPacked();
 810 }
 811
 812 LLVMBool LLVMIsOpaqueStruct(LLVMTypeRef StructTy) {
 813   return unwrap<StructType>(StructTy)->isOpaque();
 814 }
 815
 816 LLVMBool LLVMIsLiteralStruct(LLVMTypeRef StructTy) {
 817   return unwrap<StructType>(StructTy)->isLiteral();
 818 }
 819
 820 LLVMTypeRef LLVMGetTypeByName(LLVMModuleRef M, const char *Name) {
 821   return wrap(StructType::getTypeByName(unwrap(M)->getContext(), Name));
 822 }
 823
 824 LLVMTypeRef LLVMGetTypeByName2(LLVMContextRef C, const char *Name) {
 825   return wrap(StructType::getTypeByName(*unwrap(C), Name));
 826 }
 827
 828 /*--.. Operations on array, pointer, and vector types (sequence types) .....--*/
 829
 830 void LLVMGetSubtypes(LLVMTypeRef Tp, LLVMTypeRef *Arr) {
 831     int i = 0;
 832     for (auto *T : unwrap(Tp)->subtypes()) {
 833         Arr[i] = wrap(T);
 834         i++;
 835     }
 836 }
 837
 838 LLVMTypeRef LLVMArrayType(LLVMTypeRef ElementType, unsigned ElementCount) {
 839   return wrap(ArrayType::get(unwrap(ElementType), ElementCount));
 840 }
 841
 842 LLVMTypeRef LLVMArrayType2(LLVMTypeRef ElementType, uint64_t ElementCount) {
 843   return wrap(ArrayType::get(unwrap(ElementType), ElementCount));
 844 }
 845
 846 LLVMTypeRef LLVMPointerType(LLVMTypeRef ElementType, unsigned AddressSpace) {
 847   return wrap(PointerType::get(unwrap(ElementType), AddressSpace));
 848 }
 849
 850 LLVMBool LLVMPointerTypeIsOpaque(LLVMTypeRef Ty) {
 851   return true;
 852 }
 853
 854 LLVMTypeRef LLVMVectorType(LLVMTypeRef ElementType, unsigned ElementCount) {
 855   return wrap(FixedVectorType::get(unwrap(ElementType), ElementCount));
 856 }
 857
 858 LLVMTypeRef LLVMScalableVectorType(LLVMTypeRef ElementType,
 859                                    unsigned ElementCount) {
 860   return wrap(ScalableVectorType::get(unwrap(ElementType), ElementCount));
 861 }
 862
 863 LLVMTypeRef LLVMGetElementType(LLVMTypeRef WrappedTy) {
 864   auto *Ty = unwrap(WrappedTy);
 865   if (auto *ATy = dyn_cast<ArrayType>(Ty))
 866     return wrap(ATy->getElementType());
 867   return wrap(cast<VectorType>(Ty)->getElementType());
 868 }
 869
 870 unsigned LLVMGetNumContainedTypes(LLVMTypeRef Tp) {
 871     return unwrap(Tp)->getNumContainedTypes();
 872 }
 873
 874 unsigned LLVMGetArrayLength(LLVMTypeRef ArrayTy) {
 875   return unwrap<ArrayType>(ArrayTy)->getNumElements();
 876 }
 877
 878 uint64_t LLVMGetArrayLength2(LLVMTypeRef ArrayTy) {
 879   return unwrap<ArrayType>(ArrayTy)->getNumElements();
 880 }
 881
 882 unsigned LLVMGetPointerAddressSpace(LLVMTypeRef PointerTy) {
 883   return unwrap<PointerType>(PointerTy)->getAddressSpace();
 884 }
 885
 886 unsigned LLVMGetVectorSize(LLVMTypeRef VectorTy) {
 887   return unwrap<VectorType>(VectorTy)->getElementCount().getKnownMinValue();
 888 }
 889
 890 /*--.. Operations on other types ...........................................--*/
 891
 892 LLVMTypeRef LLVMPointerTypeInContext(LLVMContextRef C, unsigned AddressSpace) {
 893   return wrap(PointerType::get(*unwrap(C), AddressSpace));
 894 }
 895
 896 LLVMTypeRef LLVMVoidTypeInContext(LLVMContextRef C)  {
 897   return wrap(Type::getVoidTy(*unwrap(C)));
 898 }
 899 LLVMTypeRef LLVMLabelTypeInContext(LLVMContextRef C) {
 900   return wrap(Type::getLabelTy(*unwrap(C)));
 901 }
 902 LLVMTypeRef LLVMTokenTypeInContext(LLVMContextRef C) {
 903   return wrap(Type::getTokenTy(*unwrap(C)));
 904 }
 905 LLVMTypeRef LLVMMetadataTypeInContext(LLVMContextRef C) {
 906   return wrap(Type::getMetadataTy(*unwrap(C)));
 907 }
 908
 909 LLVMTypeRef LLVMVoidType(void)  {
 910   return LLVMVoidTypeInContext(LLVMGetGlobalContext());
 911 }
 912 LLVMTypeRef LLVMLabelType(void) {
 913   return LLVMLabelTypeInContext(LLVMGetGlobalContext());
 914 }
 915
 916 LLVMTypeRef LLVMTargetExtTypeInContext(LLVMContextRef C, const char *Name,
 917                                        LLVMTypeRef *TypeParams,
 918                                        unsigned TypeParamCount,
 919                                        unsigned *IntParams,
 920                                        unsigned IntParamCount) {
 921   ArrayRef<Type *> TypeParamArray(unwrap(TypeParams), TypeParamCount);
 922   ArrayRef<unsigned> IntParamArray(IntParams, IntParamCount);
 923   return wrap(
 924       TargetExtType::get(*unwrap(C), Name, TypeParamArray, IntParamArray));
 925 }
 926
 927 /*===-- Operations on values ----------------------------------------------===*/
 928
 929 /*--.. Operations on all values ............................................--*/
 930
 931 LLVMTypeRef LLVMTypeOf(LLVMValueRef Val) {
 932   return wrap(unwrap(Val)->getType());
 933 }
 934
 935 LLVMValueKind LLVMGetValueKind(LLVMValueRef Val) {
 936     switch(unwrap(Val)->getValueID()) {
 937 #define LLVM_C_API 1
 938 #define HANDLE_VALUE(Name) \
 939   case Value::Name##Val: \
 940     return LLVM##Name##ValueKind;
 941 #include "llvm/IR/Value.def"
 942   default:
 943     return LLVMInstructionValueKind;
 944   }
 945 }
 946
 947 const char *LLVMGetValueName2(LLVMValueRef Val, size_t *Length) {
 948   auto *V = unwrap(Val);
 949   *Length = V->getName().size();
 950   return V->getName().data();
 951 }
 952
 953 void LLVMSetValueName2(LLVMValueRef Val, const char *Name, size_t NameLen) {
 954   unwrap(Val)->setName(StringRef(Name, NameLen));
 955 }
 956
 957 const char *LLVMGetValueName(LLVMValueRef Val) {
 958   return unwrap(Val)->getName().data();
 959 }
 960
 961 void LLVMSetValueName(LLVMValueRef Val, const char *Name) {
 962   unwrap(Val)->setName(Name);
 963 }
 964
 965 void LLVMDumpValue(LLVMValueRef Val) {
 966   unwrap(Val)->print(errs(), /*IsForDebug=*/true);
 967 }
 968
 969 char* LLVMPrintValueToString(LLVMValueRef Val) {
 970   std::string buf;
 971   raw_string_ostream os(buf);
 972
 973   if (unwrap(Val))
 974     unwrap(Val)->print(os);
 975   else
 976     os << "Printing <null> Value";
 977
 978   os.flush();
 979
 980   return strdup(buf.c_str());
 981 }
 982
 983 void LLVMReplaceAllUsesWith(LLVMValueRef OldVal, LLVMValueRef NewVal) {
 984   unwrap(OldVal)->replaceAllUsesWith(unwrap(NewVal));
 985 }
 986
 987 int LLVMHasMetadata(LLVMValueRef Inst) {
 988   return unwrap<Instruction>(Inst)->hasMetadata();
 989 }
 990
 991 LLVMValueRef LLVMGetMetadata(LLVMValueRef Inst, unsigned KindID) {
 992   auto *I = unwrap<Instruction>(Inst);
 993   assert(I && "Expected instruction");
 994   if (auto *MD = I->getMetadata(KindID))
 995     return wrap(MetadataAsValue::get(I->getContext(), MD));
 996   return nullptr;
 997 }
 998
 999 // MetadataAsValue uses a canonical format which strips the actual MDNode for
1000 // MDNode with just a single constant value, storing just a ConstantAsMetadata
1001 // This undoes this canonicalization, reconstructing the MDNode.
1002 static MDNode *extractMDNode(MetadataAsValue *MAV) {
1003   Metadata *MD = MAV->getMetadata();
1004   assert((isa<MDNode>(MD) || isa<ConstantAsMetadata>(MD)) &&
1005       "Expected a metadata node or a canonicalized constant");
1006
1007   if (MDNode *N = dyn_cast<MDNode>(MD))
1008     return N;
1009
1010   return MDNode::get(MAV->getContext(), MD);
1011 }
1012
1013 void LLVMSetMetadata(LLVMValueRef Inst, unsigned KindID, LLVMValueRef Val) {
1014   MDNode *N = Val ? extractMDNode(unwrap<MetadataAsValue>(Val)) : nullptr;
1015
1016   unwrap<Instruction>(Inst)->setMetadata(KindID, N);
1017 }
1018
1019 struct LLVMOpaqueValueMetadataEntry {
1020   unsigned Kind;
1021   LLVMMetadataRef Metadata;
1022 };
1023
1024 using MetadataEntries = SmallVectorImpl<std::pair<unsigned, MDNode *>>;
1025 static LLVMValueMetadataEntry *
1026 llvm_getMetadata(size_t *NumEntries,
1027                  llvm::function_ref<void(MetadataEntries &)> AccessMD) {
1028   SmallVector<std::pair<unsigned, MDNode *>, 8> MVEs;
1029   AccessMD(MVEs);
1030
1031   LLVMOpaqueValueMetadataEntry *Result =
1032   static_cast<LLVMOpaqueValueMetadataEntry *>(
1033                                               safe_malloc(MVEs.size() * sizeof(LLVMOpaqueValueMetadataEntry)));
1034   for (unsigned i = 0; i < MVEs.size(); ++i) {
1035     const auto &ModuleFlag = MVEs[i];
1036     Result[i].Kind = ModuleFlag.first;
1037     Result[i].Metadata = wrap(ModuleFlag.second);
1038   }
1039   *NumEntries = MVEs.size();
1040   return Result;
1041 }
1042
1043 LLVMValueMetadataEntry *
1044 LLVMInstructionGetAllMetadataOtherThanDebugLoc(LLVMValueRef Value,
1045                                                size_t *NumEntries) {
1046   return llvm_getMetadata(NumEntries, [&Value](MetadataEntries &Entries) {
1047     Entries.clear();
1048     unwrap<Instruction>(Value)->getAllMetadata(Entries);
1049   });
1050 }
1051
1052 /*--.. Conversion functions ................................................--*/
1053
1054 #define LLVM_DEFINE_VALUE_CAST(name)                                       \
1055   LLVMValueRef LLVMIsA##name(LLVMValueRef Val) {                           \
1056     return wrap(static_cast<Value*>(dyn_cast_or_null<name>(unwrap(Val)))); \
1057   }
1058
1059 LLVM_FOR_EACH_VALUE_SUBCLASS(LLVM_DEFINE_VALUE_CAST)
1060
1061 LLVMValueRef LLVMIsAMDNode(LLVMValueRef Val) {
1062   if (auto *MD = dyn_cast_or_null<MetadataAsValue>(unwrap(Val)))
1063     if (isa<MDNode>(MD->getMetadata()) ||
1064         isa<ValueAsMetadata>(MD->getMetadata()))
1065       return Val;
1066   return nullptr;
1067 }
1068
1069 LLVMValueRef LLVMIsAValueAsMetadata(LLVMValueRef Val) {
1070   if (auto *MD = dyn_cast_or_null<MetadataAsValue>(unwrap(Val)))
1071     if (isa<ValueAsMetadata>(MD->getMetadata()))
1072       return Val;
1073   return nullptr;
1074 }
1075
1076 LLVMValueRef LLVMIsAMDString(LLVMValueRef Val) {
1077   if (auto *MD = dyn_cast_or_null<MetadataAsValue>(unwrap(Val)))
1078     if (isa<MDString>(MD->getMetadata()))
1079       return Val;
1080   return nullptr;
1081 }
1082
1083 /*--.. Operations on Uses ..................................................--*/
1084 LLVMUseRef LLVMGetFirstUse(LLVMValueRef Val) {
1085   Value *V = unwrap(Val);
1086   Value::use_iterator I = V->use_begin();
1087   if (I == V->use_end())
1088     return nullptr;
1089   return wrap(&*I);
1090 }
1091
1092 LLVMUseRef LLVMGetNextUse(LLVMUseRef U) {
1093   Use *Next = unwrap(U)->getNext();
1094   if (Next)
1095     return wrap(Next);
1096   return nullptr;
1097 }
1098
1099 LLVMValueRef LLVMGetUser(LLVMUseRef U) {
1100   return wrap(unwrap(U)->getUser());
1101 }
1102
1103 LLVMValueRef LLVMGetUsedValue(LLVMUseRef U) {
1104   return wrap(unwrap(U)->get());
1105 }
1106
1107 /*--.. Operations on Users .................................................--*/
1108
1109 static LLVMValueRef getMDNodeOperandImpl(LLVMContext &Context, const MDNode *N,
1110                                          unsigned Index) {
1111   Metadata *Op = N->getOperand(Index);
1112   if (!Op)
1113     return nullptr;
1114   if (auto *C = dyn_cast<ConstantAsMetadata>(Op))
1115     return wrap(C->getValue());
1116   return wrap(MetadataAsValue::get(Context, Op));
1117 }
1118
1119 LLVMValueRef LLVMGetOperand(LLVMValueRef Val, unsigned Index) {
1120   Value *V = unwrap(Val);
1121   if (auto *MD = dyn_cast<MetadataAsValue>(V)) {
1122     if (auto *L = dyn_cast<ValueAsMetadata>(MD->getMetadata())) {
1123       assert(Index == 0 && "Function-local metadata can only have one operand");
1124       return wrap(L->getValue());
1125     }
1126     return getMDNodeOperandImpl(V->getContext(),
1127                                 cast<MDNode>(MD->getMetadata()), Index);
1128   }
1129
1130   return wrap(cast<User>(V)->getOperand(Index));
1131 }
1132
1133 LLVMUseRef LLVMGetOperandUse(LLVMValueRef Val, unsigned Index) {
1134   Value *V = unwrap(Val);
1135   return wrap(&cast<User>(V)->getOperandUse(Index));
1136 }
1137
1138 void LLVMSetOperand(LLVMValueRef Val, unsigned Index, LLVMValueRef Op) {
1139   unwrap<User>(Val)->setOperand(Index, unwrap(Op));
1140 }
1141
1142 int LLVMGetNumOperands(LLVMValueRef Val) {
1143   Value *V = unwrap(Val);
1144   if (isa<MetadataAsValue>(V))
1145     return LLVMGetMDNodeNumOperands(Val);
1146
1147   return cast<User>(V)->getNumOperands();
1148 }
1149
1150 /*--.. Operations on constants of any type .................................--*/
1151
1152 LLVMValueRef LLVMConstNull(LLVMTypeRef Ty) {
1153   return wrap(Constant::getNullValue(unwrap(Ty)));
1154 }
1155
1156 LLVMValueRef LLVMConstAllOnes(LLVMTypeRef Ty) {
1157   return wrap(Constant::getAllOnesValue(unwrap(Ty)));
1158 }
1159
1160 LLVMValueRef LLVMGetUndef(LLVMTypeRef Ty) {
1161   return wrap(UndefValue::get(unwrap(Ty)));
1162 }
1163
1164 LLVMValueRef LLVMGetPoison(LLVMTypeRef Ty) {
1165   return wrap(PoisonValue::get(unwrap(Ty)));
1166 }
1167
1168 LLVMBool LLVMIsConstant(LLVMValueRef Ty) {
1169   return isa<Constant>(unwrap(Ty));
1170 }
1171
1172 LLVMBool LLVMIsNull(LLVMValueRef Val) {
1173   if (Constant *C = dyn_cast<Constant>(unwrap(Val)))
1174     return C->isNullValue();
1175   return false;
1176 }
1177
1178 LLVMBool LLVMIsUndef(LLVMValueRef Val) {
1179   return isa<UndefValue>(unwrap(Val));
1180 }
1181
1182 LLVMBool LLVMIsPoison(LLVMValueRef Val) {
1183   return isa<PoisonValue>(unwrap(Val));
1184 }
1185
1186 LLVMValueRef LLVMConstPointerNull(LLVMTypeRef Ty) {
1187   return wrap(ConstantPointerNull::get(unwrap<PointerType>(Ty)));
1188 }
1189
1190 /*--.. Operations on metadata nodes ........................................--*/
1191
1192 LLVMMetadataRef LLVMMDStringInContext2(LLVMContextRef C, const char *Str,
1193                                        size_t SLen) {
1194   return wrap(MDString::get(*unwrap(C), StringRef(Str, SLen)));
1195 }
1196
1197 LLVMMetadataRef LLVMMDNodeInContext2(LLVMContextRef C, LLVMMetadataRef *MDs,
1198                                      size_t Count) {
1199   return wrap(MDNode::get(*unwrap(C), ArrayRef<Metadata*>(unwrap(MDs), Count)));
1200 }
1201
1202 LLVMValueRef LLVMMDStringInContext(LLVMContextRef C, const char *Str,
1203                                    unsigned SLen) {
1204   LLVMContext &Context = *unwrap(C);
1205   return wrap(MetadataAsValue::get(
1206       Context, MDString::get(Context, StringRef(Str, SLen))));
1207 }
1208
1209 LLVMValueRef LLVMMDString(const char *Str, unsigned SLen) {
1210   return LLVMMDStringInContext(LLVMGetGlobalContext(), Str, SLen);
1211 }
1212
1213 LLVMValueRef LLVMMDNodeInContext(LLVMContextRef C, LLVMValueRef *Vals,
1214                                  unsigned Count) {
1215   LLVMContext &Context = *unwrap(C);
1216   SmallVector<Metadata *, 8> MDs;
1217   for (auto *OV : ArrayRef(Vals, Count)) {
1218     Value *V = unwrap(OV);
1219     Metadata *MD;
1220     if (!V)
1221       MD = nullptr;
1222     else if (auto *C = dyn_cast<Constant>(V))
1223       MD = ConstantAsMetadata::get(C);
1224     else if (auto *MDV = dyn_cast<MetadataAsValue>(V)) {
1225       MD = MDV->getMetadata();
1226       assert(!isa<LocalAsMetadata>(MD) && "Unexpected function-local metadata "
1227                                           "outside of direct argument to call");
1228     } else {
1229       // This is function-local metadata.  Pretend to make an MDNode.
1230       assert(Count == 1 &&
1231              "Expected only one operand to function-local metadata");
1232       return wrap(MetadataAsValue::get(Context, LocalAsMetadata::get(V)));
1233     }
1234
1235     MDs.push_back(MD);
1236   }
1237   return wrap(MetadataAsValue::get(Context, MDNode::get(Context, MDs)));
1238 }
1239
1240 LLVMValueRef LLVMMDNode(LLVMValueRef *Vals, unsigned Count) {
1241   return LLVMMDNodeInContext(LLVMGetGlobalContext(), Vals, Count);
1242 }
1243
1244 LLVMValueRef LLVMMetadataAsValue(LLVMContextRef C, LLVMMetadataRef MD) {
1245   return wrap(MetadataAsValue::get(*unwrap(C), unwrap(MD)));
1246 }
1247
1248 LLVMMetadataRef LLVMValueAsMetadata(LLVMValueRef Val) {
1249   auto *V = unwrap(Val);
1250   if (auto *C = dyn_cast<Constant>(V))
1251     return wrap(ConstantAsMetadata::get(C));
1252   if (auto *MAV = dyn_cast<MetadataAsValue>(V))
1253     return wrap(MAV->getMetadata());
1254   return wrap(ValueAsMetadata::get(V));
1255 }
1256
1257 const char *LLVMGetMDString(LLVMValueRef V, unsigned *Length) {
1258   if (const auto *MD = dyn_cast<MetadataAsValue>(unwrap(V)))
1259     if (const MDString *S = dyn_cast<MDString>(MD->getMetadata())) {
1260       *Length = S->getString().size();
1261       return S->getString().data();
1262     }
1263   *Length = 0;
1264   return nullptr;
1265 }
1266
1267 unsigned LLVMGetMDNodeNumOperands(LLVMValueRef V) {
1268   auto *MD = unwrap<MetadataAsValue>(V);
1269   if (isa<ValueAsMetadata>(MD->getMetadata()))
1270     return 1;
1271   return cast<MDNode>(MD->getMetadata())->getNumOperands();
1272 }
1273
1274 LLVMNamedMDNodeRef LLVMGetFirstNamedMetadata(LLVMModuleRef M) {
1275   Module *Mod = unwrap(M);
1276   Module::named_metadata_iterator I = Mod->named_metadata_begin();
1277   if (I == Mod->named_metadata_end())
1278     return nullptr;
1279   return wrap(&*I);
1280 }
1281
1282 LLVMNamedMDNodeRef LLVMGetLastNamedMetadata(LLVMModuleRef M) {
1283   Module *Mod = unwrap(M);
1284   Module::named_metadata_iterator I = Mod->named_metadata_end();
1285   if (I == Mod->named_metadata_begin())
1286     return nullptr;
1287   return wrap(&*--I);
1288 }
1289
1290 LLVMNamedMDNodeRef LLVMGetNextNamedMetadata(LLVMNamedMDNodeRef NMD) {
1291   NamedMDNode *NamedNode = unwrap(NMD);
1292   Module::named_metadata_iterator I(NamedNode);
1293   if (++I == NamedNode->getParent()->named_metadata_end())
1294     return nullptr;
1295   return wrap(&*I);
1296 }
1297
1298 LLVMNamedMDNodeRef LLVMGetPreviousNamedMetadata(LLVMNamedMDNodeRef NMD) {
1299   NamedMDNode *NamedNode = unwrap(NMD);
1300   Module::named_metadata_iterator I(NamedNode);
1301   if (I == NamedNode->getParent()->named_metadata_begin())
1302     return nullptr;
1303   return wrap(&*--I);
1304 }
1305
1306 LLVMNamedMDNodeRef LLVMGetNamedMetadata(LLVMModuleRef M,
1307                                         const char *Name, size_t NameLen) {
1308   return wrap(unwrap(M)->getNamedMetadata(StringRef(Name, NameLen)));
1309 }
1310
1311 LLVMNamedMDNodeRef LLVMGetOrInsertNamedMetadata(LLVMModuleRef M,
1312                                                 const char *Name, size_t NameLen) {
1313   return wrap(unwrap(M)->getOrInsertNamedMetadata({Name, NameLen}));
1314 }
1315
1316 const char *LLVMGetNamedMetadataName(LLVMNamedMDNodeRef NMD, size_t *NameLen) {
1317   NamedMDNode *NamedNode = unwrap(NMD);
1318   *NameLen = NamedNode->getName().size();
1319   return NamedNode->getName().data();
1320 }
1321
1322 void LLVMGetMDNodeOperands(LLVMValueRef V, LLVMValueRef *Dest) {
1323   auto *MD = unwrap<MetadataAsValue>(V);
1324   if (auto *MDV = dyn_cast<ValueAsMetadata>(MD->getMetadata())) {
1325     *Dest = wrap(MDV->getValue());
1326     return;
1327   }
1328   const auto *N = cast<MDNode>(MD->getMetadata());
1329   const unsigned numOperands = N->getNumOperands();
1330   LLVMContext &Context = unwrap(V)->getContext();
1331   for (unsigned i = 0; i < numOperands; i++)
1332     Dest[i] = getMDNodeOperandImpl(Context, N, i);
1333 }
1334
1335 void LLVMReplaceMDNodeOperandWith(LLVMValueRef V, unsigned Index,
1336                                   LLVMMetadataRef Replacement) {
1337   auto *MD = cast<MetadataAsValue>(unwrap(V));
1338   auto *N = cast<MDNode>(MD->getMetadata());
1339   N->replaceOperandWith(Index, unwrap<Metadata>(Replacement));
1340 }
1341
1342 unsigned LLVMGetNamedMetadataNumOperands(LLVMModuleRef M, const char *Name) {
1343   if (NamedMDNode *N = unwrap(M)->getNamedMetadata(Name)) {
1344     return N->getNumOperands();
1345   }
1346   return 0;
1347 }
1348
1349 void LLVMGetNamedMetadataOperands(LLVMModuleRef M, const char *Name,
1350                                   LLVMValueRef *Dest) {
1351   NamedMDNode *N = unwrap(M)->getNamedMetadata(Name);
1352   if (!N)
1353     return;
1354   LLVMContext &Context = unwrap(M)->getContext();
1355   for (unsigned i=0;i<N->getNumOperands();i++)
1356     Dest[i] = wrap(MetadataAsValue::get(Context, N->getOperand(i)));
1357 }
1358
1359 void LLVMAddNamedMetadataOperand(LLVMModuleRef M, const char *Name,
1360                                  LLVMValueRef Val) {
1361   NamedMDNode *N = unwrap(M)->getOrInsertNamedMetadata(Name);
1362   if (!N)
1363     return;
1364   if (!Val)
1365     return;
1366   N->addOperand(extractMDNode(unwrap<MetadataAsValue>(Val)));
1367 }
1368
1369 const char *LLVMGetDebugLocDirectory(LLVMValueRef Val, unsigned *Length) {
1370   if (!Length) return nullptr;
1371   StringRef S;
1372   if (const auto *I = dyn_cast<Instruction>(unwrap(Val))) {
1373     if (const auto &DL = I->getDebugLoc()) {
1374       S = DL->getDirectory();
1375     }
1376   } else if (const auto *GV = dyn_cast<GlobalVariable>(unwrap(Val))) {
1377     SmallVector<DIGlobalVariableExpression *, 1> GVEs;
1378     GV->getDebugInfo(GVEs);
1379     if (GVEs.size())
1380       if (const DIGlobalVariable *DGV = GVEs[0]->getVariable())
1381         S = DGV->getDirectory();
1382   } else if (const auto *F = dyn_cast<Function>(unwrap(Val))) {
1383     if (const DISubprogram *DSP = F->getSubprogram())
1384       S = DSP->getDirectory();
1385   } else {
1386     assert(0 && "Expected Instruction, GlobalVariable or Function");
1387     return nullptr;
1388   }
1389   *Length = S.size();
1390   return S.data();
1391 }
1392
1393 const char *LLVMGetDebugLocFilename(LLVMValueRef Val, unsigned *Length) {
1394   if (!Length) return nullptr;
1395   StringRef S;
1396   if (const auto *I = dyn_cast<Instruction>(unwrap(Val))) {
1397     if (const auto &DL = I->getDebugLoc()) {
1398       S = DL->getFilename();
1399     }
1400   } else if (const auto *GV = dyn_cast<GlobalVariable>(unwrap(Val))) {
1401     SmallVector<DIGlobalVariableExpression *, 1> GVEs;
1402     GV->getDebugInfo(GVEs);
1403     if (GVEs.size())
1404       if (const DIGlobalVariable *DGV = GVEs[0]->getVariable())
1405         S = DGV->getFilename();
1406   } else if (const auto *F = dyn_cast<Function>(unwrap(Val))) {
1407     if (const DISubprogram *DSP = F->getSubprogram())
1408       S = DSP->getFilename();
1409   } else {
1410     assert(0 && "Expected Instruction, GlobalVariable or Function");
1411     return nullptr;
1412   }
1413   *Length = S.size();
1414   return S.data();
1415 }
1416
1417 unsigned LLVMGetDebugLocLine(LLVMValueRef Val) {
1418   unsigned L = 0;
1419   if (const auto *I = dyn_cast<Instruction>(unwrap(Val))) {
1420     if (const auto &DL = I->getDebugLoc()) {
1421       L = DL->getLine();
1422     }
1423   } else if (const auto *GV = dyn_cast<GlobalVariable>(unwrap(Val))) {
1424     SmallVector<DIGlobalVariableExpression *, 1> GVEs;
1425     GV->getDebugInfo(GVEs);
1426     if (GVEs.size())
1427       if (const DIGlobalVariable *DGV = GVEs[0]->getVariable())
1428         L = DGV->getLine();
1429   } else if (const auto *F = dyn_cast<Function>(unwrap(Val))) {
1430     if (const DISubprogram *DSP = F->getSubprogram())
1431       L = DSP->getLine();
1432   } else {
1433     assert(0 && "Expected Instruction, GlobalVariable or Function");
1434     return -1;
1435   }
1436   return L;
1437 }
1438
1439 unsigned LLVMGetDebugLocColumn(LLVMValueRef Val) {
1440   unsigned C = 0;
1441   if (const auto *I = dyn_cast<Instruction>(unwrap(Val)))
1442     if (const auto &DL = I->getDebugLoc())
1443       C = DL->getColumn();
1444   return C;
1445 }
1446
1447 /*--.. Operations on scalar constants ......................................--*/
1448
1449 LLVMValueRef LLVMConstInt(LLVMTypeRef IntTy, unsigned long long N,
1450                           LLVMBool SignExtend) {
1451   return wrap(ConstantInt::get(unwrap<IntegerType>(IntTy), N, SignExtend != 0));
1452 }
1453
1454 LLVMValueRef LLVMConstIntOfArbitraryPrecision(LLVMTypeRef IntTy,
1455                                               unsigned NumWords,
1456                                               const uint64_t Words[]) {
1457     IntegerType *Ty = unwrap<IntegerType>(IntTy);
1458     return wrap(ConstantInt::get(
1459         Ty->getContext(), APInt(Ty->getBitWidth(), ArrayRef(Words, NumWords))));
1460 }
1461
1462 LLVMValueRef LLVMConstIntOfString(LLVMTypeRef IntTy, const char Str[],
1463                                   uint8_t Radix) {
1464   return wrap(ConstantInt::get(unwrap<IntegerType>(IntTy), StringRef(Str),
1465                                Radix));
1466 }
1467
1468 LLVMValueRef LLVMConstIntOfStringAndSize(LLVMTypeRef IntTy, const char Str[],
1469                                          unsigned SLen, uint8_t Radix) {
1470   return wrap(ConstantInt::get(unwrap<IntegerType>(IntTy), StringRef(Str, SLen),
1471                                Radix));
1472 }
1473
1474 LLVMValueRef LLVMConstReal(LLVMTypeRef RealTy, double N) {
1475   return wrap(ConstantFP::get(unwrap(RealTy), N));
1476 }
1477
1478 LLVMValueRef LLVMConstRealOfString(LLVMTypeRef RealTy, const char *Text) {
1479   return wrap(ConstantFP::get(unwrap(RealTy), StringRef(Text)));
1480 }
1481
1482 LLVMValueRef LLVMConstRealOfStringAndSize(LLVMTypeRef RealTy, const char Str[],
1483                                           unsigned SLen) {
1484   return wrap(ConstantFP::get(unwrap(RealTy), StringRef(Str, SLen)));
1485 }
1486
1487 unsigned long long LLVMConstIntGetZExtValue(LLVMValueRef ConstantVal) {
1488   return unwrap<ConstantInt>(ConstantVal)->getZExtValue();
1489 }
1490
1491 long long LLVMConstIntGetSExtValue(LLVMValueRef ConstantVal) {
1492   return unwrap<ConstantInt>(ConstantVal)->getSExtValue();
1493 }
1494
1495 double LLVMConstRealGetDouble(LLVMValueRef ConstantVal, LLVMBool *LosesInfo) {
1496   ConstantFP *cFP = unwrap<ConstantFP>(ConstantVal) ;
1497   Type *Ty = cFP->getType();
1498
1499   if (Ty->isHalfTy() || Ty->isBFloatTy() || Ty->isFloatTy() ||
1500       Ty->isDoubleTy()) {
1501     *LosesInfo = false;
1502     return cFP->getValueAPF().convertToDouble();
1503   }
1504
1505   bool APFLosesInfo;
1506   APFloat APF = cFP->getValueAPF();
1507   APF.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven, &APFLosesInfo);
1508   *LosesInfo = APFLosesInfo;
1509   return APF.convertToDouble();
1510 }
1511
1512 /*--.. Operations on composite constants ...................................--*/
1513
1514 LLVMValueRef LLVMConstStringInContext(LLVMContextRef C, const char *Str,
1515                                       unsigned Length,
1516                                       LLVMBool DontNullTerminate) {
1517   /* Inverted the sense of AddNull because ', 0)' is a
1518      better mnemonic for null termination than ', 1)'. */
1519   return wrap(ConstantDataArray::getString(*unwrap(C), StringRef(Str, Length),
1520                                            DontNullTerminate == 0));
1521 }
1522
1523 LLVMValueRef LLVMConstString(const char *Str, unsigned Length,
1524                              LLVMBool DontNullTerminate) {
1525   return LLVMConstStringInContext(LLVMGetGlobalContext(), Str, Length,
1526                                   DontNullTerminate);
1527 }
1528
1529 LLVMValueRef LLVMGetAggregateElement(LLVMValueRef C, unsigned Idx) {
1530   return wrap(unwrap<Constant>(C)->getAggregateElement(Idx));
1531 }
1532
1533 LLVMValueRef LLVMGetElementAsConstant(LLVMValueRef C, unsigned idx) {
1534   return wrap(unwrap<ConstantDataSequential>(C)->getElementAsConstant(idx));
1535 }
1536
1537 LLVMBool LLVMIsConstantString(LLVMValueRef C) {
1538   return unwrap<ConstantDataSequential>(C)->isString();
1539 }
1540
1541 const char *LLVMGetAsString(LLVMValueRef C, size_t *Length) {
1542   StringRef Str = unwrap<ConstantDataSequential>(C)->getAsString();
1543   *Length = Str.size();
1544   return Str.data();
1545 }
1546
1547 LLVMValueRef LLVMConstArray(LLVMTypeRef ElementTy,
1548                             LLVMValueRef *ConstantVals, unsigned Length) {
1549   ArrayRef<Constant*> V(unwrap<Constant>(ConstantVals, Length), Length);
1550   return wrap(ConstantArray::get(ArrayType::get(unwrap(ElementTy), Length), V));
1551 }
1552
1553 LLVMValueRef LLVMConstArray2(LLVMTypeRef ElementTy, LLVMValueRef *ConstantVals,
1554                              uint64_t Length) {
1555   ArrayRef<Constant *> V(unwrap<Constant>(ConstantVals, Length), Length);
1556   return wrap(ConstantArray::get(ArrayType::get(unwrap(ElementTy), Length), V));
1557 }
1558
1559 LLVMValueRef LLVMConstStructInContext(LLVMContextRef C,
1560                                       LLVMValueRef *ConstantVals,
1561                                       unsigned Count, LLVMBool Packed) {
1562   Constant **Elements = unwrap<Constant>(ConstantVals, Count);
1563   return wrap(ConstantStruct::getAnon(*unwrap(C), ArrayRef(Elements, Count),
1564                                       Packed != 0));
1565 }
1566
1567 LLVMValueRef LLVMConstStruct(LLVMValueRef *ConstantVals, unsigned Count,
1568                              LLVMBool Packed) {
1569   return LLVMConstStructInContext(LLVMGetGlobalContext(), ConstantVals, Count,
1570                                   Packed);
1571 }
1572
1573 LLVMValueRef LLVMConstNamedStruct(LLVMTypeRef StructTy,
1574                                   LLVMValueRef *ConstantVals,
1575                                   unsigned Count) {
1576   Constant **Elements = unwrap<Constant>(ConstantVals, Count);
1577   StructType *Ty = unwrap<StructType>(StructTy);
1578
1579   return wrap(ConstantStruct::get(Ty, ArrayRef(Elements, Count)));
1580 }
1581
1582 LLVMValueRef LLVMConstVector(LLVMValueRef *ScalarConstantVals, unsigned Size) {
1583   return wrap(ConstantVector::get(
1584       ArrayRef(unwrap<Constant>(ScalarConstantVals, Size), Size)));
1585 }
1586
1587 /*-- Opcode mapping */
1588
1589 static LLVMOpcode map_to_llvmopcode(int opcode)
1590 {
1591     switch (opcode) {
1592       default: llvm_unreachable("Unhandled Opcode.");
1593 #define HANDLE_INST(num, opc, clas) case num: return LLVM##opc;
1594 #include "llvm/IR/Instruction.def"
1595 #undef HANDLE_INST
1596     }
1597 }
1598
1599 static int map_from_llvmopcode(LLVMOpcode code)
1600 {
1601     switch (code) {
1602 #define HANDLE_INST(num, opc, clas) case LLVM##opc: return num;
1603 #include "llvm/IR/Instruction.def"
1604 #undef HANDLE_INST
1605     }
1606     llvm_unreachable("Unhandled Opcode.");
1607 }
1608
1609 /*--.. Constant expressions ................................................--*/
1610
1611 LLVMOpcode LLVMGetConstOpcode(LLVMValueRef ConstantVal) {
1612   return map_to_llvmopcode(unwrap<ConstantExpr>(ConstantVal)->getOpcode());
1613 }
1614
1615 LLVMValueRef LLVMAlignOf(LLVMTypeRef Ty) {
1616   return wrap(ConstantExpr::getAlignOf(unwrap(Ty)));
1617 }
1618
1619 LLVMValueRef LLVMSizeOf(LLVMTypeRef Ty) {
1620   return wrap(ConstantExpr::getSizeOf(unwrap(Ty)));
1621 }
1622
1623 LLVMValueRef LLVMConstNeg(LLVMValueRef ConstantVal) {
1624   return wrap(ConstantExpr::getNeg(unwrap<Constant>(ConstantVal)));
1625 }
1626
1627 LLVMValueRef LLVMConstNSWNeg(LLVMValueRef ConstantVal) {
1628   return wrap(ConstantExpr::getNSWNeg(unwrap<Constant>(ConstantVal)));
1629 }
1630
1631 LLVMValueRef LLVMConstNUWNeg(LLVMValueRef ConstantVal) {
1632   return wrap(ConstantExpr::getNUWNeg(unwrap<Constant>(ConstantVal)));
1633 }
1634
1635
1636 LLVMValueRef LLVMConstNot(LLVMValueRef ConstantVal) {
1637   return wrap(ConstantExpr::getNot(unwrap<Constant>(ConstantVal)));
1638 }
1639
1640 LLVMValueRef LLVMConstAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
1641   return wrap(ConstantExpr::getAdd(unwrap<Constant>(LHSConstant),
1642                                    unwrap<Constant>(RHSConstant)));
1643 }
1644
1645 LLVMValueRef LLVMConstNSWAdd(LLVMValueRef LHSConstant,
1646                              LLVMValueRef RHSConstant) {
1647   return wrap(ConstantExpr::getNSWAdd(unwrap<Constant>(LHSConstant),
1648                                       unwrap<Constant>(RHSConstant)));
1649 }
1650
1651 LLVMValueRef LLVMConstNUWAdd(LLVMValueRef LHSConstant,
1652                              LLVMValueRef RHSConstant) {
1653   return wrap(ConstantExpr::getNUWAdd(unwrap<Constant>(LHSConstant),
1654                                       unwrap<Constant>(RHSConstant)));
1655 }
1656
1657 LLVMValueRef LLVMConstSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
1658   return wrap(ConstantExpr::getSub(unwrap<Constant>(LHSConstant),
1659                                    unwrap<Constant>(RHSConstant)));
1660 }
1661
1662 LLVMValueRef LLVMConstNSWSub(LLVMValueRef LHSConstant,
1663                              LLVMValueRef RHSConstant) {
1664   return wrap(ConstantExpr::getNSWSub(unwrap<Constant>(LHSConstant),
1665                                       unwrap<Constant>(RHSConstant)));
1666 }
1667
1668 LLVMValueRef LLVMConstNUWSub(LLVMValueRef LHSConstant,
1669                              LLVMValueRef RHSConstant) {
1670   return wrap(ConstantExpr::getNUWSub(unwrap<Constant>(LHSConstant),
1671                                       unwrap<Constant>(RHSConstant)));
1672 }
1673
1674 LLVMValueRef LLVMConstMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
1675   return wrap(ConstantExpr::getMul(unwrap<Constant>(LHSConstant),
1676                                    unwrap<Constant>(RHSConstant)));
1677 }
1678
1679 LLVMValueRef LLVMConstNSWMul(LLVMValueRef LHSConstant,
1680                              LLVMValueRef RHSConstant) {
1681   return wrap(ConstantExpr::getNSWMul(unwrap<Constant>(LHSConstant),
1682                                       unwrap<Constant>(RHSConstant)));
1683 }
1684
1685 LLVMValueRef LLVMConstNUWMul(LLVMValueRef LHSConstant,
1686                              LLVMValueRef RHSConstant) {
1687   return wrap(ConstantExpr::getNUWMul(unwrap<Constant>(LHSConstant),
1688                                       unwrap<Constant>(RHSConstant)));
1689 }
1690
1691 LLVMValueRef LLVMConstXor(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
1692   return wrap(ConstantExpr::getXor(unwrap<Constant>(LHSConstant),
1693                                    unwrap<Constant>(RHSConstant)));
1694 }
1695
1696 LLVMValueRef LLVMConstICmp(LLVMIntPredicate Predicate,
1697                            LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
1698   return wrap(ConstantExpr::getICmp(Predicate,
1699                                     unwrap<Constant>(LHSConstant),
1700                                     unwrap<Constant>(RHSConstant)));
1701 }
1702
1703 LLVMValueRef LLVMConstFCmp(LLVMRealPredicate Predicate,
1704                            LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
1705   return wrap(ConstantExpr::getFCmp(Predicate,
1706                                     unwrap<Constant>(LHSConstant),
1707                                     unwrap<Constant>(RHSConstant)));
1708 }
1709
1710 LLVMValueRef LLVMConstShl(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
1711   return wrap(ConstantExpr::getShl(unwrap<Constant>(LHSConstant),
1712                                    unwrap<Constant>(RHSConstant)));
1713 }
1714
1715 LLVMValueRef LLVMConstLShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
1716   return wrap(ConstantExpr::getLShr(unwrap<Constant>(LHSConstant),
1717                                     unwrap<Constant>(RHSConstant)));
1718 }
1719
1720 LLVMValueRef LLVMConstAShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
1721   return wrap(ConstantExpr::getAShr(unwrap<Constant>(LHSConstant),
1722                                     unwrap<Constant>(RHSConstant)));
1723 }
1724
1725 LLVMValueRef LLVMConstGEP2(LLVMTypeRef Ty, LLVMValueRef ConstantVal,
1726                            LLVMValueRef *ConstantIndices, unsigned NumIndices) {
1727   ArrayRef<Constant *> IdxList(unwrap<Constant>(ConstantIndices, NumIndices),
1728                                NumIndices);
1729   Constant *Val = unwrap<Constant>(ConstantVal);
1730   return wrap(ConstantExpr::getGetElementPtr(unwrap(Ty), Val, IdxList));
1731 }
1732
1733 LLVMValueRef LLVMConstInBoundsGEP2(LLVMTypeRef Ty, LLVMValueRef ConstantVal,
1734                                    LLVMValueRef *ConstantIndices,
1735                                    unsigned NumIndices) {
1736   ArrayRef<Constant *> IdxList(unwrap<Constant>(ConstantIndices, NumIndices),
1737                                NumIndices);
1738   Constant *Val = unwrap<Constant>(ConstantVal);
1739   return wrap(ConstantExpr::getInBoundsGetElementPtr(unwrap(Ty), Val, IdxList));
1740 }
1741
1742 LLVMValueRef LLVMConstTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType) {
1743   return wrap(ConstantExpr::getTrunc(unwrap<Constant>(ConstantVal),
1744                                      unwrap(ToType)));
1745 }
1746
1747 LLVMValueRef LLVMConstSExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType) {
1748   return wrap(ConstantExpr::getSExt(unwrap<Constant>(ConstantVal),
1749                                     unwrap(ToType)));
1750 }
1751
1752 LLVMValueRef LLVMConstZExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType) {
1753   return wrap(ConstantExpr::getZExt(unwrap<Constant>(ConstantVal),
1754                                     unwrap(ToType)));
1755 }
1756
1757 LLVMValueRef LLVMConstFPTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType) {
1758   return wrap(ConstantExpr::getFPTrunc(unwrap<Constant>(ConstantVal),
1759                                        unwrap(ToType)));
1760 }
1761
1762 LLVMValueRef LLVMConstFPExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType) {
1763   return wrap(ConstantExpr::getFPExtend(unwrap<Constant>(ConstantVal),
1764                                         unwrap(ToType)));
1765 }
1766
1767 LLVMValueRef LLVMConstUIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType) {
1768   return wrap(ConstantExpr::getUIToFP(unwrap<Constant>(ConstantVal),
1769                                       unwrap(ToType)));
1770 }
1771
1772 LLVMValueRef LLVMConstSIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType) {
1773   return wrap(ConstantExpr::getSIToFP(unwrap<Constant>(ConstantVal),
1774                                       unwrap(ToType)));
1775 }
1776
1777 LLVMValueRef LLVMConstFPToUI(LLVMValueRef ConstantVal, LLVMTypeRef ToType) {
1778   return wrap(ConstantExpr::getFPToUI(unwrap<Constant>(ConstantVal),
1779                                       unwrap(ToType)));
1780 }
1781
1782 LLVMValueRef LLVMConstFPToSI(LLVMValueRef ConstantVal, LLVMTypeRef ToType) {
1783   return wrap(ConstantExpr::getFPToSI(unwrap<Constant>(ConstantVal),
1784                                       unwrap(ToType)));
1785 }
1786
1787 LLVMValueRef LLVMConstPtrToInt(LLVMValueRef ConstantVal, LLVMTypeRef ToType) {
1788   return wrap(ConstantExpr::getPtrToInt(unwrap<Constant>(ConstantVal),
1789                                         unwrap(ToType)));
1790 }
1791
1792 LLVMValueRef LLVMConstIntToPtr(LLVMValueRef ConstantVal, LLVMTypeRef ToType) {
1793   return wrap(ConstantExpr::getIntToPtr(unwrap<Constant>(ConstantVal),
1794                                         unwrap(ToType)));
1795 }
1796
1797 LLVMValueRef LLVMConstBitCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType) {
1798   return wrap(ConstantExpr::getBitCast(unwrap<Constant>(ConstantVal),
1799                                        unwrap(ToType)));
1800 }
1801
1802 LLVMValueRef LLVMConstAddrSpaceCast(LLVMValueRef ConstantVal,
1803                                     LLVMTypeRef ToType) {
1804   return wrap(ConstantExpr::getAddrSpaceCast(unwrap<Constant>(ConstantVal),
1805                                              unwrap(ToType)));
1806 }
1807
1808 LLVMValueRef LLVMConstZExtOrBitCast(LLVMValueRef ConstantVal,
1809                                     LLVMTypeRef ToType) {
1810   return wrap(ConstantExpr::getZExtOrBitCast(unwrap<Constant>(ConstantVal),
1811                                              unwrap(ToType)));
1812 }
1813
1814 LLVMValueRef LLVMConstSExtOrBitCast(LLVMValueRef ConstantVal,
1815                                     LLVMTypeRef ToType) {
1816   return wrap(ConstantExpr::getSExtOrBitCast(unwrap<Constant>(ConstantVal),
1817                                              unwrap(ToType)));
1818 }
1819
1820 LLVMValueRef LLVMConstTruncOrBitCast(LLVMValueRef ConstantVal,
1821                                      LLVMTypeRef ToType) {
1822   return wrap(ConstantExpr::getTruncOrBitCast(unwrap<Constant>(ConstantVal),
1823                                               unwrap(ToType)));
1824 }
1825
1826 LLVMValueRef LLVMConstPointerCast(LLVMValueRef ConstantVal,
1827                                   LLVMTypeRef ToType) {
1828   return wrap(ConstantExpr::getPointerCast(unwrap<Constant>(ConstantVal),
1829                                            unwrap(ToType)));
1830 }
1831
1832 LLVMValueRef LLVMConstIntCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType,
1833                               LLVMBool isSigned) {
1834   return wrap(ConstantExpr::getIntegerCast(unwrap<Constant>(ConstantVal),
1835                                            unwrap(ToType), isSigned));
1836 }
1837
1838 LLVMValueRef LLVMConstFPCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType) {
1839   return wrap(ConstantExpr::getFPCast(unwrap<Constant>(ConstantVal),
1840                                       unwrap(ToType)));
1841 }
1842
1843 LLVMValueRef LLVMConstExtractElement(LLVMValueRef VectorConstant,
1844                                      LLVMValueRef IndexConstant) {
1845   return wrap(ConstantExpr::getExtractElement(unwrap<Constant>(VectorConstant),
1846                                               unwrap<Constant>(IndexConstant)));
1847 }
1848
1849 LLVMValueRef LLVMConstInsertElement(LLVMValueRef VectorConstant,
1850                                     LLVMValueRef ElementValueConstant,
1851                                     LLVMValueRef IndexConstant) {
1852   return wrap(ConstantExpr::getInsertElement(unwrap<Constant>(VectorConstant),
1853                                          unwrap<Constant>(ElementValueConstant),
1854                                              unwrap<Constant>(IndexConstant)));
1855 }
1856
1857 LLVMValueRef LLVMConstShuffleVector(LLVMValueRef VectorAConstant,
1858                                     LLVMValueRef VectorBConstant,
1859                                     LLVMValueRef MaskConstant) {
1860   SmallVector<int, 16> IntMask;
1861   ShuffleVectorInst::getShuffleMask(unwrap<Constant>(MaskConstant), IntMask);
1862   return wrap(ConstantExpr::getShuffleVector(unwrap<Constant>(VectorAConstant),
1863                                              unwrap<Constant>(VectorBConstant),
1864                                              IntMask));
1865 }
1866
1867 LLVMValueRef LLVMConstInlineAsm(LLVMTypeRef Ty, const char *AsmString,
1868                                 const char *Constraints,
1869                                 LLVMBool HasSideEffects,
1870                                 LLVMBool IsAlignStack) {
1871   return wrap(InlineAsm::get(dyn_cast<FunctionType>(unwrap(Ty)), AsmString,
1872                              Constraints, HasSideEffects, IsAlignStack));
1873 }
1874
1875 LLVMValueRef LLVMBlockAddress(LLVMValueRef F, LLVMBasicBlockRef BB) {
1876   return wrap(BlockAddress::get(unwrap<Function>(F), unwrap(BB)));
1877 }
1878
1879 /*--.. Operations on global variables, functions, and aliases (globals) ....--*/
1880
1881 LLVMModuleRef LLVMGetGlobalParent(LLVMValueRef Global) {
1882   return wrap(unwrap<GlobalValue>(Global)->getParent());
1883 }
1884
1885 LLVMBool LLVMIsDeclaration(LLVMValueRef Global) {
1886   return unwrap<GlobalValue>(Global)->isDeclaration();
1887 }
1888
1889 LLVMLinkage LLVMGetLinkage(LLVMValueRef Global) {
1890   switch (unwrap<GlobalValue>(Global)->getLinkage()) {
1891   case GlobalValue::ExternalLinkage:
1892     return LLVMExternalLinkage;
1893   case GlobalValue::AvailableExternallyLinkage:
1894     return LLVMAvailableExternallyLinkage;
1895   case GlobalValue::LinkOnceAnyLinkage:
1896     return LLVMLinkOnceAnyLinkage;
1897   case GlobalValue::LinkOnceODRLinkage:
1898     return LLVMLinkOnceODRLinkage;
1899   case GlobalValue::WeakAnyLinkage:
1900     return LLVMWeakAnyLinkage;
1901   case GlobalValue::WeakODRLinkage:
1902     return LLVMWeakODRLinkage;
1903   case GlobalValue::AppendingLinkage:
1904     return LLVMAppendingLinkage;
1905   case GlobalValue::InternalLinkage:
1906     return LLVMInternalLinkage;
1907   case GlobalValue::PrivateLinkage:
1908     return LLVMPrivateLinkage;
1909   case GlobalValue::ExternalWeakLinkage:
1910     return LLVMExternalWeakLinkage;
1911   case GlobalValue::CommonLinkage:
1912     return LLVMCommonLinkage;
1913   }
1914
1915   llvm_unreachable("Invalid GlobalValue linkage!");
1916 }
1917
1918 void LLVMSetLinkage(LLVMValueRef Global, LLVMLinkage Linkage) {
1919   GlobalValue *GV = unwrap<GlobalValue>(Global);
1920
1921   switch (Linkage) {
1922   case LLVMExternalLinkage:
1923     GV->setLinkage(GlobalValue::ExternalLinkage);
1924     break;
1925   case LLVMAvailableExternallyLinkage:
1926     GV->setLinkage(GlobalValue::AvailableExternallyLinkage);
1927     break;
1928   case LLVMLinkOnceAnyLinkage:
1929     GV->setLinkage(GlobalValue::LinkOnceAnyLinkage);
1930     break;
1931   case LLVMLinkOnceODRLinkage:
1932     GV->setLinkage(GlobalValue::LinkOnceODRLinkage);
1933     break;
1934   case LLVMLinkOnceODRAutoHideLinkage:
1935     LLVM_DEBUG(
1936         errs() << "LLVMSetLinkage(): LLVMLinkOnceODRAutoHideLinkage is no "
1937                   "longer supported.");
1938     break;
1939   case LLVMWeakAnyLinkage:
1940     GV->setLinkage(GlobalValue::WeakAnyLinkage);
1941     break;
1942   case LLVMWeakODRLinkage:
1943     GV->setLinkage(GlobalValue::WeakODRLinkage);
1944     break;
1945   case LLVMAppendingLinkage:
1946     GV->setLinkage(GlobalValue::AppendingLinkage);
1947     break;
1948   case LLVMInternalLinkage:
1949     GV->setLinkage(GlobalValue::InternalLinkage);
1950     break;
1951   case LLVMPrivateLinkage:
1952     GV->setLinkage(GlobalValue::PrivateLinkage);
1953     break;
1954   case LLVMLinkerPrivateLinkage:
1955     GV->setLinkage(GlobalValue::PrivateLinkage);
1956     break;
1957   case LLVMLinkerPrivateWeakLinkage:
1958     GV->setLinkage(GlobalValue::PrivateLinkage);
1959     break;
1960   case LLVMDLLImportLinkage:
1961     LLVM_DEBUG(
1962         errs()
1963         << "LLVMSetLinkage(): LLVMDLLImportLinkage is no longer supported.");
1964     break;
1965   case LLVMDLLExportLinkage:
1966     LLVM_DEBUG(
1967         errs()
1968         << "LLVMSetLinkage(): LLVMDLLExportLinkage is no longer supported.");
1969     break;
1970   case LLVMExternalWeakLinkage:
1971     GV->setLinkage(GlobalValue::ExternalWeakLinkage);
1972     break;
1973   case LLVMGhostLinkage:
1974     LLVM_DEBUG(
1975         errs() << "LLVMSetLinkage(): LLVMGhostLinkage is no longer supported.");
1976     break;
1977   case LLVMCommonLinkage:
1978     GV->setLinkage(GlobalValue::CommonLinkage);
1979     break;
1980   }
1981 }
1982
1983 const char *LLVMGetSection(LLVMValueRef Global) {
1984   // Using .data() is safe because of how GlobalObject::setSection is
1985   // implemented.
1986   return unwrap<GlobalValue>(Global)->getSection().data();
1987 }
1988
1989 void LLVMSetSection(LLVMValueRef Global, const char *Section) {
1990   unwrap<GlobalObject>(Global)->setSection(Section);
1991 }
1992
1993 LLVMVisibility LLVMGetVisibility(LLVMValueRef Global) {
1994   return static_cast<LLVMVisibility>(
1995     unwrap<GlobalValue>(Global)->getVisibility());
1996 }
1997
1998 void LLVMSetVisibility(LLVMValueRef Global, LLVMVisibility Viz) {
1999   unwrap<GlobalValue>(Global)
2000     ->setVisibility(static_cast<GlobalValue::VisibilityTypes>(Viz));
2001 }
2002
2003 LLVMDLLStorageClass LLVMGetDLLStorageClass(LLVMValueRef Global) {
2004   return static_cast<LLVMDLLStorageClass>(
2005       unwrap<GlobalValue>(Global)->getDLLStorageClass());
2006 }
2007
2008 void LLVMSetDLLStorageClass(LLVMValueRef Global, LLVMDLLStorageClass Class) {
2009   unwrap<GlobalValue>(Global)->setDLLStorageClass(
2010       static_cast<GlobalValue::DLLStorageClassTypes>(Class));
2011 }
2012
2013 LLVMUnnamedAddr LLVMGetUnnamedAddress(LLVMValueRef Global) {
2014   switch (unwrap<GlobalValue>(Global)->getUnnamedAddr()) {
2015   case GlobalVariable::UnnamedAddr::None:
2016     return LLVMNoUnnamedAddr;
2017   case GlobalVariable::UnnamedAddr::Local:
2018     return LLVMLocalUnnamedAddr;
2019   case GlobalVariable::UnnamedAddr::Global:
2020     return LLVMGlobalUnnamedAddr;
2021   }
2022   llvm_unreachable("Unknown UnnamedAddr kind!");
2023 }
2024
2025 void LLVMSetUnnamedAddress(LLVMValueRef Global, LLVMUnnamedAddr UnnamedAddr) {
2026   GlobalValue *GV = unwrap<GlobalValue>(Global);
2027
2028   switch (UnnamedAddr) {
2029   case LLVMNoUnnamedAddr:
2030     return GV->setUnnamedAddr(GlobalVariable::UnnamedAddr::None);
2031   case LLVMLocalUnnamedAddr:
2032     return GV->setUnnamedAddr(GlobalVariable::UnnamedAddr::Local);
2033   case LLVMGlobalUnnamedAddr:
2034     return GV->setUnnamedAddr(GlobalVariable::UnnamedAddr::Global);
2035   }
2036 }
2037
2038 LLVMBool LLVMHasUnnamedAddr(LLVMValueRef Global) {
2039   return unwrap<GlobalValue>(Global)->hasGlobalUnnamedAddr();
2040 }
2041
2042 void LLVMSetUnnamedAddr(LLVMValueRef Global, LLVMBool HasUnnamedAddr) {
2043   unwrap<GlobalValue>(Global)->setUnnamedAddr(
2044       HasUnnamedAddr ? GlobalValue::UnnamedAddr::Global
2045                      : GlobalValue::UnnamedAddr::None);
2046 }
2047
2048 LLVMTypeRef LLVMGlobalGetValueType(LLVMValueRef Global) {
2049   return wrap(unwrap<GlobalValue>(Global)->getValueType());
2050 }
2051
2052 /*--.. Operations on global variables, load and store instructions .........--*/
2053
2054 unsigned LLVMGetAlignment(LLVMValueRef V) {
2055   Value *P = unwrap(V);
2056   if (GlobalObject *GV = dyn_cast<GlobalObject>(P))
2057     return GV->getAlign() ? GV->getAlign()->value() : 0;
2058   if (AllocaInst *AI = dyn_cast<AllocaInst>(P))
2059     return AI->getAlign().value();
2060   if (LoadInst *LI = dyn_cast<LoadInst>(P))
2061     return LI->getAlign().value();
2062   if (StoreInst *SI = dyn_cast<StoreInst>(P))
2063     return SI->getAlign().value();
2064   if (AtomicRMWInst *RMWI = dyn_cast<AtomicRMWInst>(P))
2065     return RMWI->getAlign().value();
2066   if (AtomicCmpXchgInst *CXI = dyn_cast<AtomicCmpXchgInst>(P))
2067     return CXI->getAlign().value();
2068
2069   llvm_unreachable(
2070       "only GlobalValue, AllocaInst, LoadInst, StoreInst, AtomicRMWInst, "
2071       "and AtomicCmpXchgInst have alignment");
2072 }
2073
2074 void LLVMSetAlignment(LLVMValueRef V, unsigned Bytes) {
2075   Value *P = unwrap(V);
2076   if (GlobalObject *GV = dyn_cast<GlobalObject>(P))
2077     GV->setAlignment(MaybeAlign(Bytes));
2078   else if (AllocaInst *AI = dyn_cast<AllocaInst>(P))
2079     AI->setAlignment(Align(Bytes));
2080   else if (LoadInst *LI = dyn_cast<LoadInst>(P))
2081     LI->setAlignment(Align(Bytes));
2082   else if (StoreInst *SI = dyn_cast<StoreInst>(P))
2083     SI->setAlignment(Align(Bytes));
2084   else if (AtomicRMWInst *RMWI = dyn_cast<AtomicRMWInst>(P))
2085     RMWI->setAlignment(Align(Bytes));
2086   else if (AtomicCmpXchgInst *CXI = dyn_cast<AtomicCmpXchgInst>(P))
2087     CXI->setAlignment(Align(Bytes));
2088   else
2089     llvm_unreachable(
2090         "only GlobalValue, AllocaInst, LoadInst, StoreInst, AtomicRMWInst, and "
2091         "and AtomicCmpXchgInst have alignment");
2092 }
2093
2094 LLVMValueMetadataEntry *LLVMGlobalCopyAllMetadata(LLVMValueRef Value,
2095                                                   size_t *NumEntries) {
2096   return llvm_getMetadata(NumEntries, [&Value](MetadataEntries &Entries) {
2097     Entries.clear();
2098     if (Instruction *Instr = dyn_cast<Instruction>(unwrap(Value))) {
2099       Instr->getAllMetadata(Entries);
2100     } else {
2101       unwrap<GlobalObject>(Value)->getAllMetadata(Entries);
2102     }
2103   });
2104 }
2105
2106 unsigned LLVMValueMetadataEntriesGetKind(LLVMValueMetadataEntry *Entries,
2107                                          unsigned Index) {
2108   LLVMOpaqueValueMetadataEntry MVE =
2109       static_cast<LLVMOpaqueValueMetadataEntry>(Entries[Index]);
2110   return MVE.Kind;
2111 }
2112
2113 LLVMMetadataRef
2114 LLVMValueMetadataEntriesGetMetadata(LLVMValueMetadataEntry *Entries,
2115                                     unsigned Index) {
2116   LLVMOpaqueValueMetadataEntry MVE =
2117       static_cast<LLVMOpaqueValueMetadataEntry>(Entries[Index]);
2118   return MVE.Metadata;
2119 }
2120
2121 void LLVMDisposeValueMetadataEntries(LLVMValueMetadataEntry *Entries) {
2122   free(Entries);
2123 }
2124
2125 void LLVMGlobalSetMetadata(LLVMValueRef Global, unsigned Kind,
2126                            LLVMMetadataRef MD) {
2127   unwrap<GlobalObject>(Global)->setMetadata(Kind, unwrap<MDNode>(MD));
2128 }
2129
2130 void LLVMGlobalEraseMetadata(LLVMValueRef Global, unsigned Kind) {
2131   unwrap<GlobalObject>(Global)->eraseMetadata(Kind);
2132 }
2133
2134 void LLVMGlobalClearMetadata(LLVMValueRef Global) {
2135   unwrap<GlobalObject>(Global)->clearMetadata();
2136 }
2137
2138 /*--.. Operations on global variables ......................................--*/
2139
2140 LLVMValueRef LLVMAddGlobal(LLVMModuleRef M, LLVMTypeRef Ty, const char *Name) {
2141   return wrap(new GlobalVariable(*unwrap(M), unwrap(Ty), false,
2142                                  GlobalValue::ExternalLinkage, nullptr, Name));
2143 }
2144
2145 LLVMValueRef LLVMAddGlobalInAddressSpace(LLVMModuleRef M, LLVMTypeRef Ty,
2146                                          const char *Name,
2147                                          unsigned AddressSpace) {
2148   return wrap(new GlobalVariable(*unwrap(M), unwrap(Ty), false,
2149                                  GlobalValue::ExternalLinkage, nullptr, Name,
2150                                  nullptr, GlobalVariable::NotThreadLocal,
2151                                  AddressSpace));
2152 }
2153
2154 LLVMValueRef LLVMGetNamedGlobal(LLVMModuleRef M, const char *Name) {
2155   return wrap(unwrap(M)->getNamedGlobal(Name));
2156 }
2157
2158 LLVMValueRef LLVMGetFirstGlobal(LLVMModuleRef M) {
2159   Module *Mod = unwrap(M);
2160   Module::global_iterator I = Mod->global_begin();
2161   if (I == Mod->global_end())
2162     return nullptr;
2163   return wrap(&*I);
2164 }
2165
2166 LLVMValueRef LLVMGetLastGlobal(LLVMModuleRef M) {
2167   Module *Mod = unwrap(M);
2168   Module::global_iterator I = Mod->global_end();
2169   if (I == Mod->global_begin())
2170     return nullptr;
2171   return wrap(&*--I);
2172 }
2173
2174 LLVMValueRef LLVMGetNextGlobal(LLVMValueRef GlobalVar) {
2175   GlobalVariable *GV = unwrap<GlobalVariable>(GlobalVar);
2176   Module::global_iterator I(GV);
2177   if (++I == GV->getParent()->global_end())
2178     return nullptr;
2179   return wrap(&*I);
2180 }
2181
2182 LLVMValueRef LLVMGetPreviousGlobal(LLVMValueRef GlobalVar) {
2183   GlobalVariable *GV = unwrap<GlobalVariable>(GlobalVar);
2184   Module::global_iterator I(GV);
2185   if (I == GV->getParent()->global_begin())
2186     return nullptr;
2187   return wrap(&*--I);
2188 }
2189
2190 void LLVMDeleteGlobal(LLVMValueRef GlobalVar) {
2191   unwrap<GlobalVariable>(GlobalVar)->eraseFromParent();
2192 }
2193
2194 LLVMValueRef LLVMGetInitializer(LLVMValueRef GlobalVar) {
2195   GlobalVariable* GV = unwrap<GlobalVariable>(GlobalVar);
2196   if ( !GV->hasInitializer() )
2197     return nullptr;
2198   return wrap(GV->getInitializer());
2199 }
2200
2201 void LLVMSetInitializer(LLVMValueRef GlobalVar, LLVMValueRef ConstantVal) {
2202   unwrap<GlobalVariable>(GlobalVar)
2203     ->setInitializer(unwrap<Constant>(ConstantVal));
2204 }
2205
2206 LLVMBool LLVMIsThreadLocal(LLVMValueRef GlobalVar) {
2207   return unwrap<GlobalVariable>(GlobalVar)->isThreadLocal();
2208 }
2209
2210 void LLVMSetThreadLocal(LLVMValueRef GlobalVar, LLVMBool IsThreadLocal) {
2211   unwrap<GlobalVariable>(GlobalVar)->setThreadLocal(IsThreadLocal != 0);
2212 }
2213
2214 LLVMBool LLVMIsGlobalConstant(LLVMValueRef GlobalVar) {
2215   return unwrap<GlobalVariable>(GlobalVar)->isConstant();
2216 }
2217
2218 void LLVMSetGlobalConstant(LLVMValueRef GlobalVar, LLVMBool IsConstant) {
2219   unwrap<GlobalVariable>(GlobalVar)->setConstant(IsConstant != 0);
2220 }
2221
2222 LLVMThreadLocalMode LLVMGetThreadLocalMode(LLVMValueRef GlobalVar) {
2223   switch (unwrap<GlobalVariable>(GlobalVar)->getThreadLocalMode()) {
2224   case GlobalVariable::NotThreadLocal:
2225     return LLVMNotThreadLocal;
2226   case GlobalVariable::GeneralDynamicTLSModel:
2227     return LLVMGeneralDynamicTLSModel;
2228   case GlobalVariable::LocalDynamicTLSModel:
2229     return LLVMLocalDynamicTLSModel;
2230   case GlobalVariable::InitialExecTLSModel:
2231     return LLVMInitialExecTLSModel;
2232   case GlobalVariable::LocalExecTLSModel:
2233     return LLVMLocalExecTLSModel;
2234   }
2235
2236   llvm_unreachable("Invalid GlobalVariable thread local mode");
2237 }
2238
2239 void LLVMSetThreadLocalMode(LLVMValueRef GlobalVar, LLVMThreadLocalMode Mode) {
2240   GlobalVariable *GV = unwrap<GlobalVariable>(GlobalVar);
2241
2242   switch (Mode) {
2243   case LLVMNotThreadLocal:
2244     GV->setThreadLocalMode(GlobalVariable::NotThreadLocal);
2245     break;
2246   case LLVMGeneralDynamicTLSModel:
2247     GV->setThreadLocalMode(GlobalVariable::GeneralDynamicTLSModel);
2248     break;
2249   case LLVMLocalDynamicTLSModel:
2250     GV->setThreadLocalMode(GlobalVariable::LocalDynamicTLSModel);
2251     break;
2252   case LLVMInitialExecTLSModel:
2253     GV->setThreadLocalMode(GlobalVariable::InitialExecTLSModel);
2254     break;
2255   case LLVMLocalExecTLSModel:
2256     GV->setThreadLocalMode(GlobalVariable::LocalExecTLSModel);
2257     break;
2258   }
2259 }
2260
2261 LLVMBool LLVMIsExternallyInitialized(LLVMValueRef GlobalVar) {
2262   return unwrap<GlobalVariable>(GlobalVar)->isExternallyInitialized();
2263 }
2264
2265 void LLVMSetExternallyInitialized(LLVMValueRef GlobalVar, LLVMBool IsExtInit) {
2266   unwrap<GlobalVariable>(GlobalVar)->setExternallyInitialized(IsExtInit);
2267 }
2268
2269 /*--.. Operations on aliases ......................................--*/
2270
2271 LLVMValueRef LLVMAddAlias2(LLVMModuleRef M, LLVMTypeRef ValueTy,
2272                            unsigned AddrSpace, LLVMValueRef Aliasee,
2273                            const char *Name) {
2274   return wrap(GlobalAlias::create(unwrap(ValueTy), AddrSpace,
2275                                   GlobalValue::ExternalLinkage, Name,
2276                                   unwrap<Constant>(Aliasee), unwrap(M)));
2277 }
2278
2279 LLVMValueRef LLVMGetNamedGlobalAlias(LLVMModuleRef M,
2280                                      const char *Name, size_t NameLen) {
2281   return wrap(unwrap(M)->getNamedAlias(StringRef(Name, NameLen)));
2282 }
2283
2284 LLVMValueRef LLVMGetFirstGlobalAlias(LLVMModuleRef M) {
2285   Module *Mod = unwrap(M);
2286   Module::alias_iterator I = Mod->alias_begin();
2287   if (I == Mod->alias_end())
2288     return nullptr;
2289   return wrap(&*I);
2290 }
2291
2292 LLVMValueRef LLVMGetLastGlobalAlias(LLVMModuleRef M) {
2293   Module *Mod = unwrap(M);
2294   Module::alias_iterator I = Mod->alias_end();
2295   if (I == Mod->alias_begin())
2296     return nullptr;
2297   return wrap(&*--I);
2298 }
2299
2300 LLVMValueRef LLVMGetNextGlobalAlias(LLVMValueRef GA) {
2301   GlobalAlias *Alias = unwrap<GlobalAlias>(GA);
2302   Module::alias_iterator I(Alias);
2303   if (++I == Alias->getParent()->alias_end())
2304     return nullptr;
2305   return wrap(&*I);
2306 }
2307
2308 LLVMValueRef LLVMGetPreviousGlobalAlias(LLVMValueRef GA) {
2309   GlobalAlias *Alias = unwrap<GlobalAlias>(GA);
2310   Module::alias_iterator I(Alias);
2311   if (I == Alias->getParent()->alias_begin())
2312     return nullptr;
2313   return wrap(&*--I);
2314 }
2315
2316 LLVMValueRef LLVMAliasGetAliasee(LLVMValueRef Alias) {
2317   return wrap(unwrap<GlobalAlias>(Alias)->getAliasee());
2318 }
2319
2320 void LLVMAliasSetAliasee(LLVMValueRef Alias, LLVMValueRef Aliasee) {
2321   unwrap<GlobalAlias>(Alias)->setAliasee(unwrap<Constant>(Aliasee));
2322 }
2323
2324 /*--.. Operations on functions .............................................--*/
2325
2326 LLVMValueRef LLVMAddFunction(LLVMModuleRef M, const char *Name,
2327                              LLVMTypeRef FunctionTy) {
2328   return wrap(Function::Create(unwrap<FunctionType>(FunctionTy),
2329                                GlobalValue::ExternalLinkage, Name, unwrap(M)));
2330 }
2331
2332 LLVMValueRef LLVMGetNamedFunction(LLVMModuleRef M, const char *Name) {
2333   return wrap(unwrap(M)->getFunction(Name));
2334 }
2335
2336 LLVMValueRef LLVMGetFirstFunction(LLVMModuleRef M) {
2337   Module *Mod = unwrap(M);
2338   Module::iterator I = Mod->begin();
2339   if (I == Mod->end())
2340     return nullptr;
2341   return wrap(&*I);
2342 }
2343
2344 LLVMValueRef LLVMGetLastFunction(LLVMModuleRef M) {
2345   Module *Mod = unwrap(M);
2346   Module::iterator I = Mod->end();
2347   if (I == Mod->begin())
2348     return nullptr;
2349   return wrap(&*--I);
2350 }
2351
2352 LLVMValueRef LLVMGetNextFunction(LLVMValueRef Fn) {
2353   Function *Func = unwrap<Function>(Fn);
2354   Module::iterator I(Func);
2355   if (++I == Func->getParent()->end())
2356     return nullptr;
2357   return wrap(&*I);
2358 }
2359
2360 LLVMValueRef LLVMGetPreviousFunction(LLVMValueRef Fn) {
2361   Function *Func = unwrap<Function>(Fn);
2362   Module::iterator I(Func);
2363   if (I == Func->getParent()->begin())
2364     return nullptr;
2365   return wrap(&*--I);
2366 }
2367
2368 void LLVMDeleteFunction(LLVMValueRef Fn) {
2369   unwrap<Function>(Fn)->eraseFromParent();
2370 }
2371
2372 LLVMBool LLVMHasPersonalityFn(LLVMValueRef Fn) {
2373   return unwrap<Function>(Fn)->hasPersonalityFn();
2374 }
2375
2376 LLVMValueRef LLVMGetPersonalityFn(LLVMValueRef Fn) {
2377   return wrap(unwrap<Function>(Fn)->getPersonalityFn());
2378 }
2379
2380 void LLVMSetPersonalityFn(LLVMValueRef Fn, LLVMValueRef PersonalityFn) {
2381   unwrap<Function>(Fn)->setPersonalityFn(unwrap<Constant>(PersonalityFn));
2382 }
2383
2384 unsigned LLVMGetIntrinsicID(LLVMValueRef Fn) {
2385   if (Function *F = dyn_cast<Function>(unwrap(Fn)))
2386     return F->getIntrinsicID();
2387   return 0;
2388 }
2389
2390 static Intrinsic::ID llvm_map_to_intrinsic_id(unsigned ID) {
2391   assert(ID < llvm::Intrinsic::num_intrinsics && "Intrinsic ID out of range");
2392   return llvm::Intrinsic::ID(ID);
2393 }
2394
2395 LLVMValueRef LLVMGetIntrinsicDeclaration(LLVMModuleRef Mod,
2396                                          unsigned ID,
2397                                          LLVMTypeRef *ParamTypes,
2398                                          size_t ParamCount) {
2399   ArrayRef<Type*> Tys(unwrap(ParamTypes), ParamCount);
2400   auto IID = llvm_map_to_intrinsic_id(ID);
2401   return wrap(llvm::Intrinsic::getDeclaration(unwrap(Mod), IID, Tys));
2402 }
2403
2404 const char *LLVMIntrinsicGetName(unsigned ID, size_t *NameLength) {
2405   auto IID = llvm_map_to_intrinsic_id(ID);
2406   auto Str = llvm::Intrinsic::getName(IID);
2407   *NameLength = Str.size();
2408   return Str.data();
2409 }
2410
2411 LLVMTypeRef LLVMIntrinsicGetType(LLVMContextRef Ctx, unsigned ID,
2412                                  LLVMTypeRef *ParamTypes, size_t ParamCount) {
2413   auto IID = llvm_map_to_intrinsic_id(ID);
2414   ArrayRef<Type*> Tys(unwrap(ParamTypes), ParamCount);
2415   return wrap(llvm::Intrinsic::getType(*unwrap(Ctx), IID, Tys));
2416 }
2417
2418 const char *LLVMIntrinsicCopyOverloadedName(unsigned ID,
2419                                             LLVMTypeRef *ParamTypes,
2420                                             size_t ParamCount,
2421                                             size_t *NameLength) {
2422   auto IID = llvm_map_to_intrinsic_id(ID);
2423   ArrayRef<Type*> Tys(unwrap(ParamTypes), ParamCount);
2424   auto Str = llvm::Intrinsic::getNameNoUnnamedTypes(IID, Tys);
2425   *NameLength = Str.length();
2426   return strdup(Str.c_str());
2427 }
2428
2429 const char *LLVMIntrinsicCopyOverloadedName2(LLVMModuleRef Mod, unsigned ID,
2430                                              LLVMTypeRef *ParamTypes,
2431                                              size_t ParamCount,
2432                                              size_t *NameLength) {
2433   auto IID = llvm_map_to_intrinsic_id(ID);
2434   ArrayRef<Type *> Tys(unwrap(ParamTypes), ParamCount);
2435   auto Str = llvm::Intrinsic::getName(IID, Tys, unwrap(Mod));
2436   *NameLength = Str.length();
2437   return strdup(Str.c_str());
2438 }
2439
2440 unsigned LLVMLookupIntrinsicID(const char *Name, size_t NameLen) {
2441   return Function::lookupIntrinsicID({Name, NameLen});
2442 }
2443
2444 LLVMBool LLVMIntrinsicIsOverloaded(unsigned ID) {
2445   auto IID = llvm_map_to_intrinsic_id(ID);
2446   return llvm::Intrinsic::isOverloaded(IID);
2447 }
2448
2449 unsigned LLVMGetFunctionCallConv(LLVMValueRef Fn) {
2450   return unwrap<Function>(Fn)->getCallingConv();
2451 }
2452
2453 void LLVMSetFunctionCallConv(LLVMValueRef Fn, unsigned CC) {
2454   return unwrap<Function>(Fn)->setCallingConv(
2455     static_cast<CallingConv::ID>(CC));
2456 }
2457
2458 const char *LLVMGetGC(LLVMValueRef Fn) {
2459   Function *F = unwrap<Function>(Fn);
2460   return F->hasGC()? F->getGC().c_str() : nullptr;
2461 }
2462
2463 void LLVMSetGC(LLVMValueRef Fn, const char *GC) {
2464   Function *F = unwrap<Function>(Fn);
2465   if (GC)
2466     F->setGC(GC);
2467   else
2468     F->clearGC();
2469 }
2470
2471 void LLVMAddAttributeAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx,
2472                              LLVMAttributeRef A) {
2473   unwrap<Function>(F)->addAttributeAtIndex(Idx, unwrap(A));
2474 }
2475
2476 unsigned LLVMGetAttributeCountAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx) {
2477   auto AS = unwrap<Function>(F)->getAttributes().getAttributes(Idx);
2478   return AS.getNumAttributes();
2479 }
2480
2481 void LLVMGetAttributesAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx,
2482                               LLVMAttributeRef *Attrs) {
2483   auto AS = unwrap<Function>(F)->getAttributes().getAttributes(Idx);
2484   for (auto A : AS)
2485     *Attrs++ = wrap(A);
2486 }
2487
2488 LLVMAttributeRef LLVMGetEnumAttributeAtIndex(LLVMValueRef F,
2489                                              LLVMAttributeIndex Idx,
2490                                              unsigned KindID) {
2491   return wrap(unwrap<Function>(F)->getAttributeAtIndex(
2492       Idx, (Attribute::AttrKind)KindID));
2493 }
2494
2495 LLVMAttributeRef LLVMGetStringAttributeAtIndex(LLVMValueRef F,
2496                                                LLVMAttributeIndex Idx,
2497                                                const char *K, unsigned KLen) {
2498   return wrap(
2499       unwrap<Function>(F)->getAttributeAtIndex(Idx, StringRef(K, KLen)));
2500 }
2501
2502 void LLVMRemoveEnumAttributeAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx,
2503                                     unsigned KindID) {
2504   unwrap<Function>(F)->removeAttributeAtIndex(Idx, (Attribute::AttrKind)KindID);
2505 }
2506
2507 void LLVMRemoveStringAttributeAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx,
2508                                       const char *K, unsigned KLen) {
2509   unwrap<Function>(F)->removeAttributeAtIndex(Idx, StringRef(K, KLen));
2510 }
2511
2512 void LLVMAddTargetDependentFunctionAttr(LLVMValueRef Fn, const char *A,
2513                                         const char *V) {
2514   Function *Func = unwrap<Function>(Fn);
2515   Attribute Attr = Attribute::get(Func->getContext(), A, V);
2516   Func->addFnAttr(Attr);
2517 }
2518
2519 /*--.. Operations on parameters ............................................--*/
2520
2521 unsigned LLVMCountParams(LLVMValueRef FnRef) {
2522   // This function is strictly redundant to
2523   //   LLVMCountParamTypes(LLVMGetElementType(LLVMTypeOf(FnRef)))
2524   return unwrap<Function>(FnRef)->arg_size();
2525 }
2526
2527 void LLVMGetParams(LLVMValueRef FnRef, LLVMValueRef *ParamRefs) {
2528   Function *Fn = unwrap<Function>(FnRef);
2529   for (Argument &A : Fn->args())
2530     *ParamRefs++ = wrap(&A);
2531 }
2532
2533 LLVMValueRef LLVMGetParam(LLVMValueRef FnRef, unsigned index) {
2534   Function *Fn = unwrap<Function>(FnRef);
2535   return wrap(&Fn->arg_begin()[index]);
2536 }
2537
2538 LLVMValueRef LLVMGetParamParent(LLVMValueRef V) {
2539   return wrap(unwrap<Argument>(V)->getParent());
2540 }
2541
2542 LLVMValueRef LLVMGetFirstParam(LLVMValueRef Fn) {
2543   Function *Func = unwrap<Function>(Fn);
2544   Function::arg_iterator I = Func->arg_begin();
2545   if (I == Func->arg_end())
2546     return nullptr;
2547   return wrap(&*I);
2548 }
2549
2550 LLVMValueRef LLVMGetLastParam(LLVMValueRef Fn) {
2551   Function *Func = unwrap<Function>(Fn);
2552   Function::arg_iterator I = Func->arg_end();
2553   if (I == Func->arg_begin())
2554     return nullptr;
2555   return wrap(&*--I);
2556 }
2557
2558 LLVMValueRef LLVMGetNextParam(LLVMValueRef Arg) {
2559   Argument *A = unwrap<Argument>(Arg);
2560   Function *Fn = A->getParent();
2561   if (A->getArgNo() + 1 >= Fn->arg_size())
2562     return nullptr;
2563   return wrap(&Fn->arg_begin()[A->getArgNo() + 1]);
2564 }
2565
2566 LLVMValueRef LLVMGetPreviousParam(LLVMValueRef Arg) {
2567   Argument *A = unwrap<Argument>(Arg);
2568   if (A->getArgNo() == 0)
2569     return nullptr;
2570   return wrap(&A->getParent()->arg_begin()[A->getArgNo() - 1]);
2571 }
2572
2573 void LLVMSetParamAlignment(LLVMValueRef Arg, unsigned align) {
2574   Argument *A = unwrap<Argument>(Arg);
2575   A->addAttr(Attribute::getWithAlignment(A->getContext(), Align(align)));
2576 }
2577
2578 /*--.. Operations on ifuncs ................................................--*/
2579
2580 LLVMValueRef LLVMAddGlobalIFunc(LLVMModuleRef M,
2581                                 const char *Name, size_t NameLen,
2582                                 LLVMTypeRef Ty, unsigned AddrSpace,
2583                                 LLVMValueRef Resolver) {
2584   return wrap(GlobalIFunc::create(unwrap(Ty), AddrSpace,
2585                                   GlobalValue::ExternalLinkage,
2586                                   StringRef(Name, NameLen),
2587                                   unwrap<Constant>(Resolver), unwrap(M)));
2588 }
2589
2590 LLVMValueRef LLVMGetNamedGlobalIFunc(LLVMModuleRef M,
2591                                      const char *Name, size_t NameLen) {
2592   return wrap(unwrap(M)->getNamedIFunc(StringRef(Name, NameLen)));
2593 }
2594
2595 LLVMValueRef LLVMGetFirstGlobalIFunc(LLVMModuleRef M) {
2596   Module *Mod = unwrap(M);
2597   Module::ifunc_iterator I = Mod->ifunc_begin();
2598   if (I == Mod->ifunc_end())
2599     return nullptr;
2600   return wrap(&*I);
2601 }
2602
2603 LLVMValueRef LLVMGetLastGlobalIFunc(LLVMModuleRef M) {
2604   Module *Mod = unwrap(M);
2605   Module::ifunc_iterator I = Mod->ifunc_end();
2606   if (I == Mod->ifunc_begin())
2607     return nullptr;
2608   return wrap(&*--I);
2609 }
2610
2611 LLVMValueRef LLVMGetNextGlobalIFunc(LLVMValueRef IFunc) {
2612   GlobalIFunc *GIF = unwrap<GlobalIFunc>(IFunc);
2613   Module::ifunc_iterator I(GIF);
2614   if (++I == GIF->getParent()->ifunc_end())
2615     return nullptr;
2616   return wrap(&*I);
2617 }
2618
2619 LLVMValueRef LLVMGetPreviousGlobalIFunc(LLVMValueRef IFunc) {
2620   GlobalIFunc *GIF = unwrap<GlobalIFunc>(IFunc);
2621   Module::ifunc_iterator I(GIF);
2622   if (I == GIF->getParent()->ifunc_begin())
2623     return nullptr;
2624   return wrap(&*--I);
2625 }
2626
2627 LLVMValueRef LLVMGetGlobalIFuncResolver(LLVMValueRef IFunc) {
2628   return wrap(unwrap<GlobalIFunc>(IFunc)->getResolver());
2629 }
2630
2631 void LLVMSetGlobalIFuncResolver(LLVMValueRef IFunc, LLVMValueRef Resolver) {
2632   unwrap<GlobalIFunc>(IFunc)->setResolver(unwrap<Constant>(Resolver));
2633 }
2634
2635 void LLVMEraseGlobalIFunc(LLVMValueRef IFunc) {
2636   unwrap<GlobalIFunc>(IFunc)->eraseFromParent();
2637 }
2638
2639 void LLVMRemoveGlobalIFunc(LLVMValueRef IFunc) {
2640   unwrap<GlobalIFunc>(IFunc)->removeFromParent();
2641 }
2642
2643 /*--.. Operations on basic blocks ..........................................--*/
2644
2645 LLVMValueRef LLVMBasicBlockAsValue(LLVMBasicBlockRef BB) {
2646   return wrap(static_cast<Value*>(unwrap(BB)));
2647 }
2648
2649 LLVMBool LLVMValueIsBasicBlock(LLVMValueRef Val) {
2650   return isa<BasicBlock>(unwrap(Val));
2651 }
2652
2653 LLVMBasicBlockRef LLVMValueAsBasicBlock(LLVMValueRef Val) {
2654   return wrap(unwrap<BasicBlock>(Val));
2655 }
2656
2657 const char *LLVMGetBasicBlockName(LLVMBasicBlockRef BB) {
2658   return unwrap(BB)->getName().data();
2659 }
2660
2661 LLVMValueRef LLVMGetBasicBlockParent(LLVMBasicBlockRef BB) {
2662   return wrap(unwrap(BB)->getParent());
2663 }
2664
2665 LLVMValueRef LLVMGetBasicBlockTerminator(LLVMBasicBlockRef BB) {
2666   return wrap(unwrap(BB)->getTerminator());
2667 }
2668
2669 unsigned LLVMCountBasicBlocks(LLVMValueRef FnRef) {
2670   return unwrap<Function>(FnRef)->size();
2671 }
2672
2673 void LLVMGetBasicBlocks(LLVMValueRef FnRef, LLVMBasicBlockRef *BasicBlocksRefs){
2674   Function *Fn = unwrap<Function>(FnRef);
2675   for (BasicBlock &BB : *Fn)
2676     *BasicBlocksRefs++ = wrap(&BB);
2677 }
2678
2679 LLVMBasicBlockRef LLVMGetEntryBasicBlock(LLVMValueRef Fn) {
2680   return wrap(&unwrap<Function>(Fn)->getEntryBlock());
2681 }
2682
2683 LLVMBasicBlockRef LLVMGetFirstBasicBlock(LLVMValueRef Fn) {
2684   Function *Func = unwrap<Function>(Fn);
2685   Function::iterator I = Func->begin();
2686   if (I == Func->end())
2687     return nullptr;
2688   return wrap(&*I);
2689 }
2690
2691 LLVMBasicBlockRef LLVMGetLastBasicBlock(LLVMValueRef Fn) {
2692   Function *Func = unwrap<Function>(Fn);
2693   Function::iterator I = Func->end();
2694   if (I == Func->begin())
2695     return nullptr;
2696   return wrap(&*--I);
2697 }
2698
2699 LLVMBasicBlockRef LLVMGetNextBasicBlock(LLVMBasicBlockRef BB) {
2700   BasicBlock *Block = unwrap(BB);
2701   Function::iterator I(Block);
2702   if (++I == Block->getParent()->end())
2703     return nullptr;
2704   return wrap(&*I);
2705 }
2706
2707 LLVMBasicBlockRef LLVMGetPreviousBasicBlock(LLVMBasicBlockRef BB) {
2708   BasicBlock *Block = unwrap(BB);
2709   Function::iterator I(Block);
2710   if (I == Block->getParent()->begin())
2711     return nullptr;
2712   return wrap(&*--I);
2713 }
2714
2715 LLVMBasicBlockRef LLVMCreateBasicBlockInContext(LLVMContextRef C,
2716                                                 const char *Name) {
2717   return wrap(llvm::BasicBlock::Create(*unwrap(C), Name));
2718 }
2719
2720 void LLVMInsertExistingBasicBlockAfterInsertBlock(LLVMBuilderRef Builder,
2721                                                   LLVMBasicBlockRef BB) {
2722   BasicBlock *ToInsert = unwrap(BB);
2723   BasicBlock *CurBB = unwrap(Builder)->GetInsertBlock();
2724   assert(CurBB && "current insertion point is invalid!");
2725   CurBB->getParent()->insert(std::next(CurBB->getIterator()), ToInsert);
2726 }
2727
2728 void LLVMAppendExistingBasicBlock(LLVMValueRef Fn,
2729                                   LLVMBasicBlockRef BB) {
2730   unwrap<Function>(Fn)->insert(unwrap<Function>(Fn)->end(), unwrap(BB));
2731 }
2732
2733 LLVMBasicBlockRef LLVMAppendBasicBlockInContext(LLVMContextRef C,
2734                                                 LLVMValueRef FnRef,
2735                                                 const char *Name) {
2736   return wrap(BasicBlock::Create(*unwrap(C), Name, unwrap<Function>(FnRef)));
2737 }
2738
2739 LLVMBasicBlockRef LLVMAppendBasicBlock(LLVMValueRef FnRef, const char *Name) {
2740   return LLVMAppendBasicBlockInContext(LLVMGetGlobalContext(), FnRef, Name);
2741 }
2742
2743 LLVMBasicBlockRef LLVMInsertBasicBlockInContext(LLVMContextRef C,
2744                                                 LLVMBasicBlockRef BBRef,
2745                                                 const char *Name) {
2746   BasicBlock *BB = unwrap(BBRef);
2747   return wrap(BasicBlock::Create(*unwrap(C), Name, BB->getParent(), BB));
2748 }
2749
2750 LLVMBasicBlockRef LLVMInsertBasicBlock(LLVMBasicBlockRef BBRef,
2751                                        const char *Name) {
2752   return LLVMInsertBasicBlockInContext(LLVMGetGlobalContext(), BBRef, Name);
2753 }
2754
2755 void LLVMDeleteBasicBlock(LLVMBasicBlockRef BBRef) {
2756   unwrap(BBRef)->eraseFromParent();
2757 }
2758
2759 void LLVMRemoveBasicBlockFromParent(LLVMBasicBlockRef BBRef) {
2760   unwrap(BBRef)->removeFromParent();
2761 }
2762
2763 void LLVMMoveBasicBlockBefore(LLVMBasicBlockRef BB, LLVMBasicBlockRef MovePos) {
2764   unwrap(BB)->moveBefore(unwrap(MovePos));
2765 }
2766
2767 void LLVMMoveBasicBlockAfter(LLVMBasicBlockRef BB, LLVMBasicBlockRef MovePos) {
2768   unwrap(BB)->moveAfter(unwrap(MovePos));
2769 }
2770
2771 /*--.. Operations on instructions ..........................................--*/
2772
2773 LLVMBasicBlockRef LLVMGetInstructionParent(LLVMValueRef Inst) {
2774   return wrap(unwrap<Instruction>(Inst)->getParent());
2775 }
2776
2777 LLVMValueRef LLVMGetFirstInstruction(LLVMBasicBlockRef BB) {
2778   BasicBlock *Block = unwrap(BB);
2779   BasicBlock::iterator I = Block->begin();
2780   if (I == Block->end())
2781     return nullptr;
2782   return wrap(&*I);
2783 }
2784
2785 LLVMValueRef LLVMGetLastInstruction(LLVMBasicBlockRef BB) {
2786   BasicBlock *Block = unwrap(BB);
2787   BasicBlock::iterator I = Block->end();
2788   if (I == Block->begin())
2789     return nullptr;
2790   return wrap(&*--I);
2791 }
2792
2793 LLVMValueRef LLVMGetNextInstruction(LLVMValueRef Inst) {
2794   Instruction *Instr = unwrap<Instruction>(Inst);
2795   BasicBlock::iterator I(Instr);
2796   if (++I == Instr->getParent()->end())
2797     return nullptr;
2798   return wrap(&*I);
2799 }
2800
2801 LLVMValueRef LLVMGetPreviousInstruction(LLVMValueRef Inst) {
2802   Instruction *Instr = unwrap<Instruction>(Inst);
2803   BasicBlock::iterator I(Instr);
2804   if (I == Instr->getParent()->begin())
2805     return nullptr;
2806   return wrap(&*--I);
2807 }
2808
2809 void LLVMInstructionRemoveFromParent(LLVMValueRef Inst) {
2810   unwrap<Instruction>(Inst)->removeFromParent();
2811 }
2812
2813 void LLVMInstructionEraseFromParent(LLVMValueRef Inst) {
2814   unwrap<Instruction>(Inst)->eraseFromParent();
2815 }
2816
2817 void LLVMDeleteInstruction(LLVMValueRef Inst) {
2818   unwrap<Instruction>(Inst)->deleteValue();
2819 }
2820
2821 LLVMIntPredicate LLVMGetICmpPredicate(LLVMValueRef Inst) {
2822   if (ICmpInst *I = dyn_cast<ICmpInst>(unwrap(Inst)))
2823     return (LLVMIntPredicate)I->getPredicate();
2824   if (ConstantExpr *CE = dyn_cast<ConstantExpr>(unwrap(Inst)))
2825     if (CE->getOpcode() == Instruction::ICmp)
2826       return (LLVMIntPredicate)CE->getPredicate();
2827   return (LLVMIntPredicate)0;
2828 }
2829
2830 LLVMRealPredicate LLVMGetFCmpPredicate(LLVMValueRef Inst) {
2831   if (FCmpInst *I = dyn_cast<FCmpInst>(unwrap(Inst)))
2832     return (LLVMRealPredicate)I->getPredicate();
2833   if (ConstantExpr *CE = dyn_cast<ConstantExpr>(unwrap(Inst)))
2834     if (CE->getOpcode() == Instruction::FCmp)
2835       return (LLVMRealPredicate)CE->getPredicate();
2836   return (LLVMRealPredicate)0;
2837 }
2838
2839 LLVMOpcode LLVMGetInstructionOpcode(LLVMValueRef Inst) {
2840   if (Instruction *C = dyn_cast<Instruction>(unwrap(Inst)))
2841     return map_to_llvmopcode(C->getOpcode());
2842   return (LLVMOpcode)0;
2843 }
2844
2845 LLVMValueRef LLVMInstructionClone(LLVMValueRef Inst) {
2846   if (Instruction *C = dyn_cast<Instruction>(unwrap(Inst)))
2847     return wrap(C->clone());
2848   return nullptr;
2849 }
2850
2851 LLVMValueRef LLVMIsATerminatorInst(LLVMValueRef Inst) {
2852   Instruction *I = dyn_cast<Instruction>(unwrap(Inst));
2853   return (I && I->isTerminator()) ? wrap(I) : nullptr;
2854 }
2855
2856 unsigned LLVMGetNumArgOperands(LLVMValueRef Instr) {
2857   if (FuncletPadInst *FPI = dyn_cast<FuncletPadInst>(unwrap(Instr))) {
2858     return FPI->arg_size();
2859   }
2860   return unwrap<CallBase>(Instr)->arg_size();
2861 }
2862
2863 /*--.. Call and invoke instructions ........................................--*/
2864
2865 unsigned LLVMGetInstructionCallConv(LLVMValueRef Instr) {
2866   return unwrap<CallBase>(Instr)->getCallingConv();
2867 }
2868
2869 void LLVMSetInstructionCallConv(LLVMValueRef Instr, unsigned CC) {
2870   return unwrap<CallBase>(Instr)->setCallingConv(
2871       static_cast<CallingConv::ID>(CC));
2872 }
2873
2874 void LLVMSetInstrParamAlignment(LLVMValueRef Instr, LLVMAttributeIndex Idx,
2875                                 unsigned align) {
2876   auto *Call = unwrap<CallBase>(Instr);
2877   Attribute AlignAttr =
2878       Attribute::getWithAlignment(Call->getContext(), Align(align));
2879   Call->addAttributeAtIndex(Idx, AlignAttr);
2880 }
2881
2882 void LLVMAddCallSiteAttribute(LLVMValueRef C, LLVMAttributeIndex Idx,
2883                               LLVMAttributeRef A) {
2884   unwrap<CallBase>(C)->addAttributeAtIndex(Idx, unwrap(A));
2885 }
2886
2887 unsigned LLVMGetCallSiteAttributeCount(LLVMValueRef C,
2888                                        LLVMAttributeIndex Idx) {
2889   auto *Call = unwrap<CallBase>(C);
2890   auto AS = Call->getAttributes().getAttributes(Idx);
2891   return AS.getNumAttributes();
2892 }
2893
2894 void LLVMGetCallSiteAttributes(LLVMValueRef C, LLVMAttributeIndex Idx,
2895                                LLVMAttributeRef *Attrs) {
2896   auto *Call = unwrap<CallBase>(C);
2897   auto AS = Call->getAttributes().getAttributes(Idx);
2898   for (auto A : AS)
2899     *Attrs++ = wrap(A);
2900 }
2901
2902 LLVMAttributeRef LLVMGetCallSiteEnumAttribute(LLVMValueRef C,
2903                                               LLVMAttributeIndex Idx,
2904                                               unsigned KindID) {
2905   return wrap(unwrap<CallBase>(C)->getAttributeAtIndex(
2906       Idx, (Attribute::AttrKind)KindID));
2907 }
2908
2909 LLVMAttributeRef LLVMGetCallSiteStringAttribute(LLVMValueRef C,
2910                                                 LLVMAttributeIndex Idx,
2911                                                 const char *K, unsigned KLen) {
2912   return wrap(
2913       unwrap<CallBase>(C)->getAttributeAtIndex(Idx, StringRef(K, KLen)));
2914 }
2915
2916 void LLVMRemoveCallSiteEnumAttribute(LLVMValueRef C, LLVMAttributeIndex Idx,
2917                                      unsigned KindID) {
2918   unwrap<CallBase>(C)->removeAttributeAtIndex(Idx, (Attribute::AttrKind)KindID);
2919 }
2920
2921 void LLVMRemoveCallSiteStringAttribute(LLVMValueRef C, LLVMAttributeIndex Idx,
2922                                        const char *K, unsigned KLen) {
2923   unwrap<CallBase>(C)->removeAttributeAtIndex(Idx, StringRef(K, KLen));
2924 }
2925
2926 LLVMValueRef LLVMGetCalledValue(LLVMValueRef Instr) {
2927   return wrap(unwrap<CallBase>(Instr)->getCalledOperand());
2928 }
2929
2930 LLVMTypeRef LLVMGetCalledFunctionType(LLVMValueRef Instr) {
2931   return wrap(unwrap<CallBase>(Instr)->getFunctionType());
2932 }
2933
2934 /*--.. Operations on call instructions (only) ..............................--*/
2935
2936 LLVMBool LLVMIsTailCall(LLVMValueRef Call) {
2937   return unwrap<CallInst>(Call)->isTailCall();
2938 }
2939
2940 void LLVMSetTailCall(LLVMValueRef Call, LLVMBool isTailCall) {
2941   unwrap<CallInst>(Call)->setTailCall(isTailCall);
2942 }
2943
2944 LLVMTailCallKind LLVMGetTailCallKind(LLVMValueRef Call) {
2945   return (LLVMTailCallKind)unwrap<CallInst>(Call)->getTailCallKind();
2946 }
2947
2948 void LLVMSetTailCallKind(LLVMValueRef Call, LLVMTailCallKind kind) {
2949   unwrap<CallInst>(Call)->setTailCallKind((CallInst::TailCallKind)kind);
2950 }
2951
2952 /*--.. Operations on invoke instructions (only) ............................--*/
2953
2954 LLVMBasicBlockRef LLVMGetNormalDest(LLVMValueRef Invoke) {
2955   return wrap(unwrap<InvokeInst>(Invoke)->getNormalDest());
2956 }
2957
2958 LLVMBasicBlockRef LLVMGetUnwindDest(LLVMValueRef Invoke) {
2959   if (CleanupReturnInst *CRI = dyn_cast<CleanupReturnInst>(unwrap(Invoke))) {
2960     return wrap(CRI->getUnwindDest());
2961   } else if (CatchSwitchInst *CSI = dyn_cast<CatchSwitchInst>(unwrap(Invoke))) {
2962     return wrap(CSI->getUnwindDest());
2963   }
2964   return wrap(unwrap<InvokeInst>(Invoke)->getUnwindDest());
2965 }
2966
2967 void LLVMSetNormalDest(LLVMValueRef Invoke, LLVMBasicBlockRef B) {
2968   unwrap<InvokeInst>(Invoke)->setNormalDest(unwrap(B));
2969 }
2970
2971 void LLVMSetUnwindDest(LLVMValueRef Invoke, LLVMBasicBlockRef B) {
2972   if (CleanupReturnInst *CRI = dyn_cast<CleanupReturnInst>(unwrap(Invoke))) {
2973     return CRI->setUnwindDest(unwrap(B));
2974   } else if (CatchSwitchInst *CSI = dyn_cast<CatchSwitchInst>(unwrap(Invoke))) {
2975     return CSI->setUnwindDest(unwrap(B));
2976   }
2977   unwrap<InvokeInst>(Invoke)->setUnwindDest(unwrap(B));
2978 }
2979
2980 /*--.. Operations on terminators ...........................................--*/
2981
2982 unsigned LLVMGetNumSuccessors(LLVMValueRef Term) {
2983   return unwrap<Instruction>(Term)->getNumSuccessors();
2984 }
2985
2986 LLVMBasicBlockRef LLVMGetSuccessor(LLVMValueRef Term, unsigned i) {
2987   return wrap(unwrap<Instruction>(Term)->getSuccessor(i));
2988 }
2989
2990 void LLVMSetSuccessor(LLVMValueRef Term, unsigned i, LLVMBasicBlockRef block) {
2991   return unwrap<Instruction>(Term)->setSuccessor(i, unwrap(block));
2992 }
2993
2994 /*--.. Operations on branch instructions (only) ............................--*/
2995
2996 LLVMBool LLVMIsConditional(LLVMValueRef Branch) {
2997   return unwrap<BranchInst>(Branch)->isConditional();
2998 }
2999
3000 LLVMValueRef LLVMGetCondition(LLVMValueRef Branch) {
3001   return wrap(unwrap<BranchInst>(Branch)->getCondition());
3002 }
3003
3004 void LLVMSetCondition(LLVMValueRef Branch, LLVMValueRef Cond) {
3005   return unwrap<BranchInst>(Branch)->setCondition(unwrap(Cond));
3006 }
3007
3008 /*--.. Operations on switch instructions (only) ............................--*/
3009
3010 LLVMBasicBlockRef LLVMGetSwitchDefaultDest(LLVMValueRef Switch) {
3011   return wrap(unwrap<SwitchInst>(Switch)->getDefaultDest());
3012 }
3013
3014 /*--.. Operations on alloca instructions (only) ............................--*/
3015
3016 LLVMTypeRef LLVMGetAllocatedType(LLVMValueRef Alloca) {
3017   return wrap(unwrap<AllocaInst>(Alloca)->getAllocatedType());
3018 }
3019
3020 /*--.. Operations on gep instructions (only) ...............................--*/
3021
3022 LLVMBool LLVMIsInBounds(LLVMValueRef GEP) {
3023   return unwrap<GEPOperator>(GEP)->isInBounds();
3024 }
3025
3026 void LLVMSetIsInBounds(LLVMValueRef GEP, LLVMBool InBounds) {
3027   return unwrap<GetElementPtrInst>(GEP)->setIsInBounds(InBounds);
3028 }
3029
3030 LLVMTypeRef LLVMGetGEPSourceElementType(LLVMValueRef GEP) {
3031   return wrap(unwrap<GEPOperator>(GEP)->getSourceElementType());
3032 }
3033
3034 /*--.. Operations on phi nodes .............................................--*/
3035
3036 void LLVMAddIncoming(LLVMValueRef PhiNode, LLVMValueRef *IncomingValues,
3037                      LLVMBasicBlockRef *IncomingBlocks, unsigned Count) {
3038   PHINode *PhiVal = unwrap<PHINode>(PhiNode);
3039   for (unsigned I = 0; I != Count; ++I)
3040     PhiVal->addIncoming(unwrap(IncomingValues[I]), unwrap(IncomingBlocks[I]));
3041 }
3042
3043 unsigned LLVMCountIncoming(LLVMValueRef PhiNode) {
3044   return unwrap<PHINode>(PhiNode)->getNumIncomingValues();
3045 }
3046
3047 LLVMValueRef LLVMGetIncomingValue(LLVMValueRef PhiNode, unsigned Index) {
3048   return wrap(unwrap<PHINode>(PhiNode)->getIncomingValue(Index));
3049 }
3050
3051 LLVMBasicBlockRef LLVMGetIncomingBlock(LLVMValueRef PhiNode, unsigned Index) {
3052   return wrap(unwrap<PHINode>(PhiNode)->getIncomingBlock(Index));
3053 }
3054
3055 /*--.. Operations on extractvalue and insertvalue nodes ....................--*/
3056
3057 unsigned LLVMGetNumIndices(LLVMValueRef Inst) {
3058   auto *I = unwrap(Inst);
3059   if (auto *GEP = dyn_cast<GEPOperator>(I))
3060     return GEP->getNumIndices();
3061   if (auto *EV = dyn_cast<ExtractValueInst>(I))
3062     return EV->getNumIndices();
3063   if (auto *IV = dyn_cast<InsertValueInst>(I))
3064     return IV->getNumIndices();
3065   llvm_unreachable(
3066     "LLVMGetNumIndices applies only to extractvalue and insertvalue!");
3067 }
3068
3069 const unsigned *LLVMGetIndices(LLVMValueRef Inst) {
3070   auto *I = unwrap(Inst);
3071   if (auto *EV = dyn_cast<ExtractValueInst>(I))
3072     return EV->getIndices().data();
3073   if (auto *IV = dyn_cast<InsertValueInst>(I))
3074     return IV->getIndices().data();
3075   llvm_unreachable(
3076     "LLVMGetIndices applies only to extractvalue and insertvalue!");
3077 }
3078
3079
3080 /*===-- Instruction builders ----------------------------------------------===*/
3081
3082 LLVMBuilderRef LLVMCreateBuilderInContext(LLVMContextRef C) {
3083   return wrap(new IRBuilder<>(*unwrap(C)));
3084 }
3085
3086 LLVMBuilderRef LLVMCreateBuilder(void) {
3087   return LLVMCreateBuilderInContext(LLVMGetGlobalContext());
3088 }
3089
3090 void LLVMPositionBuilder(LLVMBuilderRef Builder, LLVMBasicBlockRef Block,
3091                          LLVMValueRef Instr) {
3092   BasicBlock *BB = unwrap(Block);
3093   auto I = Instr ? unwrap<Instruction>(Instr)->getIterator() : BB->end();
3094   unwrap(Builder)->SetInsertPoint(BB, I);
3095 }
3096
3097 void LLVMPositionBuilderBefore(LLVMBuilderRef Builder, LLVMValueRef Instr) {
3098   Instruction *I = unwrap<Instruction>(Instr);
3099   unwrap(Builder)->SetInsertPoint(I->getParent(), I->getIterator());
3100 }
3101
3102 void LLVMPositionBuilderAtEnd(LLVMBuilderRef Builder, LLVMBasicBlockRef Block) {
3103   BasicBlock *BB = unwrap(Block);
3104   unwrap(Builder)->SetInsertPoint(BB);
3105 }
3106
3107 LLVMBasicBlockRef LLVMGetInsertBlock(LLVMBuilderRef Builder) {
3108    return wrap(unwrap(Builder)->GetInsertBlock());
3109 }
3110
3111 void LLVMClearInsertionPosition(LLVMBuilderRef Builder) {
3112   unwrap(Builder)->ClearInsertionPoint();
3113 }
3114
3115 void LLVMInsertIntoBuilder(LLVMBuilderRef Builder, LLVMValueRef Instr) {
3116   unwrap(Builder)->Insert(unwrap<Instruction>(Instr));
3117 }
3118
3119 void LLVMInsertIntoBuilderWithName(LLVMBuilderRef Builder, LLVMValueRef Instr,
3120                                    const char *Name) {
3121   unwrap(Builder)->Insert(unwrap<Instruction>(Instr), Name);
3122 }
3123
3124 void LLVMDisposeBuilder(LLVMBuilderRef Builder) {
3125   delete unwrap(Builder);
3126 }
3127
3128 /*--.. Metadata builders ...................................................--*/
3129
3130 LLVMMetadataRef LLVMGetCurrentDebugLocation2(LLVMBuilderRef Builder) {
3131   return wrap(unwrap(Builder)->getCurrentDebugLocation().getAsMDNode());
3132 }
3133
3134 void LLVMSetCurrentDebugLocation2(LLVMBuilderRef Builder, LLVMMetadataRef Loc) {
3135   if (Loc)
3136     unwrap(Builder)->SetCurrentDebugLocation(DebugLoc(unwrap<MDNode>(Loc)));
3137   else
3138     unwrap(Builder)->SetCurrentDebugLocation(DebugLoc());
3139 }
3140
3141 void LLVMSetCurrentDebugLocation(LLVMBuilderRef Builder, LLVMValueRef L) {
3142   MDNode *Loc =
3143       L ? cast<MDNode>(unwrap<MetadataAsValue>(L)->getMetadata()) : nullptr;
3144   unwrap(Builder)->SetCurrentDebugLocation(DebugLoc(Loc));
3145 }
3146
3147 LLVMValueRef LLVMGetCurrentDebugLocation(LLVMBuilderRef Builder) {
3148   LLVMContext &Context = unwrap(Builder)->getContext();
3149   return wrap(MetadataAsValue::get(
3150       Context, unwrap(Builder)->getCurrentDebugLocation().getAsMDNode()));
3151 }
3152
3153 void LLVMSetInstDebugLocation(LLVMBuilderRef Builder, LLVMValueRef Inst) {
3154   unwrap(Builder)->SetInstDebugLocation(unwrap<Instruction>(Inst));
3155 }
3156
3157 void LLVMAddMetadataToInst(LLVMBuilderRef Builder, LLVMValueRef Inst) {
3158   unwrap(Builder)->AddMetadataToInst(unwrap<Instruction>(Inst));
3159 }
3160
3161 void LLVMBuilderSetDefaultFPMathTag(LLVMBuilderRef Builder,
3162                                     LLVMMetadataRef FPMathTag) {
3163
3164   unwrap(Builder)->setDefaultFPMathTag(FPMathTag
3165                                        ? unwrap<MDNode>(FPMathTag)
3166                                        : nullptr);
3167 }
3168
3169 LLVMMetadataRef LLVMBuilderGetDefaultFPMathTag(LLVMBuilderRef Builder) {
3170   return wrap(unwrap(Builder)->getDefaultFPMathTag());
3171 }
3172
3173 /*--.. Instruction builders ................................................--*/
3174
3175 LLVMValueRef LLVMBuildRetVoid(LLVMBuilderRef B) {
3176   return wrap(unwrap(B)->CreateRetVoid());
3177 }
3178
3179 LLVMValueRef LLVMBuildRet(LLVMBuilderRef B, LLVMValueRef V) {
3180   return wrap(unwrap(B)->CreateRet(unwrap(V)));
3181 }
3182
3183 LLVMValueRef LLVMBuildAggregateRet(LLVMBuilderRef B, LLVMValueRef *RetVals,
3184                                    unsigned N) {
3185   return wrap(unwrap(B)->CreateAggregateRet(unwrap(RetVals), N));
3186 }
3187
3188 LLVMValueRef LLVMBuildBr(LLVMBuilderRef B, LLVMBasicBlockRef Dest) {
3189   return wrap(unwrap(B)->CreateBr(unwrap(Dest)));
3190 }
3191
3192 LLVMValueRef LLVMBuildCondBr(LLVMBuilderRef B, LLVMValueRef If,
3193                              LLVMBasicBlockRef Then, LLVMBasicBlockRef Else) {
3194   return wrap(unwrap(B)->CreateCondBr(unwrap(If), unwrap(Then), unwrap(Else)));
3195 }
3196
3197 LLVMValueRef LLVMBuildSwitch(LLVMBuilderRef B, LLVMValueRef V,
3198                              LLVMBasicBlockRef Else, unsigned NumCases) {
3199   return wrap(unwrap(B)->CreateSwitch(unwrap(V), unwrap(Else), NumCases));
3200 }
3201
3202 LLVMValueRef LLVMBuildIndirectBr(LLVMBuilderRef B, LLVMValueRef Addr,
3203                                  unsigned NumDests) {
3204   return wrap(unwrap(B)->CreateIndirectBr(unwrap(Addr), NumDests));
3205 }
3206
3207 LLVMValueRef LLVMBuildInvoke2(LLVMBuilderRef B, LLVMTypeRef Ty, LLVMValueRef Fn,
3208                               LLVMValueRef *Args, unsigned NumArgs,
3209                               LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch,
3210                               const char *Name) {
3211   return wrap(unwrap(B)->CreateInvoke(unwrap<FunctionType>(Ty), unwrap(Fn),
3212                                       unwrap(Then), unwrap(Catch),
3213                                       ArrayRef(unwrap(Args), NumArgs), Name));
3214 }
3215
3216 LLVMValueRef LLVMBuildLandingPad(LLVMBuilderRef B, LLVMTypeRef Ty,
3217                                  LLVMValueRef PersFn, unsigned NumClauses,
3218                                  const char *Name) {
3219   // The personality used to live on the landingpad instruction, but now it
3220   // lives on the parent function. For compatibility, take the provided
3221   // personality and put it on the parent function.
3222   if (PersFn)
3223     unwrap(B)->GetInsertBlock()->getParent()->setPersonalityFn(
3224         unwrap<Function>(PersFn));
3225   return wrap(unwrap(B)->CreateLandingPad(unwrap(Ty), NumClauses, Name));
3226 }
3227
3228 LLVMValueRef LLVMBuildCatchPad(LLVMBuilderRef B, LLVMValueRef ParentPad,
3229                                LLVMValueRef *Args, unsigned NumArgs,
3230                                const char *Name) {
3231   return wrap(unwrap(B)->CreateCatchPad(unwrap(ParentPad),
3232                                         ArrayRef(unwrap(Args), NumArgs), Name));
3233 }
3234
3235 LLVMValueRef LLVMBuildCleanupPad(LLVMBuilderRef B, LLVMValueRef ParentPad,
3236                                  LLVMValueRef *Args, unsigned NumArgs,
3237                                  const char *Name) {
3238   if (ParentPad == nullptr) {
3239     Type *Ty = Type::getTokenTy(unwrap(B)->getContext());
3240     ParentPad = wrap(Constant::getNullValue(Ty));
3241   }
3242   return wrap(unwrap(B)->CreateCleanupPad(
3243       unwrap(ParentPad), ArrayRef(unwrap(Args), NumArgs), Name));
3244 }
3245
3246 LLVMValueRef LLVMBuildResume(LLVMBuilderRef B, LLVMValueRef Exn) {
3247   return wrap(unwrap(B)->CreateResume(unwrap(Exn)));
3248 }
3249
3250 LLVMValueRef LLVMBuildCatchSwitch(LLVMBuilderRef B, LLVMValueRef ParentPad,
3251                                   LLVMBasicBlockRef UnwindBB,
3252                                   unsigned NumHandlers, const char *Name) {
3253   if (ParentPad == nullptr) {
3254     Type *Ty = Type::getTokenTy(unwrap(B)->getContext());
3255     ParentPad = wrap(Constant::getNullValue(Ty));
3256   }
3257   return wrap(unwrap(B)->CreateCatchSwitch(unwrap(ParentPad), unwrap(UnwindBB),
3258                                            NumHandlers, Name));
3259 }
3260
3261 LLVMValueRef LLVMBuildCatchRet(LLVMBuilderRef B, LLVMValueRef CatchPad,
3262                                LLVMBasicBlockRef BB) {
3263   return wrap(unwrap(B)->CreateCatchRet(unwrap<CatchPadInst>(CatchPad),
3264                                         unwrap(BB)));
3265 }
3266
3267 LLVMValueRef LLVMBuildCleanupRet(LLVMBuilderRef B, LLVMValueRef CatchPad,
3268                                  LLVMBasicBlockRef BB) {
3269   return wrap(unwrap(B)->CreateCleanupRet(unwrap<CleanupPadInst>(CatchPad),
3270                                           unwrap(BB)));
3271 }
3272
3273 LLVMValueRef LLVMBuildUnreachable(LLVMBuilderRef B) {
3274   return wrap(unwrap(B)->CreateUnreachable());
3275 }
3276
3277 void LLVMAddCase(LLVMValueRef Switch, LLVMValueRef OnVal,
3278                  LLVMBasicBlockRef Dest) {
3279   unwrap<SwitchInst>(Switch)->addCase(unwrap<ConstantInt>(OnVal), unwrap(Dest));
3280 }
3281
3282 void LLVMAddDestination(LLVMValueRef IndirectBr, LLVMBasicBlockRef Dest) {
3283   unwrap<IndirectBrInst>(IndirectBr)->addDestination(unwrap(Dest));
3284 }
3285
3286 unsigned LLVMGetNumClauses(LLVMValueRef LandingPad) {
3287   return unwrap<LandingPadInst>(LandingPad)->getNumClauses();
3288 }
3289
3290 LLVMValueRef LLVMGetClause(LLVMValueRef LandingPad, unsigned Idx) {
3291   return wrap(unwrap<LandingPadInst>(LandingPad)->getClause(Idx));
3292 }
3293
3294 void LLVMAddClause(LLVMValueRef LandingPad, LLVMValueRef ClauseVal) {
3295   unwrap<LandingPadInst>(LandingPad)->addClause(unwrap<Constant>(ClauseVal));
3296 }
3297
3298 LLVMBool LLVMIsCleanup(LLVMValueRef LandingPad) {
3299   return unwrap<LandingPadInst>(LandingPad)->isCleanup();
3300 }
3301
3302 void LLVMSetCleanup(LLVMValueRef LandingPad, LLVMBool Val) {
3303   unwrap<LandingPadInst>(LandingPad)->setCleanup(Val);
3304 }
3305
3306 void LLVMAddHandler(LLVMValueRef CatchSwitch, LLVMBasicBlockRef Dest) {
3307   unwrap<CatchSwitchInst>(CatchSwitch)->addHandler(unwrap(Dest));
3308 }
3309
3310 unsigned LLVMGetNumHandlers(LLVMValueRef CatchSwitch) {
3311   return unwrap<CatchSwitchInst>(CatchSwitch)->getNumHandlers();
3312 }
3313
3314 void LLVMGetHandlers(LLVMValueRef CatchSwitch, LLVMBasicBlockRef *Handlers) {
3315   CatchSwitchInst *CSI = unwrap<CatchSwitchInst>(CatchSwitch);
3316   for (const BasicBlock *H : CSI->handlers())
3317     *Handlers++ = wrap(H);
3318 }
3319
3320 LLVMValueRef LLVMGetParentCatchSwitch(LLVMValueRef CatchPad) {
3321   return wrap(unwrap<CatchPadInst>(CatchPad)->getCatchSwitch());
3322 }
3323
3324 void LLVMSetParentCatchSwitch(LLVMValueRef CatchPad, LLVMValueRef CatchSwitch) {
3325   unwrap<CatchPadInst>(CatchPad)
3326     ->setCatchSwitch(unwrap<CatchSwitchInst>(CatchSwitch));
3327 }
3328
3329 /*--.. Funclets ...........................................................--*/
3330
3331 LLVMValueRef LLVMGetArgOperand(LLVMValueRef Funclet, unsigned i) {
3332   return wrap(unwrap<FuncletPadInst>(Funclet)->getArgOperand(i));
3333 }
3334
3335 void LLVMSetArgOperand(LLVMValueRef Funclet, unsigned i, LLVMValueRef value) {
3336   unwrap<FuncletPadInst>(Funclet)->setArgOperand(i, unwrap(value));
3337 }
3338
3339 /*--.. Arithmetic ..........................................................--*/
3340
3341 LLVMValueRef LLVMBuildAdd(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
3342                           const char *Name) {
3343   return wrap(unwrap(B)->CreateAdd(unwrap(LHS), unwrap(RHS), Name));
3344 }
3345
3346 LLVMValueRef LLVMBuildNSWAdd(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
3347                           const char *Name) {
3348   return wrap(unwrap(B)->CreateNSWAdd(unwrap(LHS), unwrap(RHS), Name));
3349 }
3350
3351 LLVMValueRef LLVMBuildNUWAdd(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
3352                           const char *Name) {
3353   return wrap(unwrap(B)->CreateNUWAdd(unwrap(LHS), unwrap(RHS), Name));
3354 }
3355
3356 LLVMValueRef LLVMBuildFAdd(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
3357                           const char *Name) {
3358   return wrap(unwrap(B)->CreateFAdd(unwrap(LHS), unwrap(RHS), Name));
3359 }
3360
3361 LLVMValueRef LLVMBuildSub(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
3362                           const char *Name) {
3363   return wrap(unwrap(B)->CreateSub(unwrap(LHS), unwrap(RHS), Name));
3364 }
3365
3366 LLVMValueRef LLVMBuildNSWSub(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
3367                           const char *Name) {
3368   return wrap(unwrap(B)->CreateNSWSub(unwrap(LHS), unwrap(RHS), Name));
3369 }
3370
3371 LLVMValueRef LLVMBuildNUWSub(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
3372                           const char *Name) {
3373   return wrap(unwrap(B)->CreateNUWSub(unwrap(LHS), unwrap(RHS), Name));
3374 }
3375
3376 LLVMValueRef LLVMBuildFSub(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
3377                           const char *Name) {
3378   return wrap(unwrap(B)->CreateFSub(unwrap(LHS), unwrap(RHS), Name));
3379 }
3380
3381 LLVMValueRef LLVMBuildMul(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
3382                           const char *Name) {
3383   return wrap(unwrap(B)->CreateMul(unwrap(LHS), unwrap(RHS), Name));
3384 }
3385
3386 LLVMValueRef LLVMBuildNSWMul(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
3387                           const char *Name) {
3388   return wrap(unwrap(B)->CreateNSWMul(unwrap(LHS), unwrap(RHS), Name));
3389 }
3390
3391 LLVMValueRef LLVMBuildNUWMul(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
3392                           const char *Name) {
3393   return wrap(unwrap(B)->CreateNUWMul(unwrap(LHS), unwrap(RHS), Name));
3394 }
3395
3396 LLVMValueRef LLVMBuildFMul(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
3397                           const char *Name) {
3398   return wrap(unwrap(B)->CreateFMul(unwrap(LHS), unwrap(RHS), Name));
3399 }
3400
3401 LLVMValueRef LLVMBuildUDiv(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
3402                            const char *Name) {
3403   return wrap(unwrap(B)->CreateUDiv(unwrap(LHS), unwrap(RHS), Name));
3404 }
3405
3406 LLVMValueRef LLVMBuildExactUDiv(LLVMBuilderRef B, LLVMValueRef LHS,
3407                                 LLVMValueRef RHS, const char *Name) {
3408   return wrap(unwrap(B)->CreateExactUDiv(unwrap(LHS), unwrap(RHS), Name));
3409 }
3410
3411 LLVMValueRef LLVMBuildSDiv(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
3412                            const char *Name) {
3413   return wrap(unwrap(B)->CreateSDiv(unwrap(LHS), unwrap(RHS), Name));
3414 }
3415
3416 LLVMValueRef LLVMBuildExactSDiv(LLVMBuilderRef B, LLVMValueRef LHS,
3417                                 LLVMValueRef RHS, const char *Name) {
3418   return wrap(unwrap(B)->CreateExactSDiv(unwrap(LHS), unwrap(RHS), Name));
3419 }
3420
3421 LLVMValueRef LLVMBuildFDiv(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
3422                            const char *Name) {
3423   return wrap(unwrap(B)->CreateFDiv(unwrap(LHS), unwrap(RHS), Name));
3424 }
3425
3426 LLVMValueRef LLVMBuildURem(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
3427                            const char *Name) {
3428   return wrap(unwrap(B)->CreateURem(unwrap(LHS), unwrap(RHS), Name));
3429 }
3430
3431 LLVMValueRef LLVMBuildSRem(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
3432                            const char *Name) {
3433   return wrap(unwrap(B)->CreateSRem(unwrap(LHS), unwrap(RHS), Name));
3434 }
3435
3436 LLVMValueRef LLVMBuildFRem(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
3437                            const char *Name) {
3438   return wrap(unwrap(B)->CreateFRem(unwrap(LHS), unwrap(RHS), Name));
3439 }
3440
3441 LLVMValueRef LLVMBuildShl(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
3442                           const char *Name) {
3443   return wrap(unwrap(B)->CreateShl(unwrap(LHS), unwrap(RHS), Name));
3444 }
3445
3446 LLVMValueRef LLVMBuildLShr(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
3447                            const char *Name) {
3448   return wrap(unwrap(B)->CreateLShr(unwrap(LHS), unwrap(RHS), Name));
3449 }
3450
3451 LLVMValueRef LLVMBuildAShr(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
3452                            const char *Name) {
3453   return wrap(unwrap(B)->CreateAShr(unwrap(LHS), unwrap(RHS), Name));
3454 }
3455
3456 LLVMValueRef LLVMBuildAnd(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
3457                           const char *Name) {
3458   return wrap(unwrap(B)->CreateAnd(unwrap(LHS), unwrap(RHS), Name));
3459 }
3460
3461 LLVMValueRef LLVMBuildOr(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
3462                          const char *Name) {
3463   return wrap(unwrap(B)->CreateOr(unwrap(LHS), unwrap(RHS), Name));
3464 }
3465
3466 LLVMValueRef LLVMBuildXor(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
3467                           const char *Name) {
3468   return wrap(unwrap(B)->CreateXor(unwrap(LHS), unwrap(RHS), Name));
3469 }
3470
3471 LLVMValueRef LLVMBuildBinOp(LLVMBuilderRef B, LLVMOpcode Op,
3472                             LLVMValueRef LHS, LLVMValueRef RHS,
3473                             const char *Name) {
3474   return wrap(unwrap(B)->CreateBinOp(Instruction::BinaryOps(map_from_llvmopcode(Op)), unwrap(LHS),
3475                                      unwrap(RHS), Name));
3476 }
3477
3478 LLVMValueRef LLVMBuildNeg(LLVMBuilderRef B, LLVMValueRef V, const char *Name) {
3479   return wrap(unwrap(B)->CreateNeg(unwrap(V), Name));
3480 }
3481
3482 LLVMValueRef LLVMBuildNSWNeg(LLVMBuilderRef B, LLVMValueRef V,
3483                              const char *Name) {
3484   return wrap(unwrap(B)->CreateNSWNeg(unwrap(V), Name));
3485 }
3486
3487 LLVMValueRef LLVMBuildNUWNeg(LLVMBuilderRef B, LLVMValueRef V,
3488                              const char *Name) {
3489   return wrap(unwrap(B)->CreateNUWNeg(unwrap(V), Name));
3490 }
3491
3492 LLVMValueRef LLVMBuildFNeg(LLVMBuilderRef B, LLVMValueRef V, const char *Name) {
3493   return wrap(unwrap(B)->CreateFNeg(unwrap(V), Name));
3494 }
3495
3496 LLVMValueRef LLVMBuildNot(LLVMBuilderRef B, LLVMValueRef V, const char *Name) {
3497   return wrap(unwrap(B)->CreateNot(unwrap(V), Name));
3498 }
3499
3500 LLVMBool LLVMGetNUW(LLVMValueRef ArithInst) {
3501   Value *P = unwrap<Value>(ArithInst);
3502   return cast<Instruction>(P)->hasNoUnsignedWrap();
3503 }
3504
3505 void LLVMSetNUW(LLVMValueRef ArithInst, LLVMBool HasNUW) {
3506   Value *P = unwrap<Value>(ArithInst);
3507   cast<Instruction>(P)->setHasNoUnsignedWrap(HasNUW);
3508 }
3509
3510 LLVMBool LLVMGetNSW(LLVMValueRef ArithInst) {
3511   Value *P = unwrap<Value>(ArithInst);
3512   return cast<Instruction>(P)->hasNoSignedWrap();
3513 }
3514
3515 void LLVMSetNSW(LLVMValueRef ArithInst, LLVMBool HasNSW) {
3516   Value *P = unwrap<Value>(ArithInst);
3517   cast<Instruction>(P)->setHasNoSignedWrap(HasNSW);
3518 }
3519
3520 LLVMBool LLVMGetExact(LLVMValueRef DivOrShrInst) {
3521   Value *P = unwrap<Value>(DivOrShrInst);
3522   return cast<Instruction>(P)->isExact();
3523 }
3524
3525 void LLVMSetExact(LLVMValueRef DivOrShrInst, LLVMBool IsExact) {
3526   Value *P = unwrap<Value>(DivOrShrInst);
3527   cast<Instruction>(P)->setIsExact(IsExact);
3528 }
3529
3530 /*--.. Memory ..............................................................--*/
3531
3532 LLVMValueRef LLVMBuildMalloc(LLVMBuilderRef B, LLVMTypeRef Ty,
3533                              const char *Name) {
3534   Type* ITy = Type::getInt32Ty(unwrap(B)->GetInsertBlock()->getContext());
3535   Constant* AllocSize = ConstantExpr::getSizeOf(unwrap(Ty));
3536   AllocSize = ConstantExpr::getTruncOrBitCast(AllocSize, ITy);
3537   return wrap(unwrap(B)->CreateMalloc(ITy, unwrap(Ty), AllocSize, nullptr,
3538                                       nullptr, Name));
3539 }
3540
3541 LLVMValueRef LLVMBuildArrayMalloc(LLVMBuilderRef B, LLVMTypeRef Ty,
3542                                   LLVMValueRef Val, const char *Name) {
3543   Type* ITy = Type::getInt32Ty(unwrap(B)->GetInsertBlock()->getContext());
3544   Constant* AllocSize = ConstantExpr::getSizeOf(unwrap(Ty));
3545   AllocSize = ConstantExpr::getTruncOrBitCast(AllocSize, ITy);
3546   return wrap(unwrap(B)->CreateMalloc(ITy, unwrap(Ty), AllocSize, unwrap(Val),
3547                                       nullptr, Name));
3548 }
3549
3550 LLVMValueRef LLVMBuildMemSet(LLVMBuilderRef B, LLVMValueRef Ptr,
3551                              LLVMValueRef Val, LLVMValueRef Len,
3552                              unsigned Align) {
3553   return wrap(unwrap(B)->CreateMemSet(unwrap(Ptr), unwrap(Val), unwrap(Len),
3554                                       MaybeAlign(Align)));
3555 }
3556
3557 LLVMValueRef LLVMBuildMemCpy(LLVMBuilderRef B,
3558                              LLVMValueRef Dst, unsigned DstAlign,
3559                              LLVMValueRef Src, unsigned SrcAlign,
3560                              LLVMValueRef Size) {
3561   return wrap(unwrap(B)->CreateMemCpy(unwrap(Dst), MaybeAlign(DstAlign),
3562                                       unwrap(Src), MaybeAlign(SrcAlign),
3563                                       unwrap(Size)));
3564 }
3565
3566 LLVMValueRef LLVMBuildMemMove(LLVMBuilderRef B,
3567                               LLVMValueRef Dst, unsigned DstAlign,
3568                               LLVMValueRef Src, unsigned SrcAlign,
3569                               LLVMValueRef Size) {
3570   return wrap(unwrap(B)->CreateMemMove(unwrap(Dst), MaybeAlign(DstAlign),
3571                                        unwrap(Src), MaybeAlign(SrcAlign),
3572                                        unwrap(Size)));
3573 }
3574
3575 LLVMValueRef LLVMBuildAlloca(LLVMBuilderRef B, LLVMTypeRef Ty,
3576                              const char *Name) {
3577   return wrap(unwrap(B)->CreateAlloca(unwrap(Ty), nullptr, Name));
3578 }
3579
3580 LLVMValueRef LLVMBuildArrayAlloca(LLVMBuilderRef B, LLVMTypeRef Ty,
3581                                   LLVMValueRef Val, const char *Name) {
3582   return wrap(unwrap(B)->CreateAlloca(unwrap(Ty), unwrap(Val), Name));
3583 }
3584
3585 LLVMValueRef LLVMBuildFree(LLVMBuilderRef B, LLVMValueRef PointerVal) {
3586   return wrap(unwrap(B)->CreateFree(unwrap(PointerVal)));
3587 }
3588
3589 LLVMValueRef LLVMBuildLoad2(LLVMBuilderRef B, LLVMTypeRef Ty,
3590                             LLVMValueRef PointerVal, const char *Name) {
3591   return wrap(unwrap(B)->CreateLoad(unwrap(Ty), unwrap(PointerVal), Name));
3592 }
3593
3594 LLVMValueRef LLVMBuildStore(LLVMBuilderRef B, LLVMValueRef Val,
3595                             LLVMValueRef PointerVal) {
3596   return wrap(unwrap(B)->CreateStore(unwrap(Val), unwrap(PointerVal)));
3597 }
3598
3599 static AtomicOrdering mapFromLLVMOrdering(LLVMAtomicOrdering Ordering) {
3600   switch (Ordering) {
3601     case LLVMAtomicOrderingNotAtomic: return AtomicOrdering::NotAtomic;
3602     case LLVMAtomicOrderingUnordered: return AtomicOrdering::Unordered;
3603     case LLVMAtomicOrderingMonotonic: return AtomicOrdering::Monotonic;
3604     case LLVMAtomicOrderingAcquire: return AtomicOrdering::Acquire;
3605     case LLVMAtomicOrderingRelease: return AtomicOrdering::Release;
3606     case LLVMAtomicOrderingAcquireRelease:
3607       return AtomicOrdering::AcquireRelease;
3608     case LLVMAtomicOrderingSequentiallyConsistent:
3609       return AtomicOrdering::SequentiallyConsistent;
3610   }
3611
3612   llvm_unreachable("Invalid LLVMAtomicOrdering value!");
3613 }
3614
3615 static LLVMAtomicOrdering mapToLLVMOrdering(AtomicOrdering Ordering) {
3616   switch (Ordering) {
3617     case AtomicOrdering::NotAtomic: return LLVMAtomicOrderingNotAtomic;
3618     case AtomicOrdering::Unordered: return LLVMAtomicOrderingUnordered;
3619     case AtomicOrdering::Monotonic: return LLVMAtomicOrderingMonotonic;
3620     case AtomicOrdering::Acquire: return LLVMAtomicOrderingAcquire;
3621     case AtomicOrdering::Release: return LLVMAtomicOrderingRelease;
3622     case AtomicOrdering::AcquireRelease:
3623       return LLVMAtomicOrderingAcquireRelease;
3624     case AtomicOrdering::SequentiallyConsistent:
3625       return LLVMAtomicOrderingSequentiallyConsistent;
3626   }
3627
3628   llvm_unreachable("Invalid AtomicOrdering value!");
3629 }
3630
3631 static AtomicRMWInst::BinOp mapFromLLVMRMWBinOp(LLVMAtomicRMWBinOp BinOp) {
3632   switch (BinOp) {
3633     case LLVMAtomicRMWBinOpXchg: return AtomicRMWInst::Xchg;
3634     case LLVMAtomicRMWBinOpAdd: return AtomicRMWInst::Add;
3635     case LLVMAtomicRMWBinOpSub: return AtomicRMWInst::Sub;
3636     case LLVMAtomicRMWBinOpAnd: return AtomicRMWInst::And;
3637     case LLVMAtomicRMWBinOpNand: return AtomicRMWInst::Nand;
3638     case LLVMAtomicRMWBinOpOr: return AtomicRMWInst::Or;
3639     case LLVMAtomicRMWBinOpXor: return AtomicRMWInst::Xor;
3640     case LLVMAtomicRMWBinOpMax: return AtomicRMWInst::Max;
3641     case LLVMAtomicRMWBinOpMin: return AtomicRMWInst::Min;
3642     case LLVMAtomicRMWBinOpUMax: return AtomicRMWInst::UMax;
3643     case LLVMAtomicRMWBinOpUMin: return AtomicRMWInst::UMin;
3644     case LLVMAtomicRMWBinOpFAdd: return AtomicRMWInst::FAdd;
3645     case LLVMAtomicRMWBinOpFSub: return AtomicRMWInst::FSub;
3646     case LLVMAtomicRMWBinOpFMax: return AtomicRMWInst::FMax;
3647     case LLVMAtomicRMWBinOpFMin: return AtomicRMWInst::FMin;
3648   }
3649
3650   llvm_unreachable("Invalid LLVMAtomicRMWBinOp value!");
3651 }
3652
3653 static LLVMAtomicRMWBinOp mapToLLVMRMWBinOp(AtomicRMWInst::BinOp BinOp) {
3654   switch (BinOp) {
3655     case AtomicRMWInst::Xchg: return LLVMAtomicRMWBinOpXchg;
3656     case AtomicRMWInst::Add: return LLVMAtomicRMWBinOpAdd;
3657     case AtomicRMWInst::Sub: return LLVMAtomicRMWBinOpSub;
3658     case AtomicRMWInst::And: return LLVMAtomicRMWBinOpAnd;
3659     case AtomicRMWInst::Nand: return LLVMAtomicRMWBinOpNand;
3660     case AtomicRMWInst::Or: return LLVMAtomicRMWBinOpOr;
3661     case AtomicRMWInst::Xor: return LLVMAtomicRMWBinOpXor;
3662     case AtomicRMWInst::Max: return LLVMAtomicRMWBinOpMax;
3663     case AtomicRMWInst::Min: return LLVMAtomicRMWBinOpMin;
3664     case AtomicRMWInst::UMax: return LLVMAtomicRMWBinOpUMax;
3665     case AtomicRMWInst::UMin: return LLVMAtomicRMWBinOpUMin;
3666     case AtomicRMWInst::FAdd: return LLVMAtomicRMWBinOpFAdd;
3667     case AtomicRMWInst::FSub: return LLVMAtomicRMWBinOpFSub;
3668     case AtomicRMWInst::FMax: return LLVMAtomicRMWBinOpFMax;
3669     case AtomicRMWInst::FMin: return LLVMAtomicRMWBinOpFMin;
3670     default: break;
3671   }
3672
3673   llvm_unreachable("Invalid AtomicRMWBinOp value!");
3674 }
3675
3676 // TODO: Should this and other atomic instructions support building with
3677 // "syncscope"?
3678 LLVMValueRef LLVMBuildFence(LLVMBuilderRef B, LLVMAtomicOrdering Ordering,
3679                             LLVMBool isSingleThread, const char *Name) {
3680   return wrap(
3681     unwrap(B)->CreateFence(mapFromLLVMOrdering(Ordering),
3682                            isSingleThread ? SyncScope::SingleThread
3683                                           : SyncScope::System,
3684                            Name));
3685 }
3686
3687 LLVMValueRef LLVMBuildGEP2(LLVMBuilderRef B, LLVMTypeRef Ty,
3688                            LLVMValueRef Pointer, LLVMValueRef *Indices,
3689                            unsigned NumIndices, const char *Name) {
3690   ArrayRef<Value *> IdxList(unwrap(Indices), NumIndices);
3691   return wrap(unwrap(B)->CreateGEP(unwrap(Ty), unwrap(Pointer), IdxList, Name));
3692 }
3693
3694 LLVMValueRef LLVMBuildInBoundsGEP2(LLVMBuilderRef B, LLVMTypeRef Ty,
3695                                    LLVMValueRef Pointer, LLVMValueRef *Indices,
3696                                    unsigned NumIndices, const char *Name) {
3697   ArrayRef<Value *> IdxList(unwrap(Indices), NumIndices);
3698   return wrap(
3699       unwrap(B)->CreateInBoundsGEP(unwrap(Ty), unwrap(Pointer), IdxList, Name));
3700 }
3701
3702 LLVMValueRef LLVMBuildStructGEP2(LLVMBuilderRef B, LLVMTypeRef Ty,
3703                                  LLVMValueRef Pointer, unsigned Idx,
3704                                  const char *Name) {
3705   return wrap(
3706       unwrap(B)->CreateStructGEP(unwrap(Ty), unwrap(Pointer), Idx, Name));
3707 }
3708
3709 LLVMValueRef LLVMBuildGlobalString(LLVMBuilderRef B, const char *Str,
3710                                    const char *Name) {
3711   return wrap(unwrap(B)->CreateGlobalString(Str, Name));
3712 }
3713
3714 LLVMValueRef LLVMBuildGlobalStringPtr(LLVMBuilderRef B, const char *Str,
3715                                       const char *Name) {
3716   return wrap(unwrap(B)->CreateGlobalStringPtr(Str, Name));
3717 }
3718
3719 LLVMBool LLVMGetVolatile(LLVMValueRef MemAccessInst) {
3720   Value *P = unwrap(MemAccessInst);
3721   if (LoadInst *LI = dyn_cast<LoadInst>(P))
3722     return LI->isVolatile();
3723   if (StoreInst *SI = dyn_cast<StoreInst>(P))
3724     return SI->isVolatile();
3725   if (AtomicRMWInst *AI = dyn_cast<AtomicRMWInst>(P))
3726     return AI->isVolatile();
3727   return cast<AtomicCmpXchgInst>(P)->isVolatile();
3728 }
3729
3730 void LLVMSetVolatile(LLVMValueRef MemAccessInst, LLVMBool isVolatile) {
3731   Value *P = unwrap(MemAccessInst);
3732   if (LoadInst *LI = dyn_cast<LoadInst>(P))
3733     return LI->setVolatile(isVolatile);
3734   if (StoreInst *SI = dyn_cast<StoreInst>(P))
3735     return SI->setVolatile(isVolatile);
3736   if (AtomicRMWInst *AI = dyn_cast<AtomicRMWInst>(P))
3737     return AI->setVolatile(isVolatile);
3738   return cast<AtomicCmpXchgInst>(P)->setVolatile(isVolatile);
3739 }
3740
3741 LLVMBool LLVMGetWeak(LLVMValueRef CmpXchgInst) {
3742   return unwrap<AtomicCmpXchgInst>(CmpXchgInst)->isWeak();
3743 }
3744
3745 void LLVMSetWeak(LLVMValueRef CmpXchgInst, LLVMBool isWeak) {
3746   return unwrap<AtomicCmpXchgInst>(CmpXchgInst)->setWeak(isWeak);
3747 }
3748
3749 LLVMAtomicOrdering LLVMGetOrdering(LLVMValueRef MemAccessInst) {
3750   Value *P = unwrap(MemAccessInst);
3751   AtomicOrdering O;
3752   if (LoadInst *LI = dyn_cast<LoadInst>(P))
3753     O = LI->getOrdering();
3754   else if (StoreInst *SI = dyn_cast<StoreInst>(P))
3755     O = SI->getOrdering();
3756   else if (FenceInst *FI = dyn_cast<FenceInst>(P))
3757     O = FI->getOrdering();
3758   else
3759     O = cast<AtomicRMWInst>(P)->getOrdering();
3760   return mapToLLVMOrdering(O);
3761 }
3762
3763 void LLVMSetOrdering(LLVMValueRef MemAccessInst, LLVMAtomicOrdering Ordering) {
3764   Value *P = unwrap(MemAccessInst);
3765   AtomicOrdering O = mapFromLLVMOrdering(Ordering);
3766
3767   if (LoadInst *LI = dyn_cast<LoadInst>(P))
3768     return LI->setOrdering(O);
3769   else if (FenceInst *FI = dyn_cast<FenceInst>(P))
3770     return FI->setOrdering(O);
3771   else if (AtomicRMWInst *ARWI = dyn_cast<AtomicRMWInst>(P))
3772     return ARWI->setOrdering(O);
3773   return cast<StoreInst>(P)->setOrdering(O);
3774 }
3775
3776 LLVMAtomicRMWBinOp LLVMGetAtomicRMWBinOp(LLVMValueRef Inst) {
3777   return mapToLLVMRMWBinOp(unwrap<AtomicRMWInst>(Inst)->getOperation());
3778 }
3779
3780 void LLVMSetAtomicRMWBinOp(LLVMValueRef Inst, LLVMAtomicRMWBinOp BinOp) {
3781   unwrap<AtomicRMWInst>(Inst)->setOperation(mapFromLLVMRMWBinOp(BinOp));
3782 }
3783
3784 /*--.. Casts ...............................................................--*/
3785
3786 LLVMValueRef LLVMBuildTrunc(LLVMBuilderRef B, LLVMValueRef Val,
3787                             LLVMTypeRef DestTy, const char *Name) {
3788   return wrap(unwrap(B)->CreateTrunc(unwrap(Val), unwrap(DestTy), Name));
3789 }
3790
3791 LLVMValueRef LLVMBuildZExt(LLVMBuilderRef B, LLVMValueRef Val,
3792                            LLVMTypeRef DestTy, const char *Name) {
3793   return wrap(unwrap(B)->CreateZExt(unwrap(Val), unwrap(DestTy), Name));
3794 }
3795
3796 LLVMValueRef LLVMBuildSExt(LLVMBuilderRef B, LLVMValueRef Val,
3797                            LLVMTypeRef DestTy, const char *Name) {
3798   return wrap(unwrap(B)->CreateSExt(unwrap(Val), unwrap(DestTy), Name));
3799 }
3800
3801 LLVMValueRef LLVMBuildFPToUI(LLVMBuilderRef B, LLVMValueRef Val,
3802                              LLVMTypeRef DestTy, const char *Name) {
3803   return wrap(unwrap(B)->CreateFPToUI(unwrap(Val), unwrap(DestTy), Name));
3804 }
3805
3806 LLVMValueRef LLVMBuildFPToSI(LLVMBuilderRef B, LLVMValueRef Val,
3807                              LLVMTypeRef DestTy, const char *Name) {
3808   return wrap(unwrap(B)->CreateFPToSI(unwrap(Val), unwrap(DestTy), Name));
3809 }
3810
3811 LLVMValueRef LLVMBuildUIToFP(LLVMBuilderRef B, LLVMValueRef Val,
3812                              LLVMTypeRef DestTy, const char *Name) {
3813   return wrap(unwrap(B)->CreateUIToFP(unwrap(Val), unwrap(DestTy), Name));
3814 }
3815
3816 LLVMValueRef LLVMBuildSIToFP(LLVMBuilderRef B, LLVMValueRef Val,
3817                              LLVMTypeRef DestTy, const char *Name) {
3818   return wrap(unwrap(B)->CreateSIToFP(unwrap(Val), unwrap(DestTy), Name));
3819 }
3820
3821 LLVMValueRef LLVMBuildFPTrunc(LLVMBuilderRef B, LLVMValueRef Val,
3822                               LLVMTypeRef DestTy, const char *Name) {
3823   return wrap(unwrap(B)->CreateFPTrunc(unwrap(Val), unwrap(DestTy), Name));
3824 }
3825
3826 LLVMValueRef LLVMBuildFPExt(LLVMBuilderRef B, LLVMValueRef Val,
3827                             LLVMTypeRef DestTy, const char *Name) {
3828   return wrap(unwrap(B)->CreateFPExt(unwrap(Val), unwrap(DestTy), Name));
3829 }
3830
3831 LLVMValueRef LLVMBuildPtrToInt(LLVMBuilderRef B, LLVMValueRef Val,
3832                                LLVMTypeRef DestTy, const char *Name) {
3833   return wrap(unwrap(B)->CreatePtrToInt(unwrap(Val), unwrap(DestTy), Name));
3834 }
3835
3836 LLVMValueRef LLVMBuildIntToPtr(LLVMBuilderRef B, LLVMValueRef Val,
3837                                LLVMTypeRef DestTy, const char *Name) {
3838   return wrap(unwrap(B)->CreateIntToPtr(unwrap(Val), unwrap(DestTy), Name));
3839 }
3840
3841 LLVMValueRef LLVMBuildBitCast(LLVMBuilderRef B, LLVMValueRef Val,
3842                               LLVMTypeRef DestTy, const char *Name) {
3843   return wrap(unwrap(B)->CreateBitCast(unwrap(Val), unwrap(DestTy), Name));
3844 }
3845
3846 LLVMValueRef LLVMBuildAddrSpaceCast(LLVMBuilderRef B, LLVMValueRef Val,
3847                                     LLVMTypeRef DestTy, const char *Name) {
3848   return wrap(unwrap(B)->CreateAddrSpaceCast(unwrap(Val), unwrap(DestTy), Name));
3849 }
3850
3851 LLVMValueRef LLVMBuildZExtOrBitCast(LLVMBuilderRef B, LLVMValueRef Val,
3852                                     LLVMTypeRef DestTy, const char *Name) {
3853   return wrap(unwrap(B)->CreateZExtOrBitCast(unwrap(Val), unwrap(DestTy),
3854                                              Name));
3855 }
3856
3857 LLVMValueRef LLVMBuildSExtOrBitCast(LLVMBuilderRef B, LLVMValueRef Val,
3858                                     LLVMTypeRef DestTy, const char *Name) {
3859   return wrap(unwrap(B)->CreateSExtOrBitCast(unwrap(Val), unwrap(DestTy),
3860                                              Name));
3861 }
3862
3863 LLVMValueRef LLVMBuildTruncOrBitCast(LLVMBuilderRef B, LLVMValueRef Val,
3864                                      LLVMTypeRef DestTy, const char *Name) {
3865   return wrap(unwrap(B)->CreateTruncOrBitCast(unwrap(Val), unwrap(DestTy),
3866                                               Name));
3867 }
3868
3869 LLVMValueRef LLVMBuildCast(LLVMBuilderRef B, LLVMOpcode Op, LLVMValueRef Val,
3870                            LLVMTypeRef DestTy, const char *Name) {
3871   return wrap(unwrap(B)->CreateCast(Instruction::CastOps(map_from_llvmopcode(Op)), unwrap(Val),
3872                                     unwrap(DestTy), Name));
3873 }
3874
3875 LLVMValueRef LLVMBuildPointerCast(LLVMBuilderRef B, LLVMValueRef Val,
3876                                   LLVMTypeRef DestTy, const char *Name) {
3877   return wrap(unwrap(B)->CreatePointerCast(unwrap(Val), unwrap(DestTy), Name));
3878 }
3879
3880 LLVMValueRef LLVMBuildIntCast2(LLVMBuilderRef B, LLVMValueRef Val,
3881                                LLVMTypeRef DestTy, LLVMBool IsSigned,
3882                                const char *Name) {
3883   return wrap(
3884       unwrap(B)->CreateIntCast(unwrap(Val), unwrap(DestTy), IsSigned, Name));
3885 }
3886
3887 LLVMValueRef LLVMBuildIntCast(LLVMBuilderRef B, LLVMValueRef Val,
3888                               LLVMTypeRef DestTy, const char *Name) {
3889   return wrap(unwrap(B)->CreateIntCast(unwrap(Val), unwrap(DestTy),
3890                                        /*isSigned*/true, Name));
3891 }
3892
3893 LLVMValueRef LLVMBuildFPCast(LLVMBuilderRef B, LLVMValueRef Val,
3894                              LLVMTypeRef DestTy, const char *Name) {
3895   return wrap(unwrap(B)->CreateFPCast(unwrap(Val), unwrap(DestTy), Name));
3896 }
3897
3898 LLVMOpcode LLVMGetCastOpcode(LLVMValueRef Src, LLVMBool SrcIsSigned,
3899                              LLVMTypeRef DestTy, LLVMBool DestIsSigned) {
3900   return map_to_llvmopcode(CastInst::getCastOpcode(
3901       unwrap(Src), SrcIsSigned, unwrap(DestTy), DestIsSigned));
3902 }
3903
3904 /*--.. Comparisons .........................................................--*/
3905
3906 LLVMValueRef LLVMBuildICmp(LLVMBuilderRef B, LLVMIntPredicate Op,
3907                            LLVMValueRef LHS, LLVMValueRef RHS,
3908                            const char *Name) {
3909   return wrap(unwrap(B)->CreateICmp(static_cast<ICmpInst::Predicate>(Op),
3910                                     unwrap(LHS), unwrap(RHS), Name));
3911 }
3912
3913 LLVMValueRef LLVMBuildFCmp(LLVMBuilderRef B, LLVMRealPredicate Op,
3914                            LLVMValueRef LHS, LLVMValueRef RHS,
3915                            const char *Name) {
3916   return wrap(unwrap(B)->CreateFCmp(static_cast<FCmpInst::Predicate>(Op),
3917                                     unwrap(LHS), unwrap(RHS), Name));
3918 }
3919
3920 /*--.. Miscellaneous instructions ..........................................--*/
3921
3922 LLVMValueRef LLVMBuildPhi(LLVMBuilderRef B, LLVMTypeRef Ty, const char *Name) {
3923   return wrap(unwrap(B)->CreatePHI(unwrap(Ty), 0, Name));
3924 }
3925
3926 LLVMValueRef LLVMBuildCall2(LLVMBuilderRef B, LLVMTypeRef Ty, LLVMValueRef Fn,
3927                             LLVMValueRef *Args, unsigned NumArgs,
3928                             const char *Name) {
3929   FunctionType *FTy = unwrap<FunctionType>(Ty);
3930   return wrap(unwrap(B)->CreateCall(FTy, unwrap(Fn),
3931                                     ArrayRef(unwrap(Args), NumArgs), Name));
3932 }
3933
3934 LLVMValueRef LLVMBuildSelect(LLVMBuilderRef B, LLVMValueRef If,
3935                              LLVMValueRef Then, LLVMValueRef Else,
3936                              const char *Name) {
3937   return wrap(unwrap(B)->CreateSelect(unwrap(If), unwrap(Then), unwrap(Else),
3938                                       Name));
3939 }
3940
3941 LLVMValueRef LLVMBuildVAArg(LLVMBuilderRef B, LLVMValueRef List,
3942                             LLVMTypeRef Ty, const char *Name) {
3943   return wrap(unwrap(B)->CreateVAArg(unwrap(List), unwrap(Ty), Name));
3944 }
3945
3946 LLVMValueRef LLVMBuildExtractElement(LLVMBuilderRef B, LLVMValueRef VecVal,
3947                                       LLVMValueRef Index, const char *Name) {
3948   return wrap(unwrap(B)->CreateExtractElement(unwrap(VecVal), unwrap(Index),
3949                                               Name));
3950 }
3951
3952 LLVMValueRef LLVMBuildInsertElement(LLVMBuilderRef B, LLVMValueRef VecVal,
3953                                     LLVMValueRef EltVal, LLVMValueRef Index,
3954                                     const char *Name) {
3955   return wrap(unwrap(B)->CreateInsertElement(unwrap(VecVal), unwrap(EltVal),
3956                                              unwrap(Index), Name));
3957 }
3958
3959 LLVMValueRef LLVMBuildShuffleVector(LLVMBuilderRef B, LLVMValueRef V1,
3960                                     LLVMValueRef V2, LLVMValueRef Mask,
3961                                     const char *Name) {
3962   return wrap(unwrap(B)->CreateShuffleVector(unwrap(V1), unwrap(V2),
3963                                              unwrap(Mask), Name));
3964 }
3965
3966 LLVMValueRef LLVMBuildExtractValue(LLVMBuilderRef B, LLVMValueRef AggVal,
3967                                    unsigned Index, const char *Name) {
3968   return wrap(unwrap(B)->CreateExtractValue(unwrap(AggVal), Index, Name));
3969 }
3970
3971 LLVMValueRef LLVMBuildInsertValue(LLVMBuilderRef B, LLVMValueRef AggVal,
3972                                   LLVMValueRef EltVal, unsigned Index,
3973                                   const char *Name) {
3974   return wrap(unwrap(B)->CreateInsertValue(unwrap(AggVal), unwrap(EltVal),
3975                                            Index, Name));
3976 }
3977
3978 LLVMValueRef LLVMBuildFreeze(LLVMBuilderRef B, LLVMValueRef Val,
3979                              const char *Name) {
3980   return wrap(unwrap(B)->CreateFreeze(unwrap(Val), Name));
3981 }
3982
3983 LLVMValueRef LLVMBuildIsNull(LLVMBuilderRef B, LLVMValueRef Val,
3984                              const char *Name) {
3985   return wrap(unwrap(B)->CreateIsNull(unwrap(Val), Name));
3986 }
3987
3988 LLVMValueRef LLVMBuildIsNotNull(LLVMBuilderRef B, LLVMValueRef Val,
3989                                 const char *Name) {
3990   return wrap(unwrap(B)->CreateIsNotNull(unwrap(Val), Name));
3991 }
3992
3993 LLVMValueRef LLVMBuildPtrDiff2(LLVMBuilderRef B, LLVMTypeRef ElemTy,
3994                                LLVMValueRef LHS, LLVMValueRef RHS,
3995                                const char *Name) {
3996   return wrap(unwrap(B)->CreatePtrDiff(unwrap(ElemTy), unwrap(LHS),
3997                                        unwrap(RHS), Name));
3998 }
3999
4000 LLVMValueRef LLVMBuildAtomicRMW(LLVMBuilderRef B,LLVMAtomicRMWBinOp op,
4001                                LLVMValueRef PTR, LLVMValueRef Val,
4002                                LLVMAtomicOrdering ordering,
4003                                LLVMBool singleThread) {
4004   AtomicRMWInst::BinOp intop = mapFromLLVMRMWBinOp(op);
4005   return wrap(unwrap(B)->CreateAtomicRMW(
4006       intop, unwrap(PTR), unwrap(Val), MaybeAlign(),
4007       mapFromLLVMOrdering(ordering),
4008       singleThread ? SyncScope::SingleThread : SyncScope::System));
4009 }
4010
4011 LLVMValueRef LLVMBuildAtomicCmpXchg(LLVMBuilderRef B, LLVMValueRef Ptr,
4012                                     LLVMValueRef Cmp, LLVMValueRef New,
4013                                     LLVMAtomicOrdering SuccessOrdering,
4014                                     LLVMAtomicOrdering FailureOrdering,
4015                                     LLVMBool singleThread) {
4016
4017   return wrap(unwrap(B)->CreateAtomicCmpXchg(
4018       unwrap(Ptr), unwrap(Cmp), unwrap(New), MaybeAlign(),
4019       mapFromLLVMOrdering(SuccessOrdering),
4020       mapFromLLVMOrdering(FailureOrdering),
4021       singleThread ? SyncScope::SingleThread : SyncScope::System));
4022 }
4023
4024 unsigned LLVMGetNumMaskElements(LLVMValueRef SVInst) {
4025   Value *P = unwrap(SVInst);
4026   ShuffleVectorInst *I = cast<ShuffleVectorInst>(P);
4027   return I->getShuffleMask().size();
4028 }
4029
4030 int LLVMGetMaskValue(LLVMValueRef SVInst, unsigned Elt) {
4031   Value *P = unwrap(SVInst);
4032   ShuffleVectorInst *I = cast<ShuffleVectorInst>(P);
4033   return I->getMaskValue(Elt);
4034 }
4035
4036 int LLVMGetUndefMaskElem(void) { return PoisonMaskElem; }
4037
4038 LLVMBool LLVMIsAtomicSingleThread(LLVMValueRef AtomicInst) {
4039   Value *P = unwrap(AtomicInst);
4040
4041   if (AtomicRMWInst *I = dyn_cast<AtomicRMWInst>(P))
4042     return I->getSyncScopeID() == SyncScope::SingleThread;
4043   else if (FenceInst *FI = dyn_cast<FenceInst>(P))
4044     return FI->getSyncScopeID() == SyncScope::SingleThread;
4045   else if (StoreInst *SI = dyn_cast<StoreInst>(P))
4046     return SI->getSyncScopeID() == SyncScope::SingleThread;
4047   else if (LoadInst *LI = dyn_cast<LoadInst>(P))
4048     return LI->getSyncScopeID() == SyncScope::SingleThread;
4049   return cast<AtomicCmpXchgInst>(P)->getSyncScopeID() ==
4050              SyncScope::SingleThread;
4051 }
4052
4053 void LLVMSetAtomicSingleThread(LLVMValueRef AtomicInst, LLVMBool NewValue) {
4054   Value *P = unwrap(AtomicInst);
4055   SyncScope::ID SSID = NewValue ? SyncScope::SingleThread : SyncScope::System;
4056
4057   if (AtomicRMWInst *I = dyn_cast<AtomicRMWInst>(P))
4058     return I->setSyncScopeID(SSID);
4059   else if (FenceInst *FI = dyn_cast<FenceInst>(P))
4060     return FI->setSyncScopeID(SSID);
4061   else if (StoreInst *SI = dyn_cast<StoreInst>(P))
4062     return SI->setSyncScopeID(SSID);
4063   else if (LoadInst *LI = dyn_cast<LoadInst>(P))
4064     return LI->setSyncScopeID(SSID);
4065   return cast<AtomicCmpXchgInst>(P)->setSyncScopeID(SSID);
4066 }
4067
4068 LLVMAtomicOrdering LLVMGetCmpXchgSuccessOrdering(LLVMValueRef CmpXchgInst)  {
4069   Value *P = unwrap(CmpXchgInst);
4070   return mapToLLVMOrdering(cast<AtomicCmpXchgInst>(P)->getSuccessOrdering());
4071 }
4072
4073 void LLVMSetCmpXchgSuccessOrdering(LLVMValueRef CmpXchgInst,
4074                                    LLVMAtomicOrdering Ordering) {
4075   Value *P = unwrap(CmpXchgInst);
4076   AtomicOrdering O = mapFromLLVMOrdering(Ordering);
4077
4078   return cast<AtomicCmpXchgInst>(P)->setSuccessOrdering(O);
4079 }
4080
4081 LLVMAtomicOrdering LLVMGetCmpXchgFailureOrdering(LLVMValueRef CmpXchgInst)  {
4082   Value *P = unwrap(CmpXchgInst);
4083   return mapToLLVMOrdering(cast<AtomicCmpXchgInst>(P)->getFailureOrdering());
4084 }
4085
4086 void LLVMSetCmpXchgFailureOrdering(LLVMValueRef CmpXchgInst,
4087                                    LLVMAtomicOrdering Ordering) {
4088   Value *P = unwrap(CmpXchgInst);
4089   AtomicOrdering O = mapFromLLVMOrdering(Ordering);
4090
4091   return cast<AtomicCmpXchgInst>(P)->setFailureOrdering(O);
4092 }
4093
4094 /*===-- Module providers --------------------------------------------------===*/
4095
4096 LLVMModuleProviderRef
4097 LLVMCreateModuleProviderForExistingModule(LLVMModuleRef M) {
4098   return reinterpret_cast<LLVMModuleProviderRef>(M);
4099 }
4100
4101 void LLVMDisposeModuleProvider(LLVMModuleProviderRef MP) {
4102   delete unwrap(MP);
4103 }
4104
4105
4106 /*===-- Memory buffers ----------------------------------------------------===*/
4107
4108 LLVMBool LLVMCreateMemoryBufferWithContentsOfFile(
4109     const char *Path,
4110     LLVMMemoryBufferRef *OutMemBuf,
4111     char **OutMessage) {
4112
4113   ErrorOr<std::unique_ptr<MemoryBuffer>> MBOrErr = MemoryBuffer::getFile(Path);
4114   if (std::error_code EC = MBOrErr.getError()) {
4115     *OutMessage = strdup(EC.message().c_str());
4116     return 1;
4117   }
4118   *OutMemBuf = wrap(MBOrErr.get().release());
4119   return 0;
4120 }
4121
4122 LLVMBool LLVMCreateMemoryBufferWithSTDIN(LLVMMemoryBufferRef *OutMemBuf,
4123                                          char **OutMessage) {
4124   ErrorOr<std::unique_ptr<MemoryBuffer>> MBOrErr = MemoryBuffer::getSTDIN();
4125   if (std::error_code EC = MBOrErr.getError()) {
4126     *OutMessage = strdup(EC.message().c_str());
4127     return 1;
4128   }
4129   *OutMemBuf = wrap(MBOrErr.get().release());
4130   return 0;
4131 }
4132
4133 LLVMMemoryBufferRef LLVMCreateMemoryBufferWithMemoryRange(
4134     const char *InputData,
4135     size_t InputDataLength,
4136     const char *BufferName,
4137     LLVMBool RequiresNullTerminator) {
4138
4139   return wrap(MemoryBuffer::getMemBuffer(StringRef(InputData, InputDataLength),
4140                                          StringRef(BufferName),
4141                                          RequiresNullTerminator).release());
4142 }
4143
4144 LLVMMemoryBufferRef LLVMCreateMemoryBufferWithMemoryRangeCopy(
4145     const char *InputData,
4146     size_t InputDataLength,
4147     const char *BufferName) {
4148
4149   return wrap(
4150       MemoryBuffer::getMemBufferCopy(StringRef(InputData, InputDataLength),
4151                                      StringRef(BufferName)).release());
4152 }
4153
4154 const char *LLVMGetBufferStart(LLVMMemoryBufferRef MemBuf) {
4155   return unwrap(MemBuf)->getBufferStart();
4156 }
4157
4158 size_t LLVMGetBufferSize(LLVMMemoryBufferRef MemBuf) {
4159   return unwrap(MemBuf)->getBufferSize();
4160 }
4161
4162 void LLVMDisposeMemoryBuffer(LLVMMemoryBufferRef MemBuf) {
4163   delete unwrap(MemBuf);
4164 }
4165
4166 /*===-- Pass Manager ------------------------------------------------------===*/
4167
4168 LLVMPassManagerRef LLVMCreatePassManager() {
4169   return wrap(new legacy::PassManager());
4170 }
4171
4172 LLVMPassManagerRef LLVMCreateFunctionPassManagerForModule(LLVMModuleRef M) {
4173   return wrap(new legacy::FunctionPassManager(unwrap(M)));
4174 }
4175
4176 LLVMPassManagerRef LLVMCreateFunctionPassManager(LLVMModuleProviderRef P) {
4177   return LLVMCreateFunctionPassManagerForModule(
4178                                             reinterpret_cast<LLVMModuleRef>(P));
4179 }
4180
4181 LLVMBool LLVMRunPassManager(LLVMPassManagerRef PM, LLVMModuleRef M) {
4182   return unwrap<legacy::PassManager>(PM)->run(*unwrap(M));
4183 }
4184
4185 LLVMBool LLVMInitializeFunctionPassManager(LLVMPassManagerRef FPM) {
4186   return unwrap<legacy::FunctionPassManager>(FPM)->doInitialization();
4187 }
4188
4189 LLVMBool LLVMRunFunctionPassManager(LLVMPassManagerRef FPM, LLVMValueRef F) {
4190   return unwrap<legacy::FunctionPassManager>(FPM)->run(*unwrap<Function>(F));
4191 }
4192
4193 LLVMBool LLVMFinalizeFunctionPassManager(LLVMPassManagerRef FPM) {
4194   return unwrap<legacy::FunctionPassManager>(FPM)->doFinalization();
4195 }
4196
4197 void LLVMDisposePassManager(LLVMPassManagerRef PM) {
4198   delete unwrap(PM);
4199 }
4200
4201 /*===-- Threading ------------------------------------------------------===*/
4202
4203 LLVMBool LLVMStartMultithreaded() {
4204   return LLVMIsMultithreaded();
4205 }
4206
4207 void LLVMStopMultithreaded() {
4208 }
4209
4210 LLVMBool LLVMIsMultithreaded() {
4211   return llvm_is_multithreaded();
4212 }