fork/rust

git clone https://git.julia.blue/fork/rust

borsAuto merge of #67350 - Mark-Simulacrum:stable-next, r=Mark-Simulacrum73528e339aa

1.40.0
55.6 KiB1566 linesraw
1#include "rustllvm.h"
2#include "llvm/IR/CallSite.h"
3#include "llvm/IR/DebugInfoMetadata.h"
4#include "llvm/IR/DiagnosticInfo.h"
5#include "llvm/IR/DiagnosticPrinter.h"
6#include "llvm/IR/GlobalVariable.h"
7#include "llvm/IR/Instructions.h"
8#include "llvm/Object/Archive.h"
9#include "llvm/Object/ObjectFile.h"
10#include "llvm/Bitcode/BitcodeWriterPass.h"
11#include "llvm/Support/Signals.h"
12#include "llvm/ADT/Optional.h"
13
14#include <iostream>
15
16//===----------------------------------------------------------------------===
17//
18// This file defines alternate interfaces to core functions that are more
19// readily callable by Rust's FFI.
20//
21//===----------------------------------------------------------------------===
22
23using namespace llvm;
24using namespace llvm::sys;
25using namespace llvm::object;
26
27// LLVMAtomicOrdering is already an enum - don't create another
28// one.
29static AtomicOrdering fromRust(LLVMAtomicOrdering Ordering) {
30  switch (Ordering) {
31  case LLVMAtomicOrderingNotAtomic:
32    return AtomicOrdering::NotAtomic;
33  case LLVMAtomicOrderingUnordered:
34    return AtomicOrdering::Unordered;
35  case LLVMAtomicOrderingMonotonic:
36    return AtomicOrdering::Monotonic;
37  case LLVMAtomicOrderingAcquire:
38    return AtomicOrdering::Acquire;
39  case LLVMAtomicOrderingRelease:
40    return AtomicOrdering::Release;
41  case LLVMAtomicOrderingAcquireRelease:
42    return AtomicOrdering::AcquireRelease;
43  case LLVMAtomicOrderingSequentiallyConsistent:
44    return AtomicOrdering::SequentiallyConsistent;
45  }
46
47  report_fatal_error("Invalid LLVMAtomicOrdering value!");
48}
49
50static LLVM_THREAD_LOCAL char *LastError;
51
52// Custom error handler for fatal LLVM errors.
53//
54// Notably it exits the process with code 101, unlike LLVM's default of 1.
55static void FatalErrorHandler(void *UserData,
56                              const std::string& Reason,
57                              bool GenCrashDiag) {
58  // Do the same thing that the default error handler does.
59  std::cerr << "LLVM ERROR: " << Reason << std::endl;
60
61  // Since this error handler exits the process, we have to run any cleanup that
62  // LLVM would run after handling the error. This might change with an LLVM
63  // upgrade.
64  sys::RunInterruptHandlers();
65
66  exit(101);
67}
68
69extern "C" void LLVMRustInstallFatalErrorHandler() {
70  install_fatal_error_handler(FatalErrorHandler);
71}
72
73extern "C" LLVMMemoryBufferRef
74LLVMRustCreateMemoryBufferWithContentsOfFile(const char *Path) {
75  ErrorOr<std::unique_ptr<MemoryBuffer>> BufOr =
76      MemoryBuffer::getFile(Path, -1, false);
77  if (!BufOr) {
78    LLVMRustSetLastError(BufOr.getError().message().c_str());
79    return nullptr;
80  }
81  return wrap(BufOr.get().release());
82}
83
84extern "C" char *LLVMRustGetLastError(void) {
85  char *Ret = LastError;
86  LastError = nullptr;
87  return Ret;
88}
89
90extern "C" void LLVMRustSetLastError(const char *Err) {
91  free((void *)LastError);
92  LastError = strdup(Err);
93}
94
95extern "C" LLVMContextRef LLVMRustContextCreate(bool shouldDiscardNames) {
96  auto ctx = new LLVMContext();
97  ctx->setDiscardValueNames(shouldDiscardNames);
98  return wrap(ctx);
99}
100
101extern "C" void LLVMRustSetNormalizedTarget(LLVMModuleRef M,
102                                            const char *Triple) {
103  unwrap(M)->setTargetTriple(Triple::normalize(Triple));
104}
105
106extern "C" void LLVMRustPrintPassTimings() {
107  raw_fd_ostream OS(2, false); // stderr.
108  TimerGroup::printAll(OS);
109}
110
111extern "C" LLVMValueRef LLVMRustGetNamedValue(LLVMModuleRef M,
112                                              const char *Name) {
113  return wrap(unwrap(M)->getNamedValue(Name));
114}
115
116extern "C" LLVMValueRef LLVMRustGetOrInsertFunction(LLVMModuleRef M,
117                                                    const char *Name,
118                                                    LLVMTypeRef FunctionTy) {
119  return wrap(
120      unwrap(M)->getOrInsertFunction(Name, unwrap<FunctionType>(FunctionTy))
121#if LLVM_VERSION_GE(9, 0)
122      .getCallee()
123#endif
124      );
125}
126
127extern "C" LLVMValueRef
128LLVMRustGetOrInsertGlobal(LLVMModuleRef M, const char *Name, LLVMTypeRef Ty) {
129  return wrap(unwrap(M)->getOrInsertGlobal(Name, unwrap(Ty)));
130}
131
132extern "C" LLVMValueRef
133LLVMRustInsertPrivateGlobal(LLVMModuleRef M, LLVMTypeRef Ty) {
134  return wrap(new GlobalVariable(*unwrap(M),
135                                 unwrap(Ty),
136                                 false,
137                                 GlobalValue::PrivateLinkage,
138                                 nullptr));
139}
140
141extern "C" LLVMTypeRef LLVMRustMetadataTypeInContext(LLVMContextRef C) {
142  return wrap(Type::getMetadataTy(*unwrap(C)));
143}
144
145static Attribute::AttrKind fromRust(LLVMRustAttribute Kind) {
146  switch (Kind) {
147  case AlwaysInline:
148    return Attribute::AlwaysInline;
149  case ByVal:
150    return Attribute::ByVal;
151  case Cold:
152    return Attribute::Cold;
153  case InlineHint:
154    return Attribute::InlineHint;
155  case MinSize:
156    return Attribute::MinSize;
157  case Naked:
158    return Attribute::Naked;
159  case NoAlias:
160    return Attribute::NoAlias;
161  case NoCapture:
162    return Attribute::NoCapture;
163  case NoInline:
164    return Attribute::NoInline;
165  case NonNull:
166    return Attribute::NonNull;
167  case NoRedZone:
168    return Attribute::NoRedZone;
169  case NoReturn:
170    return Attribute::NoReturn;
171  case NoUnwind:
172    return Attribute::NoUnwind;
173  case OptimizeForSize:
174    return Attribute::OptimizeForSize;
175  case ReadOnly:
176    return Attribute::ReadOnly;
177  case SExt:
178    return Attribute::SExt;
179  case StructRet:
180    return Attribute::StructRet;
181  case UWTable:
182    return Attribute::UWTable;
183  case ZExt:
184    return Attribute::ZExt;
185  case InReg:
186    return Attribute::InReg;
187  case SanitizeThread:
188    return Attribute::SanitizeThread;
189  case SanitizeAddress:
190    return Attribute::SanitizeAddress;
191  case SanitizeMemory:
192    return Attribute::SanitizeMemory;
193  case NonLazyBind:
194    return Attribute::NonLazyBind;
195  case OptimizeNone:
196    return Attribute::OptimizeNone;
197  case ReturnsTwice:
198    return Attribute::ReturnsTwice;
199  }
200  report_fatal_error("bad AttributeKind");
201}
202
203extern "C" void LLVMRustAddCallSiteAttribute(LLVMValueRef Instr, unsigned Index,
204                                             LLVMRustAttribute RustAttr) {
205  CallSite Call = CallSite(unwrap<Instruction>(Instr));
206  Attribute Attr = Attribute::get(Call->getContext(), fromRust(RustAttr));
207  Call.addAttribute(Index, Attr);
208}
209
210extern "C" void LLVMRustAddAlignmentCallSiteAttr(LLVMValueRef Instr,
211                                                 unsigned Index,
212                                                 uint32_t Bytes) {
213  CallSite Call = CallSite(unwrap<Instruction>(Instr));
214  AttrBuilder B;
215  B.addAlignmentAttr(Bytes);
216  Call.setAttributes(Call.getAttributes().addAttributes(
217      Call->getContext(), Index, B));
218}
219
220extern "C" void LLVMRustAddDereferenceableCallSiteAttr(LLVMValueRef Instr,
221                                                       unsigned Index,
222                                                       uint64_t Bytes) {
223  CallSite Call = CallSite(unwrap<Instruction>(Instr));
224  AttrBuilder B;
225  B.addDereferenceableAttr(Bytes);
226  Call.setAttributes(Call.getAttributes().addAttributes(
227      Call->getContext(), Index, B));
228}
229
230extern "C" void LLVMRustAddDereferenceableOrNullCallSiteAttr(LLVMValueRef Instr,
231                                                             unsigned Index,
232                                                             uint64_t Bytes) {
233  CallSite Call = CallSite(unwrap<Instruction>(Instr));
234  AttrBuilder B;
235  B.addDereferenceableOrNullAttr(Bytes);
236  Call.setAttributes(Call.getAttributes().addAttributes(
237      Call->getContext(), Index, B));
238}
239
240extern "C" void LLVMRustAddByValCallSiteAttr(LLVMValueRef Instr, unsigned Index,
241                                             LLVMTypeRef Ty) {
242  CallSite Call = CallSite(unwrap<Instruction>(Instr));
243#if LLVM_VERSION_GE(9, 0)
244  Attribute Attr = Attribute::getWithByValType(Call->getContext(), unwrap(Ty));
245#else
246  Attribute Attr = Attribute::get(Call->getContext(), Attribute::ByVal);
247#endif
248  Call.addAttribute(Index, Attr);
249}
250
251extern "C" void LLVMRustAddFunctionAttribute(LLVMValueRef Fn, unsigned Index,
252                                             LLVMRustAttribute RustAttr) {
253  Function *A = unwrap<Function>(Fn);
254  Attribute Attr = Attribute::get(A->getContext(), fromRust(RustAttr));
255  AttrBuilder B(Attr);
256  A->addAttributes(Index, B);
257}
258
259extern "C" void LLVMRustAddAlignmentAttr(LLVMValueRef Fn,
260                                         unsigned Index,
261                                         uint32_t Bytes) {
262  Function *A = unwrap<Function>(Fn);
263  AttrBuilder B;
264  B.addAlignmentAttr(Bytes);
265  A->addAttributes(Index, B);
266}
267
268extern "C" void LLVMRustAddDereferenceableAttr(LLVMValueRef Fn, unsigned Index,
269                                               uint64_t Bytes) {
270  Function *A = unwrap<Function>(Fn);
271  AttrBuilder B;
272  B.addDereferenceableAttr(Bytes);
273  A->addAttributes(Index, B);
274}
275
276extern "C" void LLVMRustAddDereferenceableOrNullAttr(LLVMValueRef Fn,
277                                                     unsigned Index,
278                                                     uint64_t Bytes) {
279  Function *A = unwrap<Function>(Fn);
280  AttrBuilder B;
281  B.addDereferenceableOrNullAttr(Bytes);
282  A->addAttributes(Index, B);
283}
284
285extern "C" void LLVMRustAddByValAttr(LLVMValueRef Fn, unsigned Index,
286                                     LLVMTypeRef Ty) {
287  Function *F = unwrap<Function>(Fn);
288#if LLVM_VERSION_GE(9, 0)
289  Attribute Attr = Attribute::getWithByValType(F->getContext(), unwrap(Ty));
290#else
291  Attribute Attr = Attribute::get(F->getContext(), Attribute::ByVal);
292#endif
293  F->addAttribute(Index, Attr);
294}
295
296extern "C" void LLVMRustAddFunctionAttrStringValue(LLVMValueRef Fn,
297                                                   unsigned Index,
298                                                   const char *Name,
299                                                   const char *Value) {
300  Function *F = unwrap<Function>(Fn);
301  AttrBuilder B;
302  B.addAttribute(Name, Value);
303  F->addAttributes(Index, B);
304}
305
306extern "C" void LLVMRustRemoveFunctionAttributes(LLVMValueRef Fn,
307                                                 unsigned Index,
308                                                 LLVMRustAttribute RustAttr) {
309  Function *F = unwrap<Function>(Fn);
310  Attribute Attr = Attribute::get(F->getContext(), fromRust(RustAttr));
311  AttrBuilder B(Attr);
312  auto PAL = F->getAttributes();
313  auto PALNew = PAL.removeAttributes(F->getContext(), Index, B);
314  F->setAttributes(PALNew);
315}
316
317// enable fpmath flag UnsafeAlgebra
318extern "C" void LLVMRustSetHasUnsafeAlgebra(LLVMValueRef V) {
319  if (auto I = dyn_cast<Instruction>(unwrap<Value>(V))) {
320    I->setFast(true);
321  }
322}
323
324extern "C" LLVMValueRef
325LLVMRustBuildAtomicLoad(LLVMBuilderRef B, LLVMValueRef Source, const char *Name,
326                        LLVMAtomicOrdering Order) {
327  LoadInst *LI = new LoadInst(unwrap(Source));
328  LI->setAtomic(fromRust(Order));
329  return wrap(unwrap(B)->Insert(LI, Name));
330}
331
332extern "C" LLVMValueRef LLVMRustBuildAtomicStore(LLVMBuilderRef B,
333                                                 LLVMValueRef V,
334                                                 LLVMValueRef Target,
335                                                 LLVMAtomicOrdering Order) {
336  StoreInst *SI = new StoreInst(unwrap(V), unwrap(Target));
337  SI->setAtomic(fromRust(Order));
338  return wrap(unwrap(B)->Insert(SI));
339}
340
341extern "C" LLVMValueRef
342LLVMRustBuildAtomicCmpXchg(LLVMBuilderRef B, LLVMValueRef Target,
343                           LLVMValueRef Old, LLVMValueRef Source,
344                           LLVMAtomicOrdering Order,
345                           LLVMAtomicOrdering FailureOrder, LLVMBool Weak) {
346  AtomicCmpXchgInst *ACXI = unwrap(B)->CreateAtomicCmpXchg(
347      unwrap(Target), unwrap(Old), unwrap(Source), fromRust(Order),
348      fromRust(FailureOrder));
349  ACXI->setWeak(Weak);
350  return wrap(ACXI);
351}
352
353enum class LLVMRustSynchronizationScope {
354  Other,
355  SingleThread,
356  CrossThread,
357};
358
359static SyncScope::ID fromRust(LLVMRustSynchronizationScope Scope) {
360  switch (Scope) {
361  case LLVMRustSynchronizationScope::SingleThread:
362    return SyncScope::SingleThread;
363  case LLVMRustSynchronizationScope::CrossThread:
364    return SyncScope::System;
365  default:
366    report_fatal_error("bad SynchronizationScope.");
367  }
368}
369
370extern "C" LLVMValueRef
371LLVMRustBuildAtomicFence(LLVMBuilderRef B, LLVMAtomicOrdering Order,
372                         LLVMRustSynchronizationScope Scope) {
373  return wrap(unwrap(B)->CreateFence(fromRust(Order), fromRust(Scope)));
374}
375
376enum class LLVMRustAsmDialect {
377  Other,
378  Att,
379  Intel,
380};
381
382static InlineAsm::AsmDialect fromRust(LLVMRustAsmDialect Dialect) {
383  switch (Dialect) {
384  case LLVMRustAsmDialect::Att:
385    return InlineAsm::AD_ATT;
386  case LLVMRustAsmDialect::Intel:
387    return InlineAsm::AD_Intel;
388  default:
389    report_fatal_error("bad AsmDialect.");
390  }
391}
392
393extern "C" LLVMValueRef LLVMRustInlineAsm(LLVMTypeRef Ty, char *AsmString,
394                                          char *Constraints,
395                                          LLVMBool HasSideEffects,
396                                          LLVMBool IsAlignStack,
397                                          LLVMRustAsmDialect Dialect) {
398  return wrap(InlineAsm::get(unwrap<FunctionType>(Ty), AsmString, Constraints,
399                             HasSideEffects, IsAlignStack, fromRust(Dialect)));
400}
401
402extern "C" bool LLVMRustInlineAsmVerify(LLVMTypeRef Ty,
403                                          char *Constraints) {
404  return InlineAsm::Verify(unwrap<FunctionType>(Ty), Constraints);
405}
406
407extern "C" void LLVMRustAppendModuleInlineAsm(LLVMModuleRef M, const char *Asm) {
408  unwrap(M)->appendModuleInlineAsm(StringRef(Asm));
409}
410
411typedef DIBuilder *LLVMRustDIBuilderRef;
412
413template <typename DIT> DIT *unwrapDIPtr(LLVMMetadataRef Ref) {
414  return (DIT *)(Ref ? unwrap<MDNode>(Ref) : nullptr);
415}
416
417#define DIDescriptor DIScope
418#define DIArray DINodeArray
419#define unwrapDI unwrapDIPtr
420
421// These values **must** match debuginfo::DIFlags! They also *happen*
422// to match LLVM, but that isn't required as we do giant sets of
423// matching below. The value shouldn't be directly passed to LLVM.
424enum class LLVMRustDIFlags : uint32_t {
425  FlagZero = 0,
426  FlagPrivate = 1,
427  FlagProtected = 2,
428  FlagPublic = 3,
429  FlagFwdDecl = (1 << 2),
430  FlagAppleBlock = (1 << 3),
431  FlagBlockByrefStruct = (1 << 4),
432  FlagVirtual = (1 << 5),
433  FlagArtificial = (1 << 6),
434  FlagExplicit = (1 << 7),
435  FlagPrototyped = (1 << 8),
436  FlagObjcClassComplete = (1 << 9),
437  FlagObjectPointer = (1 << 10),
438  FlagVector = (1 << 11),
439  FlagStaticMember = (1 << 12),
440  FlagLValueReference = (1 << 13),
441  FlagRValueReference = (1 << 14),
442  FlagExternalTypeRef = (1 << 15),
443  FlagIntroducedVirtual = (1 << 18),
444  FlagBitField = (1 << 19),
445  FlagNoReturn = (1 << 20),
446  // Do not add values that are not supported by the minimum LLVM
447  // version we support! see llvm/include/llvm/IR/DebugInfoFlags.def
448};
449
450inline LLVMRustDIFlags operator&(LLVMRustDIFlags A, LLVMRustDIFlags B) {
451  return static_cast<LLVMRustDIFlags>(static_cast<uint32_t>(A) &
452                                      static_cast<uint32_t>(B));
453}
454
455inline LLVMRustDIFlags operator|(LLVMRustDIFlags A, LLVMRustDIFlags B) {
456  return static_cast<LLVMRustDIFlags>(static_cast<uint32_t>(A) |
457                                      static_cast<uint32_t>(B));
458}
459
460inline LLVMRustDIFlags &operator|=(LLVMRustDIFlags &A, LLVMRustDIFlags B) {
461  return A = A | B;
462}
463
464inline bool isSet(LLVMRustDIFlags F) { return F != LLVMRustDIFlags::FlagZero; }
465
466inline LLVMRustDIFlags visibility(LLVMRustDIFlags F) {
467  return static_cast<LLVMRustDIFlags>(static_cast<uint32_t>(F) & 0x3);
468}
469
470static DINode::DIFlags fromRust(LLVMRustDIFlags Flags) {
471  DINode::DIFlags Result = DINode::DIFlags::FlagZero;
472
473  switch (visibility(Flags)) {
474  case LLVMRustDIFlags::FlagPrivate:
475    Result |= DINode::DIFlags::FlagPrivate;
476    break;
477  case LLVMRustDIFlags::FlagProtected:
478    Result |= DINode::DIFlags::FlagProtected;
479    break;
480  case LLVMRustDIFlags::FlagPublic:
481    Result |= DINode::DIFlags::FlagPublic;
482    break;
483  default:
484    // The rest are handled below
485    break;
486  }
487
488  if (isSet(Flags & LLVMRustDIFlags::FlagFwdDecl)) {
489    Result |= DINode::DIFlags::FlagFwdDecl;
490  }
491  if (isSet(Flags & LLVMRustDIFlags::FlagAppleBlock)) {
492    Result |= DINode::DIFlags::FlagAppleBlock;
493  }
494  if (isSet(Flags & LLVMRustDIFlags::FlagBlockByrefStruct)) {
495    Result |= DINode::DIFlags::FlagBlockByrefStruct;
496  }
497  if (isSet(Flags & LLVMRustDIFlags::FlagVirtual)) {
498    Result |= DINode::DIFlags::FlagVirtual;
499  }
500  if (isSet(Flags & LLVMRustDIFlags::FlagArtificial)) {
501    Result |= DINode::DIFlags::FlagArtificial;
502  }
503  if (isSet(Flags & LLVMRustDIFlags::FlagExplicit)) {
504    Result |= DINode::DIFlags::FlagExplicit;
505  }
506  if (isSet(Flags & LLVMRustDIFlags::FlagPrototyped)) {
507    Result |= DINode::DIFlags::FlagPrototyped;
508  }
509  if (isSet(Flags & LLVMRustDIFlags::FlagObjcClassComplete)) {
510    Result |= DINode::DIFlags::FlagObjcClassComplete;
511  }
512  if (isSet(Flags & LLVMRustDIFlags::FlagObjectPointer)) {
513    Result |= DINode::DIFlags::FlagObjectPointer;
514  }
515  if (isSet(Flags & LLVMRustDIFlags::FlagVector)) {
516    Result |= DINode::DIFlags::FlagVector;
517  }
518  if (isSet(Flags & LLVMRustDIFlags::FlagStaticMember)) {
519    Result |= DINode::DIFlags::FlagStaticMember;
520  }
521  if (isSet(Flags & LLVMRustDIFlags::FlagLValueReference)) {
522    Result |= DINode::DIFlags::FlagLValueReference;
523  }
524  if (isSet(Flags & LLVMRustDIFlags::FlagRValueReference)) {
525    Result |= DINode::DIFlags::FlagRValueReference;
526  }
527  if (isSet(Flags & LLVMRustDIFlags::FlagIntroducedVirtual)) {
528    Result |= DINode::DIFlags::FlagIntroducedVirtual;
529  }
530  if (isSet(Flags & LLVMRustDIFlags::FlagBitField)) {
531    Result |= DINode::DIFlags::FlagBitField;
532  }
533  if (isSet(Flags & LLVMRustDIFlags::FlagNoReturn)) {
534    Result |= DINode::DIFlags::FlagNoReturn;
535  }
536
537  return Result;
538}
539
540// These values **must** match debuginfo::DISPFlags! They also *happen*
541// to match LLVM, but that isn't required as we do giant sets of
542// matching below. The value shouldn't be directly passed to LLVM.
543enum class LLVMRustDISPFlags : uint32_t {
544  SPFlagZero = 0,
545  SPFlagVirtual = 1,
546  SPFlagPureVirtual = 2,
547  SPFlagLocalToUnit = (1 << 2),
548  SPFlagDefinition = (1 << 3),
549  SPFlagOptimized = (1 << 4),
550  SPFlagMainSubprogram = (1 << 5),
551  // Do not add values that are not supported by the minimum LLVM
552  // version we support! see llvm/include/llvm/IR/DebugInfoFlags.def
553  // (In LLVM < 8, createFunction supported these as separate bool arguments.)
554};
555
556inline LLVMRustDISPFlags operator&(LLVMRustDISPFlags A, LLVMRustDISPFlags B) {
557  return static_cast<LLVMRustDISPFlags>(static_cast<uint32_t>(A) &
558                                      static_cast<uint32_t>(B));
559}
560
561inline LLVMRustDISPFlags operator|(LLVMRustDISPFlags A, LLVMRustDISPFlags B) {
562  return static_cast<LLVMRustDISPFlags>(static_cast<uint32_t>(A) |
563                                      static_cast<uint32_t>(B));
564}
565
566inline LLVMRustDISPFlags &operator|=(LLVMRustDISPFlags &A, LLVMRustDISPFlags B) {
567  return A = A | B;
568}
569
570inline bool isSet(LLVMRustDISPFlags F) { return F != LLVMRustDISPFlags::SPFlagZero; }
571
572inline LLVMRustDISPFlags virtuality(LLVMRustDISPFlags F) {
573  return static_cast<LLVMRustDISPFlags>(static_cast<uint32_t>(F) & 0x3);
574}
575
576#if LLVM_VERSION_GE(8, 0)
577static DISubprogram::DISPFlags fromRust(LLVMRustDISPFlags SPFlags) {
578  DISubprogram::DISPFlags Result = DISubprogram::DISPFlags::SPFlagZero;
579
580  switch (virtuality(SPFlags)) {
581  case LLVMRustDISPFlags::SPFlagVirtual:
582    Result |= DISubprogram::DISPFlags::SPFlagVirtual;
583    break;
584  case LLVMRustDISPFlags::SPFlagPureVirtual:
585    Result |= DISubprogram::DISPFlags::SPFlagPureVirtual;
586    break;
587  default:
588    // The rest are handled below
589    break;
590  }
591
592  if (isSet(SPFlags & LLVMRustDISPFlags::SPFlagLocalToUnit)) {
593    Result |= DISubprogram::DISPFlags::SPFlagLocalToUnit;
594  }
595  if (isSet(SPFlags & LLVMRustDISPFlags::SPFlagDefinition)) {
596    Result |= DISubprogram::DISPFlags::SPFlagDefinition;
597  }
598  if (isSet(SPFlags & LLVMRustDISPFlags::SPFlagOptimized)) {
599    Result |= DISubprogram::DISPFlags::SPFlagOptimized;
600  }
601#if LLVM_VERSION_GE(9, 0)
602  if (isSet(SPFlags & LLVMRustDISPFlags::SPFlagMainSubprogram)) {
603    Result |= DISubprogram::DISPFlags::SPFlagMainSubprogram;
604  }
605#endif
606
607  return Result;
608}
609#endif
610
611enum class LLVMRustDebugEmissionKind {
612  NoDebug,
613  FullDebug,
614  LineTablesOnly,
615};
616
617static DICompileUnit::DebugEmissionKind fromRust(LLVMRustDebugEmissionKind Kind) {
618  switch (Kind) {
619  case LLVMRustDebugEmissionKind::NoDebug:
620    return DICompileUnit::DebugEmissionKind::NoDebug;
621  case LLVMRustDebugEmissionKind::FullDebug:
622    return DICompileUnit::DebugEmissionKind::FullDebug;
623  case LLVMRustDebugEmissionKind::LineTablesOnly:
624    return DICompileUnit::DebugEmissionKind::LineTablesOnly;
625  default:
626    report_fatal_error("bad DebugEmissionKind.");
627  }
628}
629
630extern "C" uint32_t LLVMRustDebugMetadataVersion() {
631  return DEBUG_METADATA_VERSION;
632}
633
634extern "C" uint32_t LLVMRustVersionMinor() { return LLVM_VERSION_MINOR; }
635
636extern "C" uint32_t LLVMRustVersionMajor() { return LLVM_VERSION_MAJOR; }
637
638extern "C" void LLVMRustAddModuleFlag(LLVMModuleRef M, const char *Name,
639                                      uint32_t Value) {
640  unwrap(M)->addModuleFlag(Module::Warning, Name, Value);
641}
642
643extern "C" LLVMValueRef LLVMRustMetadataAsValue(LLVMContextRef C, LLVMMetadataRef MD) {
644  return wrap(MetadataAsValue::get(*unwrap(C), unwrap(MD)));
645}
646
647extern "C" LLVMRustDIBuilderRef LLVMRustDIBuilderCreate(LLVMModuleRef M) {
648  return new DIBuilder(*unwrap(M));
649}
650
651extern "C" void LLVMRustDIBuilderDispose(LLVMRustDIBuilderRef Builder) {
652  delete Builder;
653}
654
655extern "C" void LLVMRustDIBuilderFinalize(LLVMRustDIBuilderRef Builder) {
656  Builder->finalize();
657}
658
659extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateCompileUnit(
660    LLVMRustDIBuilderRef Builder, unsigned Lang, LLVMMetadataRef FileRef,
661    const char *Producer, bool isOptimized, const char *Flags,
662    unsigned RuntimeVer, const char *SplitName,
663    LLVMRustDebugEmissionKind Kind) {
664  auto *File = unwrapDI<DIFile>(FileRef);
665
666  return wrap(Builder->createCompileUnit(Lang, File, Producer, isOptimized,
667                                         Flags, RuntimeVer, SplitName,
668                                         fromRust(Kind)));
669}
670
671extern "C" LLVMMetadataRef
672LLVMRustDIBuilderCreateFile(LLVMRustDIBuilderRef Builder, const char *Filename,
673                            const char *Directory) {
674  return wrap(Builder->createFile(Filename, Directory));
675}
676
677extern "C" LLVMMetadataRef
678LLVMRustDIBuilderCreateSubroutineType(LLVMRustDIBuilderRef Builder,
679                                      LLVMMetadataRef File,
680                                      LLVMMetadataRef ParameterTypes) {
681  return wrap(Builder->createSubroutineType(
682      DITypeRefArray(unwrap<MDTuple>(ParameterTypes))));
683}
684
685extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateFunction(
686    LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
687    const char *LinkageName, LLVMMetadataRef File, unsigned LineNo,
688    LLVMMetadataRef Ty, unsigned ScopeLine, LLVMRustDIFlags Flags,
689    LLVMRustDISPFlags SPFlags, LLVMValueRef Fn, LLVMMetadataRef TParam,
690    LLVMMetadataRef Decl) {
691  DITemplateParameterArray TParams =
692      DITemplateParameterArray(unwrap<MDTuple>(TParam));
693#if LLVM_VERSION_GE(8, 0)
694  DISubprogram::DISPFlags llvmSPFlags = fromRust(SPFlags);
695  DINode::DIFlags llvmFlags = fromRust(Flags);
696#if LLVM_VERSION_LT(9, 0)
697  if (isSet(SPFlags & LLVMRustDISPFlags::SPFlagMainSubprogram))
698    llvmFlags |= DINode::DIFlags::FlagMainSubprogram;
699#endif
700  DISubprogram *Sub = Builder->createFunction(
701      unwrapDI<DIScope>(Scope), Name, LinkageName, unwrapDI<DIFile>(File),
702      LineNo, unwrapDI<DISubroutineType>(Ty), ScopeLine, llvmFlags,
703      llvmSPFlags, TParams, unwrapDIPtr<DISubprogram>(Decl));
704#else
705  bool IsLocalToUnit = isSet(SPFlags & LLVMRustDISPFlags::SPFlagLocalToUnit);
706  bool IsDefinition = isSet(SPFlags & LLVMRustDISPFlags::SPFlagDefinition);
707  bool IsOptimized = isSet(SPFlags & LLVMRustDISPFlags::SPFlagOptimized);
708  DINode::DIFlags llvmFlags = fromRust(Flags);
709  if (isSet(SPFlags & LLVMRustDISPFlags::SPFlagMainSubprogram))
710    llvmFlags |= DINode::DIFlags::FlagMainSubprogram;
711  DISubprogram *Sub = Builder->createFunction(
712      unwrapDI<DIScope>(Scope), Name, LinkageName, unwrapDI<DIFile>(File),
713      LineNo, unwrapDI<DISubroutineType>(Ty), IsLocalToUnit, IsDefinition,
714      ScopeLine, llvmFlags, IsOptimized, TParams,
715      unwrapDIPtr<DISubprogram>(Decl));
716#endif
717  unwrap<Function>(Fn)->setSubprogram(Sub);
718  return wrap(Sub);
719}
720
721extern "C" LLVMMetadataRef
722LLVMRustDIBuilderCreateBasicType(LLVMRustDIBuilderRef Builder, const char *Name,
723                                 uint64_t SizeInBits, uint32_t AlignInBits,
724                                 unsigned Encoding) {
725  return wrap(Builder->createBasicType(Name, SizeInBits, Encoding));
726}
727
728extern "C" LLVMMetadataRef LLVMRustDIBuilderCreatePointerType(
729    LLVMRustDIBuilderRef Builder, LLVMMetadataRef PointeeTy,
730    uint64_t SizeInBits, uint32_t AlignInBits, const char *Name) {
731  return wrap(Builder->createPointerType(unwrapDI<DIType>(PointeeTy),
732                                         SizeInBits, AlignInBits,
733                                         /* DWARFAddressSpace */ None,
734                                         Name));
735}
736
737extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateStructType(
738    LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
739    LLVMMetadataRef File, unsigned LineNumber, uint64_t SizeInBits,
740    uint32_t AlignInBits, LLVMRustDIFlags Flags,
741    LLVMMetadataRef DerivedFrom, LLVMMetadataRef Elements,
742    unsigned RunTimeLang, LLVMMetadataRef VTableHolder,
743    const char *UniqueId) {
744  return wrap(Builder->createStructType(
745      unwrapDI<DIDescriptor>(Scope), Name, unwrapDI<DIFile>(File), LineNumber,
746      SizeInBits, AlignInBits, fromRust(Flags), unwrapDI<DIType>(DerivedFrom),
747      DINodeArray(unwrapDI<MDTuple>(Elements)), RunTimeLang,
748      unwrapDI<DIType>(VTableHolder), UniqueId));
749}
750
751extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateVariantPart(
752    LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
753    LLVMMetadataRef File, unsigned LineNumber, uint64_t SizeInBits,
754    uint32_t AlignInBits, LLVMRustDIFlags Flags, LLVMMetadataRef Discriminator,
755    LLVMMetadataRef Elements, const char *UniqueId) {
756#if LLVM_VERSION_GE(7, 0)
757  return wrap(Builder->createVariantPart(
758      unwrapDI<DIDescriptor>(Scope), Name, unwrapDI<DIFile>(File), LineNumber,
759      SizeInBits, AlignInBits, fromRust(Flags), unwrapDI<DIDerivedType>(Discriminator),
760      DINodeArray(unwrapDI<MDTuple>(Elements)), UniqueId));
761#else
762  abort();
763#endif
764}
765
766extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateMemberType(
767    LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
768    LLVMMetadataRef File, unsigned LineNo, uint64_t SizeInBits,
769    uint32_t AlignInBits, uint64_t OffsetInBits, LLVMRustDIFlags Flags,
770    LLVMMetadataRef Ty) {
771  return wrap(Builder->createMemberType(unwrapDI<DIDescriptor>(Scope), Name,
772                                        unwrapDI<DIFile>(File), LineNo,
773                                        SizeInBits, AlignInBits, OffsetInBits,
774                                        fromRust(Flags), unwrapDI<DIType>(Ty)));
775}
776
777extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateVariantMemberType(
778    LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope,
779    const char *Name, LLVMMetadataRef File, unsigned LineNo, uint64_t SizeInBits,
780    uint32_t AlignInBits, uint64_t OffsetInBits, LLVMValueRef Discriminant,
781    LLVMRustDIFlags Flags, LLVMMetadataRef Ty) {
782#if LLVM_VERSION_GE(7, 0)
783  llvm::ConstantInt* D = nullptr;
784  if (Discriminant) {
785    D = unwrap<llvm::ConstantInt>(Discriminant);
786  }
787  return wrap(Builder->createVariantMemberType(unwrapDI<DIDescriptor>(Scope), Name,
788                                               unwrapDI<DIFile>(File), LineNo,
789                                               SizeInBits, AlignInBits, OffsetInBits, D,
790                                               fromRust(Flags), unwrapDI<DIType>(Ty)));
791#else
792  return wrap(Builder->createMemberType(unwrapDI<DIDescriptor>(Scope), Name,
793                                        unwrapDI<DIFile>(File), LineNo,
794                                        SizeInBits, AlignInBits, OffsetInBits,
795                                        fromRust(Flags), unwrapDI<DIType>(Ty)));
796#endif
797}
798
799extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateLexicalBlock(
800    LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope,
801    LLVMMetadataRef File, unsigned Line, unsigned Col) {
802  return wrap(Builder->createLexicalBlock(unwrapDI<DIDescriptor>(Scope),
803                                          unwrapDI<DIFile>(File), Line, Col));
804}
805
806extern "C" LLVMMetadataRef
807LLVMRustDIBuilderCreateLexicalBlockFile(LLVMRustDIBuilderRef Builder,
808                                        LLVMMetadataRef Scope,
809                                        LLVMMetadataRef File) {
810  return wrap(Builder->createLexicalBlockFile(unwrapDI<DIDescriptor>(Scope),
811                                              unwrapDI<DIFile>(File)));
812}
813
814extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateStaticVariable(
815    LLVMRustDIBuilderRef Builder, LLVMMetadataRef Context, const char *Name,
816    const char *LinkageName, LLVMMetadataRef File, unsigned LineNo,
817    LLVMMetadataRef Ty, bool IsLocalToUnit, LLVMValueRef V,
818    LLVMMetadataRef Decl = nullptr, uint32_t AlignInBits = 0) {
819  llvm::GlobalVariable *InitVal = cast<llvm::GlobalVariable>(unwrap(V));
820
821  llvm::DIExpression *InitExpr = nullptr;
822  if (llvm::ConstantInt *IntVal = llvm::dyn_cast<llvm::ConstantInt>(InitVal)) {
823    InitExpr = Builder->createConstantValueExpression(
824        IntVal->getValue().getSExtValue());
825  } else if (llvm::ConstantFP *FPVal =
826                 llvm::dyn_cast<llvm::ConstantFP>(InitVal)) {
827    InitExpr = Builder->createConstantValueExpression(
828        FPVal->getValueAPF().bitcastToAPInt().getZExtValue());
829  }
830
831  llvm::DIGlobalVariableExpression *VarExpr = Builder->createGlobalVariableExpression(
832      unwrapDI<DIDescriptor>(Context), Name, LinkageName,
833      unwrapDI<DIFile>(File), LineNo, unwrapDI<DIType>(Ty), IsLocalToUnit,
834      InitExpr, unwrapDIPtr<MDNode>(Decl),
835#if LLVM_VERSION_GE(8, 0)
836      /* templateParams */ nullptr,
837#endif
838      AlignInBits);
839
840  InitVal->setMetadata("dbg", VarExpr);
841
842  return wrap(VarExpr);
843}
844
845extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateVariable(
846    LLVMRustDIBuilderRef Builder, unsigned Tag, LLVMMetadataRef Scope,
847    const char *Name, LLVMMetadataRef File, unsigned LineNo,
848    LLVMMetadataRef Ty, bool AlwaysPreserve, LLVMRustDIFlags Flags,
849    unsigned ArgNo, uint32_t AlignInBits) {
850  if (Tag == 0x100) { // DW_TAG_auto_variable
851    return wrap(Builder->createAutoVariable(
852        unwrapDI<DIDescriptor>(Scope), Name, unwrapDI<DIFile>(File), LineNo,
853        unwrapDI<DIType>(Ty), AlwaysPreserve, fromRust(Flags), AlignInBits));
854  } else {
855    return wrap(Builder->createParameterVariable(
856        unwrapDI<DIDescriptor>(Scope), Name, ArgNo, unwrapDI<DIFile>(File),
857        LineNo, unwrapDI<DIType>(Ty), AlwaysPreserve, fromRust(Flags)));
858  }
859}
860
861extern "C" LLVMMetadataRef
862LLVMRustDIBuilderCreateArrayType(LLVMRustDIBuilderRef Builder, uint64_t Size,
863                                 uint32_t AlignInBits, LLVMMetadataRef Ty,
864                                 LLVMMetadataRef Subscripts) {
865  return wrap(
866      Builder->createArrayType(Size, AlignInBits, unwrapDI<DIType>(Ty),
867                               DINodeArray(unwrapDI<MDTuple>(Subscripts))));
868}
869
870extern "C" LLVMMetadataRef
871LLVMRustDIBuilderGetOrCreateSubrange(LLVMRustDIBuilderRef Builder, int64_t Lo,
872                                     int64_t Count) {
873  return wrap(Builder->getOrCreateSubrange(Lo, Count));
874}
875
876extern "C" LLVMMetadataRef
877LLVMRustDIBuilderGetOrCreateArray(LLVMRustDIBuilderRef Builder,
878                                  LLVMMetadataRef *Ptr, unsigned Count) {
879  Metadata **DataValue = unwrap(Ptr);
880  return wrap(
881      Builder->getOrCreateArray(ArrayRef<Metadata *>(DataValue, Count)).get());
882}
883
884extern "C" LLVMValueRef LLVMRustDIBuilderInsertDeclareAtEnd(
885    LLVMRustDIBuilderRef Builder, LLVMValueRef V, LLVMMetadataRef VarInfo,
886    int64_t *AddrOps, unsigned AddrOpsCount, LLVMValueRef DL,
887    LLVMBasicBlockRef InsertAtEnd) {
888  return wrap(Builder->insertDeclare(
889      unwrap(V), unwrap<DILocalVariable>(VarInfo),
890      Builder->createExpression(llvm::ArrayRef<int64_t>(AddrOps, AddrOpsCount)),
891      DebugLoc(cast<MDNode>(unwrap<MetadataAsValue>(DL)->getMetadata())),
892      unwrap(InsertAtEnd)));
893}
894
895extern "C" LLVMMetadataRef
896LLVMRustDIBuilderCreateEnumerator(LLVMRustDIBuilderRef Builder,
897                                  const char *Name, uint64_t Val) {
898  return wrap(Builder->createEnumerator(Name, Val));
899}
900
901extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateEnumerationType(
902    LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
903    LLVMMetadataRef File, unsigned LineNumber, uint64_t SizeInBits,
904    uint32_t AlignInBits, LLVMMetadataRef Elements,
905    LLVMMetadataRef ClassTy, bool IsScoped) {
906#if LLVM_VERSION_GE(7, 0)
907  return wrap(Builder->createEnumerationType(
908      unwrapDI<DIDescriptor>(Scope), Name, unwrapDI<DIFile>(File), LineNumber,
909      SizeInBits, AlignInBits, DINodeArray(unwrapDI<MDTuple>(Elements)),
910      unwrapDI<DIType>(ClassTy), "", IsScoped));
911#else
912  // Ignore IsScoped on older LLVM.
913  return wrap(Builder->createEnumerationType(
914      unwrapDI<DIDescriptor>(Scope), Name, unwrapDI<DIFile>(File), LineNumber,
915      SizeInBits, AlignInBits, DINodeArray(unwrapDI<MDTuple>(Elements)),
916      unwrapDI<DIType>(ClassTy), ""));
917#endif
918}
919
920extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateUnionType(
921    LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
922    LLVMMetadataRef File, unsigned LineNumber, uint64_t SizeInBits,
923    uint32_t AlignInBits, LLVMRustDIFlags Flags, LLVMMetadataRef Elements,
924    unsigned RunTimeLang, const char *UniqueId) {
925  return wrap(Builder->createUnionType(
926      unwrapDI<DIDescriptor>(Scope), Name, unwrapDI<DIFile>(File), LineNumber,
927      SizeInBits, AlignInBits, fromRust(Flags),
928      DINodeArray(unwrapDI<MDTuple>(Elements)), RunTimeLang, UniqueId));
929}
930
931extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateTemplateTypeParameter(
932    LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
933    LLVMMetadataRef Ty, LLVMMetadataRef File, unsigned LineNo,
934    unsigned ColumnNo) {
935  return wrap(Builder->createTemplateTypeParameter(
936      unwrapDI<DIDescriptor>(Scope), Name, unwrapDI<DIType>(Ty)));
937}
938
939extern "C" LLVMMetadataRef
940LLVMRustDIBuilderCreateNameSpace(LLVMRustDIBuilderRef Builder,
941                                 LLVMMetadataRef Scope, const char *Name,
942                                 LLVMMetadataRef File, unsigned LineNo) {
943  return wrap(Builder->createNameSpace(
944      unwrapDI<DIDescriptor>(Scope), Name,
945      false // ExportSymbols (only relevant for C++ anonymous namespaces)
946      ));
947}
948
949extern "C" void
950LLVMRustDICompositeTypeReplaceArrays(LLVMRustDIBuilderRef Builder,
951                                     LLVMMetadataRef CompositeTy,
952                                     LLVMMetadataRef Elements,
953                                     LLVMMetadataRef Params) {
954  DICompositeType *Tmp = unwrapDI<DICompositeType>(CompositeTy);
955  Builder->replaceArrays(Tmp, DINodeArray(unwrap<MDTuple>(Elements)),
956                         DINodeArray(unwrap<MDTuple>(Params)));
957}
958
959extern "C" LLVMValueRef
960LLVMRustDIBuilderCreateDebugLocation(LLVMContextRef ContextRef, unsigned Line,
961                                     unsigned Column, LLVMMetadataRef Scope,
962                                     LLVMMetadataRef InlinedAt) {
963  LLVMContext &Context = *unwrap(ContextRef);
964
965  DebugLoc debug_loc = DebugLoc::get(Line, Column, unwrapDIPtr<MDNode>(Scope),
966                                     unwrapDIPtr<MDNode>(InlinedAt));
967
968  return wrap(MetadataAsValue::get(Context, debug_loc.getAsMDNode()));
969}
970
971extern "C" int64_t LLVMRustDIBuilderCreateOpDeref() {
972  return dwarf::DW_OP_deref;
973}
974
975extern "C" int64_t LLVMRustDIBuilderCreateOpPlusUconst() {
976  return dwarf::DW_OP_plus_uconst;
977}
978
979extern "C" void LLVMRustWriteTypeToString(LLVMTypeRef Ty, RustStringRef Str) {
980  RawRustStringOstream OS(Str);
981  unwrap<llvm::Type>(Ty)->print(OS);
982}
983
984extern "C" void LLVMRustWriteValueToString(LLVMValueRef V,
985                                           RustStringRef Str) {
986  RawRustStringOstream OS(Str);
987  if (!V) {
988    OS << "(null)";
989  } else {
990    OS << "(";
991    unwrap<llvm::Value>(V)->getType()->print(OS);
992    OS << ":";
993    unwrap<llvm::Value>(V)->print(OS);
994    OS << ")";
995  }
996}
997
998// Note that the two following functions look quite similar to the
999// LLVMGetSectionName function. Sadly, it appears that this function only
1000// returns a char* pointer, which isn't guaranteed to be null-terminated. The
1001// function provided by LLVM doesn't return the length, so we've created our own
1002// function which returns the length as well as the data pointer.
1003//
1004// For an example of this not returning a null terminated string, see
1005// lib/Object/COFFObjectFile.cpp in the getSectionName function. One of the
1006// branches explicitly creates a StringRef without a null terminator, and then
1007// that's returned.
1008
1009inline section_iterator *unwrap(LLVMSectionIteratorRef SI) {
1010  return reinterpret_cast<section_iterator *>(SI);
1011}
1012
1013extern "C" size_t LLVMRustGetSectionName(LLVMSectionIteratorRef SI,
1014                                         const char **Ptr) {
1015  StringRef Ret;
1016  if (std::error_code EC = (*unwrap(SI))->getName(Ret))
1017    report_fatal_error(EC.message());
1018  *Ptr = Ret.data();
1019  return Ret.size();
1020}
1021
1022// LLVMArrayType function does not support 64-bit ElementCount
1023extern "C" LLVMTypeRef LLVMRustArrayType(LLVMTypeRef ElementTy,
1024                                         uint64_t ElementCount) {
1025  return wrap(ArrayType::get(unwrap(ElementTy), ElementCount));
1026}
1027
1028DEFINE_SIMPLE_CONVERSION_FUNCTIONS(Twine, LLVMTwineRef)
1029
1030extern "C" void LLVMRustWriteTwineToString(LLVMTwineRef T, RustStringRef Str) {
1031  RawRustStringOstream OS(Str);
1032  unwrap(T)->print(OS);
1033}
1034
1035extern "C" void LLVMRustUnpackOptimizationDiagnostic(
1036    LLVMDiagnosticInfoRef DI, RustStringRef PassNameOut,
1037    LLVMValueRef *FunctionOut, unsigned* Line, unsigned* Column,
1038    RustStringRef FilenameOut, RustStringRef MessageOut) {
1039  // Undefined to call this not on an optimization diagnostic!
1040  llvm::DiagnosticInfoOptimizationBase *Opt =
1041      static_cast<llvm::DiagnosticInfoOptimizationBase *>(unwrap(DI));
1042
1043  RawRustStringOstream PassNameOS(PassNameOut);
1044  PassNameOS << Opt->getPassName();
1045  *FunctionOut = wrap(&Opt->getFunction());
1046
1047  RawRustStringOstream FilenameOS(FilenameOut);
1048  DiagnosticLocation loc = Opt->getLocation();
1049  if (loc.isValid()) {
1050    *Line = loc.getLine();
1051    *Column = loc.getColumn();
1052#if LLVM_VERSION_GE(8, 0)
1053    FilenameOS << loc.getAbsolutePath();
1054#else
1055    FilenameOS << loc.getFilename();
1056#endif
1057  }
1058
1059  RawRustStringOstream MessageOS(MessageOut);
1060  MessageOS << Opt->getMsg();
1061}
1062
1063extern "C" void
1064LLVMRustUnpackInlineAsmDiagnostic(LLVMDiagnosticInfoRef DI, unsigned *CookieOut,
1065                                  LLVMTwineRef *MessageOut,
1066                                  LLVMValueRef *InstructionOut) {
1067  // Undefined to call this not on an inline assembly diagnostic!
1068  llvm::DiagnosticInfoInlineAsm *IA =
1069      static_cast<llvm::DiagnosticInfoInlineAsm *>(unwrap(DI));
1070
1071  *CookieOut = IA->getLocCookie();
1072  *MessageOut = wrap(&IA->getMsgStr());
1073  *InstructionOut = wrap(IA->getInstruction());
1074}
1075
1076extern "C" void LLVMRustWriteDiagnosticInfoToString(LLVMDiagnosticInfoRef DI,
1077                                                    RustStringRef Str) {
1078  RawRustStringOstream OS(Str);
1079  DiagnosticPrinterRawOStream DP(OS);
1080  unwrap(DI)->print(DP);
1081}
1082
1083enum class LLVMRustDiagnosticKind {
1084  Other,
1085  InlineAsm,
1086  StackSize,
1087  DebugMetadataVersion,
1088  SampleProfile,
1089  OptimizationRemark,
1090  OptimizationRemarkMissed,
1091  OptimizationRemarkAnalysis,
1092  OptimizationRemarkAnalysisFPCommute,
1093  OptimizationRemarkAnalysisAliasing,
1094  OptimizationRemarkOther,
1095  OptimizationFailure,
1096  PGOProfile,
1097  Linker,
1098};
1099
1100static LLVMRustDiagnosticKind toRust(DiagnosticKind Kind) {
1101  switch (Kind) {
1102  case DK_InlineAsm:
1103    return LLVMRustDiagnosticKind::InlineAsm;
1104  case DK_StackSize:
1105    return LLVMRustDiagnosticKind::StackSize;
1106  case DK_DebugMetadataVersion:
1107    return LLVMRustDiagnosticKind::DebugMetadataVersion;
1108  case DK_SampleProfile:
1109    return LLVMRustDiagnosticKind::SampleProfile;
1110  case DK_OptimizationRemark:
1111    return LLVMRustDiagnosticKind::OptimizationRemark;
1112  case DK_OptimizationRemarkMissed:
1113    return LLVMRustDiagnosticKind::OptimizationRemarkMissed;
1114  case DK_OptimizationRemarkAnalysis:
1115    return LLVMRustDiagnosticKind::OptimizationRemarkAnalysis;
1116  case DK_OptimizationRemarkAnalysisFPCommute:
1117    return LLVMRustDiagnosticKind::OptimizationRemarkAnalysisFPCommute;
1118  case DK_OptimizationRemarkAnalysisAliasing:
1119    return LLVMRustDiagnosticKind::OptimizationRemarkAnalysisAliasing;
1120  case DK_PGOProfile:
1121    return LLVMRustDiagnosticKind::PGOProfile;
1122  case DK_Linker:
1123    return LLVMRustDiagnosticKind::Linker;
1124  default:
1125    return (Kind >= DK_FirstRemark && Kind <= DK_LastRemark)
1126               ? LLVMRustDiagnosticKind::OptimizationRemarkOther
1127               : LLVMRustDiagnosticKind::Other;
1128  }
1129}
1130
1131extern "C" LLVMRustDiagnosticKind
1132LLVMRustGetDiagInfoKind(LLVMDiagnosticInfoRef DI) {
1133  return toRust((DiagnosticKind)unwrap(DI)->getKind());
1134}
1135// This is kept distinct from LLVMGetTypeKind, because when
1136// a new type kind is added, the Rust-side enum must be
1137// updated or UB will result.
1138extern "C" LLVMTypeKind LLVMRustGetTypeKind(LLVMTypeRef Ty) {
1139  switch (unwrap(Ty)->getTypeID()) {
1140  case Type::VoidTyID:
1141    return LLVMVoidTypeKind;
1142  case Type::HalfTyID:
1143    return LLVMHalfTypeKind;
1144  case Type::FloatTyID:
1145    return LLVMFloatTypeKind;
1146  case Type::DoubleTyID:
1147    return LLVMDoubleTypeKind;
1148  case Type::X86_FP80TyID:
1149    return LLVMX86_FP80TypeKind;
1150  case Type::FP128TyID:
1151    return LLVMFP128TypeKind;
1152  case Type::PPC_FP128TyID:
1153    return LLVMPPC_FP128TypeKind;
1154  case Type::LabelTyID:
1155    return LLVMLabelTypeKind;
1156  case Type::MetadataTyID:
1157    return LLVMMetadataTypeKind;
1158  case Type::IntegerTyID:
1159    return LLVMIntegerTypeKind;
1160  case Type::FunctionTyID:
1161    return LLVMFunctionTypeKind;
1162  case Type::StructTyID:
1163    return LLVMStructTypeKind;
1164  case Type::ArrayTyID:
1165    return LLVMArrayTypeKind;
1166  case Type::PointerTyID:
1167    return LLVMPointerTypeKind;
1168  case Type::VectorTyID:
1169    return LLVMVectorTypeKind;
1170  case Type::X86_MMXTyID:
1171    return LLVMX86_MMXTypeKind;
1172  case Type::TokenTyID:
1173    return LLVMTokenTypeKind;
1174  }
1175  report_fatal_error("Unhandled TypeID.");
1176}
1177
1178DEFINE_SIMPLE_CONVERSION_FUNCTIONS(SMDiagnostic, LLVMSMDiagnosticRef)
1179
1180extern "C" void LLVMRustSetInlineAsmDiagnosticHandler(
1181    LLVMContextRef C, LLVMContext::InlineAsmDiagHandlerTy H, void *CX) {
1182  unwrap(C)->setInlineAsmDiagnosticHandler(H, CX);
1183}
1184
1185extern "C" void LLVMRustWriteSMDiagnosticToString(LLVMSMDiagnosticRef D,
1186                                                  RustStringRef Str) {
1187  RawRustStringOstream OS(Str);
1188  unwrap(D)->print("", OS);
1189}
1190
1191extern "C" LLVMValueRef LLVMRustBuildCleanupPad(LLVMBuilderRef B,
1192                                                LLVMValueRef ParentPad,
1193                                                unsigned ArgCount,
1194                                                LLVMValueRef *LLArgs,
1195                                                const char *Name) {
1196  Value **Args = unwrap(LLArgs);
1197  if (ParentPad == nullptr) {
1198    Type *Ty = Type::getTokenTy(unwrap(B)->getContext());
1199    ParentPad = wrap(Constant::getNullValue(Ty));
1200  }
1201  return wrap(unwrap(B)->CreateCleanupPad(
1202      unwrap(ParentPad), ArrayRef<Value *>(Args, ArgCount), Name));
1203}
1204
1205extern "C" LLVMValueRef LLVMRustBuildCleanupRet(LLVMBuilderRef B,
1206                                                LLVMValueRef CleanupPad,
1207                                                LLVMBasicBlockRef UnwindBB) {
1208  CleanupPadInst *Inst = cast<CleanupPadInst>(unwrap(CleanupPad));
1209  return wrap(unwrap(B)->CreateCleanupRet(Inst, unwrap(UnwindBB)));
1210}
1211
1212extern "C" LLVMValueRef
1213LLVMRustBuildCatchPad(LLVMBuilderRef B, LLVMValueRef ParentPad,
1214                      unsigned ArgCount, LLVMValueRef *LLArgs, const char *Name) {
1215  Value **Args = unwrap(LLArgs);
1216  return wrap(unwrap(B)->CreateCatchPad(
1217      unwrap(ParentPad), ArrayRef<Value *>(Args, ArgCount), Name));
1218}
1219
1220extern "C" LLVMValueRef LLVMRustBuildCatchRet(LLVMBuilderRef B,
1221                                              LLVMValueRef Pad,
1222                                              LLVMBasicBlockRef BB) {
1223  return wrap(unwrap(B)->CreateCatchRet(cast<CatchPadInst>(unwrap(Pad)),
1224                                              unwrap(BB)));
1225}
1226
1227extern "C" LLVMValueRef LLVMRustBuildCatchSwitch(LLVMBuilderRef B,
1228                                                 LLVMValueRef ParentPad,
1229                                                 LLVMBasicBlockRef BB,
1230                                                 unsigned NumHandlers,
1231                                                 const char *Name) {
1232  if (ParentPad == nullptr) {
1233    Type *Ty = Type::getTokenTy(unwrap(B)->getContext());
1234    ParentPad = wrap(Constant::getNullValue(Ty));
1235  }
1236  return wrap(unwrap(B)->CreateCatchSwitch(unwrap(ParentPad), unwrap(BB),
1237                                                 NumHandlers, Name));
1238}
1239
1240extern "C" void LLVMRustAddHandler(LLVMValueRef CatchSwitchRef,
1241                                   LLVMBasicBlockRef Handler) {
1242  Value *CatchSwitch = unwrap(CatchSwitchRef);
1243  cast<CatchSwitchInst>(CatchSwitch)->addHandler(unwrap(Handler));
1244}
1245
1246extern "C" OperandBundleDef *LLVMRustBuildOperandBundleDef(const char *Name,
1247                                                           LLVMValueRef *Inputs,
1248                                                           unsigned NumInputs) {
1249  return new OperandBundleDef(Name, makeArrayRef(unwrap(Inputs), NumInputs));
1250}
1251
1252extern "C" void LLVMRustFreeOperandBundleDef(OperandBundleDef *Bundle) {
1253  delete Bundle;
1254}
1255
1256extern "C" LLVMValueRef LLVMRustBuildCall(LLVMBuilderRef B, LLVMValueRef Fn,
1257                                          LLVMValueRef *Args, unsigned NumArgs,
1258                                          OperandBundleDef *Bundle,
1259                                          const char *Name) {
1260  unsigned Len = Bundle ? 1 : 0;
1261  ArrayRef<OperandBundleDef> Bundles = makeArrayRef(Bundle, Len);
1262  return wrap(unwrap(B)->CreateCall(
1263      unwrap(Fn), makeArrayRef(unwrap(Args), NumArgs), Bundles, Name));
1264}
1265
1266extern "C" LLVMValueRef LLVMRustBuildMemCpy(LLVMBuilderRef B,
1267                                            LLVMValueRef Dst, unsigned DstAlign,
1268                                            LLVMValueRef Src, unsigned SrcAlign,
1269                                            LLVMValueRef Size, bool IsVolatile) {
1270#if LLVM_VERSION_GE(7, 0)
1271  return wrap(unwrap(B)->CreateMemCpy(
1272      unwrap(Dst), DstAlign,
1273      unwrap(Src), SrcAlign,
1274      unwrap(Size), IsVolatile));
1275#else
1276  unsigned Align = std::min(DstAlign, SrcAlign);
1277  return wrap(unwrap(B)->CreateMemCpy(
1278      unwrap(Dst), unwrap(Src),
1279      unwrap(Size), Align, IsVolatile));
1280#endif
1281}
1282
1283extern "C" LLVMValueRef LLVMRustBuildMemMove(LLVMBuilderRef B,
1284                                             LLVMValueRef Dst, unsigned DstAlign,
1285                                             LLVMValueRef Src, unsigned SrcAlign,
1286                                             LLVMValueRef Size, bool IsVolatile) {
1287#if LLVM_VERSION_GE(7, 0)
1288  return wrap(unwrap(B)->CreateMemMove(
1289      unwrap(Dst), DstAlign,
1290      unwrap(Src), SrcAlign,
1291      unwrap(Size), IsVolatile));
1292#else
1293  unsigned Align = std::min(DstAlign, SrcAlign);
1294  return wrap(unwrap(B)->CreateMemMove(
1295      unwrap(Dst), unwrap(Src),
1296      unwrap(Size), Align, IsVolatile));
1297#endif
1298}
1299
1300extern "C" LLVMValueRef
1301LLVMRustBuildInvoke(LLVMBuilderRef B, LLVMValueRef Fn, LLVMValueRef *Args,
1302                    unsigned NumArgs, LLVMBasicBlockRef Then,
1303                    LLVMBasicBlockRef Catch, OperandBundleDef *Bundle,
1304                    const char *Name) {
1305  unsigned Len = Bundle ? 1 : 0;
1306  ArrayRef<OperandBundleDef> Bundles = makeArrayRef(Bundle, Len);
1307  return wrap(unwrap(B)->CreateInvoke(unwrap(Fn), unwrap(Then), unwrap(Catch),
1308                                      makeArrayRef(unwrap(Args), NumArgs),
1309                                      Bundles, Name));
1310}
1311
1312extern "C" void LLVMRustPositionBuilderAtStart(LLVMBuilderRef B,
1313                                               LLVMBasicBlockRef BB) {
1314  auto Point = unwrap(BB)->getFirstInsertionPt();
1315  unwrap(B)->SetInsertPoint(unwrap(BB), Point);
1316}
1317
1318extern "C" void LLVMRustSetComdat(LLVMModuleRef M, LLVMValueRef V,
1319                                  const char *Name) {
1320  Triple TargetTriple(unwrap(M)->getTargetTriple());
1321  GlobalObject *GV = unwrap<GlobalObject>(V);
1322  if (!TargetTriple.isOSBinFormatMachO()) {
1323    GV->setComdat(unwrap(M)->getOrInsertComdat(Name));
1324  }
1325}
1326
1327extern "C" void LLVMRustUnsetComdat(LLVMValueRef V) {
1328  GlobalObject *GV = unwrap<GlobalObject>(V);
1329  GV->setComdat(nullptr);
1330}
1331
1332enum class LLVMRustLinkage {
1333  ExternalLinkage = 0,
1334  AvailableExternallyLinkage = 1,
1335  LinkOnceAnyLinkage = 2,
1336  LinkOnceODRLinkage = 3,
1337  WeakAnyLinkage = 4,
1338  WeakODRLinkage = 5,
1339  AppendingLinkage = 6,
1340  InternalLinkage = 7,
1341  PrivateLinkage = 8,
1342  ExternalWeakLinkage = 9,
1343  CommonLinkage = 10,
1344};
1345
1346static LLVMRustLinkage toRust(LLVMLinkage Linkage) {
1347  switch (Linkage) {
1348  case LLVMExternalLinkage:
1349    return LLVMRustLinkage::ExternalLinkage;
1350  case LLVMAvailableExternallyLinkage:
1351    return LLVMRustLinkage::AvailableExternallyLinkage;
1352  case LLVMLinkOnceAnyLinkage:
1353    return LLVMRustLinkage::LinkOnceAnyLinkage;
1354  case LLVMLinkOnceODRLinkage:
1355    return LLVMRustLinkage::LinkOnceODRLinkage;
1356  case LLVMWeakAnyLinkage:
1357    return LLVMRustLinkage::WeakAnyLinkage;
1358  case LLVMWeakODRLinkage:
1359    return LLVMRustLinkage::WeakODRLinkage;
1360  case LLVMAppendingLinkage:
1361    return LLVMRustLinkage::AppendingLinkage;
1362  case LLVMInternalLinkage:
1363    return LLVMRustLinkage::InternalLinkage;
1364  case LLVMPrivateLinkage:
1365    return LLVMRustLinkage::PrivateLinkage;
1366  case LLVMExternalWeakLinkage:
1367    return LLVMRustLinkage::ExternalWeakLinkage;
1368  case LLVMCommonLinkage:
1369    return LLVMRustLinkage::CommonLinkage;
1370  default:
1371    report_fatal_error("Invalid LLVMRustLinkage value!");
1372  }
1373}
1374
1375static LLVMLinkage fromRust(LLVMRustLinkage Linkage) {
1376  switch (Linkage) {
1377  case LLVMRustLinkage::ExternalLinkage:
1378    return LLVMExternalLinkage;
1379  case LLVMRustLinkage::AvailableExternallyLinkage:
1380    return LLVMAvailableExternallyLinkage;
1381  case LLVMRustLinkage::LinkOnceAnyLinkage:
1382    return LLVMLinkOnceAnyLinkage;
1383  case LLVMRustLinkage::LinkOnceODRLinkage:
1384    return LLVMLinkOnceODRLinkage;
1385  case LLVMRustLinkage::WeakAnyLinkage:
1386    return LLVMWeakAnyLinkage;
1387  case LLVMRustLinkage::WeakODRLinkage:
1388    return LLVMWeakODRLinkage;
1389  case LLVMRustLinkage::AppendingLinkage:
1390    return LLVMAppendingLinkage;
1391  case LLVMRustLinkage::InternalLinkage:
1392    return LLVMInternalLinkage;
1393  case LLVMRustLinkage::PrivateLinkage:
1394    return LLVMPrivateLinkage;
1395  case LLVMRustLinkage::ExternalWeakLinkage:
1396    return LLVMExternalWeakLinkage;
1397  case LLVMRustLinkage::CommonLinkage:
1398    return LLVMCommonLinkage;
1399  }
1400  report_fatal_error("Invalid LLVMRustLinkage value!");
1401}
1402
1403extern "C" LLVMRustLinkage LLVMRustGetLinkage(LLVMValueRef V) {
1404  return toRust(LLVMGetLinkage(V));
1405}
1406
1407extern "C" void LLVMRustSetLinkage(LLVMValueRef V,
1408                                   LLVMRustLinkage RustLinkage) {
1409  LLVMSetLinkage(V, fromRust(RustLinkage));
1410}
1411
1412// Returns true if both high and low were successfully set. Fails in case constant wasn’t any of
1413// the common sizes (1, 8, 16, 32, 64, 128 bits)
1414extern "C" bool LLVMRustConstInt128Get(LLVMValueRef CV, bool sext, uint64_t *high, uint64_t *low)
1415{
1416    auto C = unwrap<llvm::ConstantInt>(CV);
1417    if (C->getBitWidth() > 128) { return false; }
1418    APInt AP;
1419    if (sext) {
1420        AP = C->getValue().sextOrSelf(128);
1421    } else {
1422        AP = C->getValue().zextOrSelf(128);
1423    }
1424    *low = AP.getLoBits(64).getZExtValue();
1425    *high = AP.getHiBits(64).getZExtValue();
1426    return true;
1427}
1428
1429enum class LLVMRustVisibility {
1430  Default = 0,
1431  Hidden = 1,
1432  Protected = 2,
1433};
1434
1435static LLVMRustVisibility toRust(LLVMVisibility Vis) {
1436  switch (Vis) {
1437  case LLVMDefaultVisibility:
1438    return LLVMRustVisibility::Default;
1439  case LLVMHiddenVisibility:
1440    return LLVMRustVisibility::Hidden;
1441  case LLVMProtectedVisibility:
1442    return LLVMRustVisibility::Protected;
1443  }
1444  report_fatal_error("Invalid LLVMRustVisibility value!");
1445}
1446
1447static LLVMVisibility fromRust(LLVMRustVisibility Vis) {
1448  switch (Vis) {
1449  case LLVMRustVisibility::Default:
1450    return LLVMDefaultVisibility;
1451  case LLVMRustVisibility::Hidden:
1452    return LLVMHiddenVisibility;
1453  case LLVMRustVisibility::Protected:
1454    return LLVMProtectedVisibility;
1455  }
1456  report_fatal_error("Invalid LLVMRustVisibility value!");
1457}
1458
1459extern "C" LLVMRustVisibility LLVMRustGetVisibility(LLVMValueRef V) {
1460  return toRust(LLVMGetVisibility(V));
1461}
1462
1463// Oh hey, a binding that makes sense for once? (because LLVM’s own do not)
1464extern "C" LLVMValueRef LLVMRustBuildIntCast(LLVMBuilderRef B, LLVMValueRef Val,
1465                                             LLVMTypeRef DestTy, bool isSigned) {
1466  return wrap(unwrap(B)->CreateIntCast(unwrap(Val), unwrap(DestTy), isSigned, ""));
1467}
1468
1469extern "C" void LLVMRustSetVisibility(LLVMValueRef V,
1470                                      LLVMRustVisibility RustVisibility) {
1471  LLVMSetVisibility(V, fromRust(RustVisibility));
1472}
1473
1474struct LLVMRustModuleBuffer {
1475  std::string data;
1476};
1477
1478extern "C" LLVMRustModuleBuffer*
1479LLVMRustModuleBufferCreate(LLVMModuleRef M) {
1480  auto Ret = llvm::make_unique<LLVMRustModuleBuffer>();
1481  {
1482    raw_string_ostream OS(Ret->data);
1483    {
1484      legacy::PassManager PM;
1485      PM.add(createBitcodeWriterPass(OS));
1486      PM.run(*unwrap(M));
1487    }
1488  }
1489  return Ret.release();
1490}
1491
1492extern "C" void
1493LLVMRustModuleBufferFree(LLVMRustModuleBuffer *Buffer) {
1494  delete Buffer;
1495}
1496
1497extern "C" const void*
1498LLVMRustModuleBufferPtr(const LLVMRustModuleBuffer *Buffer) {
1499  return Buffer->data.data();
1500}
1501
1502extern "C" size_t
1503LLVMRustModuleBufferLen(const LLVMRustModuleBuffer *Buffer) {
1504  return Buffer->data.length();
1505}
1506
1507extern "C" uint64_t
1508LLVMRustModuleCost(LLVMModuleRef M) {
1509  auto f = unwrap(M)->functions();
1510  return std::distance(std::begin(f), std::end(f));
1511}
1512
1513// Vector reductions:
1514extern "C" LLVMValueRef
1515LLVMRustBuildVectorReduceFAdd(LLVMBuilderRef B, LLVMValueRef Acc, LLVMValueRef Src) {
1516    return wrap(unwrap(B)->CreateFAddReduce(unwrap(Acc),unwrap(Src)));
1517}
1518extern "C" LLVMValueRef
1519LLVMRustBuildVectorReduceFMul(LLVMBuilderRef B, LLVMValueRef Acc, LLVMValueRef Src) {
1520    return wrap(unwrap(B)->CreateFMulReduce(unwrap(Acc),unwrap(Src)));
1521}
1522extern "C" LLVMValueRef
1523LLVMRustBuildVectorReduceAdd(LLVMBuilderRef B, LLVMValueRef Src) {
1524    return wrap(unwrap(B)->CreateAddReduce(unwrap(Src)));
1525}
1526extern "C" LLVMValueRef
1527LLVMRustBuildVectorReduceMul(LLVMBuilderRef B, LLVMValueRef Src) {
1528    return wrap(unwrap(B)->CreateMulReduce(unwrap(Src)));
1529}
1530extern "C" LLVMValueRef
1531LLVMRustBuildVectorReduceAnd(LLVMBuilderRef B, LLVMValueRef Src) {
1532    return wrap(unwrap(B)->CreateAndReduce(unwrap(Src)));
1533}
1534extern "C" LLVMValueRef
1535LLVMRustBuildVectorReduceOr(LLVMBuilderRef B, LLVMValueRef Src) {
1536    return wrap(unwrap(B)->CreateOrReduce(unwrap(Src)));
1537}
1538extern "C" LLVMValueRef
1539LLVMRustBuildVectorReduceXor(LLVMBuilderRef B, LLVMValueRef Src) {
1540    return wrap(unwrap(B)->CreateXorReduce(unwrap(Src)));
1541}
1542extern "C" LLVMValueRef
1543LLVMRustBuildVectorReduceMin(LLVMBuilderRef B, LLVMValueRef Src, bool IsSigned) {
1544    return wrap(unwrap(B)->CreateIntMinReduce(unwrap(Src), IsSigned));
1545}
1546extern "C" LLVMValueRef
1547LLVMRustBuildVectorReduceMax(LLVMBuilderRef B, LLVMValueRef Src, bool IsSigned) {
1548    return wrap(unwrap(B)->CreateIntMaxReduce(unwrap(Src), IsSigned));
1549}
1550extern "C" LLVMValueRef
1551LLVMRustBuildVectorReduceFMin(LLVMBuilderRef B, LLVMValueRef Src, bool NoNaN) {
1552   return wrap(unwrap(B)->CreateFPMinReduce(unwrap(Src), NoNaN));
1553}
1554extern "C" LLVMValueRef
1555LLVMRustBuildVectorReduceFMax(LLVMBuilderRef B, LLVMValueRef Src, bool NoNaN) {
1556  return wrap(unwrap(B)->CreateFPMaxReduce(unwrap(Src), NoNaN));
1557}
1558
1559extern "C" LLVMValueRef
1560LLVMRustBuildMinNum(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS) {
1561    return wrap(unwrap(B)->CreateMinNum(unwrap(LHS),unwrap(RHS)));
1562}
1563extern "C" LLVMValueRef
1564LLVMRustBuildMaxNum(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS) {
1565    return wrap(unwrap(B)->CreateMaxNum(unwrap(LHS),unwrap(RHS)));
1566}