fork/rust

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

borsAuto merge of #103046 - JanBeh:PR_clarify_cmp_terminology, r=workingjubilee3bcad65fbf6

master
70.8 KiB2062 linesraw
1#include "LLVMWrapper.h"
2#include "llvm/ADT/Statistic.h"
3#include "llvm/IR/DebugInfoMetadata.h"
4#include "llvm/IR/DiagnosticHandler.h"
5#include "llvm/IR/DiagnosticInfo.h"
6#include "llvm/IR/DiagnosticPrinter.h"
7#include "llvm/IR/GlobalVariable.h"
8#include "llvm/IR/Instructions.h"
9#include "llvm/IR/Intrinsics.h"
10#include "llvm/IR/IntrinsicsARM.h"
11#include "llvm/IR/LLVMRemarkStreamer.h"
12#include "llvm/IR/Mangler.h"
13#include "llvm/Remarks/RemarkStreamer.h"
14#include "llvm/Remarks/RemarkSerializer.h"
15#include "llvm/Remarks/RemarkFormat.h"
16#include "llvm/Support/ToolOutputFile.h"
17#if LLVM_VERSION_GE(16, 0)
18#include "llvm/Support/ModRef.h"
19#endif
20#include "llvm/Object/Archive.h"
21#include "llvm/Object/COFFImportFile.h"
22#include "llvm/Object/ObjectFile.h"
23#include "llvm/Pass.h"
24#include "llvm/Bitcode/BitcodeWriter.h"
25#include "llvm/Support/Signals.h"
26#if LLVM_VERSION_LT(16, 0)
27#include "llvm/ADT/Optional.h"
28#endif
29
30#include <iostream>
31
32//===----------------------------------------------------------------------===
33//
34// This file defines alternate interfaces to core functions that are more
35// readily callable by Rust's FFI.
36//
37//===----------------------------------------------------------------------===
38
39using namespace llvm;
40using namespace llvm::sys;
41using namespace llvm::object;
42
43// LLVMAtomicOrdering is already an enum - don't create another
44// one.
45static AtomicOrdering fromRust(LLVMAtomicOrdering Ordering) {
46  switch (Ordering) {
47  case LLVMAtomicOrderingNotAtomic:
48    return AtomicOrdering::NotAtomic;
49  case LLVMAtomicOrderingUnordered:
50    return AtomicOrdering::Unordered;
51  case LLVMAtomicOrderingMonotonic:
52    return AtomicOrdering::Monotonic;
53  case LLVMAtomicOrderingAcquire:
54    return AtomicOrdering::Acquire;
55  case LLVMAtomicOrderingRelease:
56    return AtomicOrdering::Release;
57  case LLVMAtomicOrderingAcquireRelease:
58    return AtomicOrdering::AcquireRelease;
59  case LLVMAtomicOrderingSequentiallyConsistent:
60    return AtomicOrdering::SequentiallyConsistent;
61  }
62
63  report_fatal_error("Invalid LLVMAtomicOrdering value!");
64}
65
66static LLVM_THREAD_LOCAL char *LastError;
67
68// Custom error handler for fatal LLVM errors.
69//
70// Notably it exits the process with code 101, unlike LLVM's default of 1.
71static void FatalErrorHandler(void *UserData,
72                              const char* Reason,
73                              bool GenCrashDiag) {
74  // Do the same thing that the default error handler does.
75  std::cerr << "LLVM ERROR: " << Reason << std::endl;
76
77  // Since this error handler exits the process, we have to run any cleanup that
78  // LLVM would run after handling the error. This might change with an LLVM
79  // upgrade.
80  sys::RunInterruptHandlers();
81
82  exit(101);
83}
84
85extern "C" void LLVMRustInstallFatalErrorHandler() {
86  install_fatal_error_handler(FatalErrorHandler);
87}
88
89extern "C" void LLVMRustDisableSystemDialogsOnCrash() {
90  sys::DisableSystemDialogsOnCrash();
91}
92
93extern "C" char *LLVMRustGetLastError(void) {
94  char *Ret = LastError;
95  LastError = nullptr;
96  return Ret;
97}
98
99extern "C" void LLVMRustSetLastError(const char *Err) {
100  free((void *)LastError);
101  LastError = strdup(Err);
102}
103
104extern "C" LLVMContextRef LLVMRustContextCreate(bool shouldDiscardNames) {
105  auto ctx = new LLVMContext();
106  ctx->setDiscardValueNames(shouldDiscardNames);
107  return wrap(ctx);
108}
109
110extern "C" void LLVMRustSetNormalizedTarget(LLVMModuleRef M,
111                                            const char *Triple) {
112  unwrap(M)->setTargetTriple(Triple::normalize(Triple));
113}
114
115extern "C" const char *LLVMRustPrintPassTimings(size_t *Len) {
116  std::string buf;
117  raw_string_ostream SS(buf);
118  TimerGroup::printAll(SS);
119  SS.flush();
120  *Len = buf.length();
121  char *CStr = (char *)malloc(*Len);
122  memcpy(CStr, buf.c_str(), *Len);
123  return CStr;
124}
125
126extern "C" const char *LLVMRustPrintStatistics(size_t *Len) {
127  std::string buf;
128  raw_string_ostream SS(buf);
129  llvm::PrintStatistics(SS);
130  SS.flush();
131  *Len = buf.length();
132  char *CStr = (char *)malloc(*Len);
133  memcpy(CStr, buf.c_str(), *Len);
134  return CStr;
135}
136
137extern "C" LLVMValueRef LLVMRustGetNamedValue(LLVMModuleRef M, const char *Name,
138                                              size_t NameLen) {
139  return wrap(unwrap(M)->getNamedValue(StringRef(Name, NameLen)));
140}
141
142enum class LLVMRustTailCallKind {
143  None,
144  Tail,
145  MustTail,
146  NoTail,
147};
148
149static CallInst::TailCallKind fromRust(LLVMRustTailCallKind Kind) {
150  switch (Kind) {
151  case LLVMRustTailCallKind::None:
152    return CallInst::TailCallKind::TCK_None;
153  case LLVMRustTailCallKind::Tail:
154    return CallInst::TailCallKind::TCK_Tail;
155  case LLVMRustTailCallKind::MustTail:
156    return CallInst::TailCallKind::TCK_MustTail;
157  case LLVMRustTailCallKind::NoTail:
158    return CallInst::TailCallKind::TCK_NoTail;
159  default:
160    report_fatal_error("bad CallInst::TailCallKind.");
161  }
162}
163
164extern "C" void LLVMRustSetTailCallKind(LLVMValueRef Call, LLVMRustTailCallKind TCK) {
165  unwrap<CallInst>(Call)->setTailCallKind(fromRust(TCK));
166}
167
168extern "C" LLVMValueRef LLVMRustGetOrInsertFunction(LLVMModuleRef M,
169                                                    const char *Name,
170                                                    size_t NameLen,
171                                                    LLVMTypeRef FunctionTy) {
172  return wrap(unwrap(M)
173                  ->getOrInsertFunction(StringRef(Name, NameLen),
174                                        unwrap<FunctionType>(FunctionTy))
175                  .getCallee()
176  );
177}
178
179extern "C" LLVMValueRef
180LLVMRustGetOrInsertGlobal(LLVMModuleRef M, const char *Name, size_t NameLen, LLVMTypeRef Ty) {
181  Module *Mod = unwrap(M);
182  StringRef NameRef(Name, NameLen);
183
184  // We don't use Module::getOrInsertGlobal because that returns a Constant*,
185  // which may either be the real GlobalVariable*, or a constant bitcast of it
186  // if our type doesn't match the original declaration. We always want the
187  // GlobalVariable* so we can access linkage, visibility, etc.
188  GlobalVariable *GV = Mod->getGlobalVariable(NameRef, true);
189  if (!GV)
190    GV = new GlobalVariable(*Mod, unwrap(Ty), false,
191                            GlobalValue::ExternalLinkage, nullptr, NameRef);
192  return wrap(GV);
193}
194
195extern "C" LLVMValueRef
196LLVMRustInsertPrivateGlobal(LLVMModuleRef M, LLVMTypeRef Ty) {
197  return wrap(new GlobalVariable(*unwrap(M),
198                                 unwrap(Ty),
199                                 false,
200                                 GlobalValue::PrivateLinkage,
201                                 nullptr));
202}
203
204static Attribute::AttrKind fromRust(LLVMRustAttribute Kind) {
205  switch (Kind) {
206  case AlwaysInline:
207    return Attribute::AlwaysInline;
208  case ByVal:
209    return Attribute::ByVal;
210  case Cold:
211    return Attribute::Cold;
212  case InlineHint:
213    return Attribute::InlineHint;
214  case MinSize:
215    return Attribute::MinSize;
216  case Naked:
217    return Attribute::Naked;
218  case NoAlias:
219    return Attribute::NoAlias;
220  case NoCapture:
221    return Attribute::NoCapture;
222  case NoCfCheck:
223    return Attribute::NoCfCheck;
224  case NoInline:
225    return Attribute::NoInline;
226  case NonNull:
227    return Attribute::NonNull;
228  case NoRedZone:
229    return Attribute::NoRedZone;
230  case NoReturn:
231    return Attribute::NoReturn;
232  case NoUnwind:
233    return Attribute::NoUnwind;
234  case OptimizeForSize:
235    return Attribute::OptimizeForSize;
236  case ReadOnly:
237    return Attribute::ReadOnly;
238  case SExt:
239    return Attribute::SExt;
240  case StructRet:
241    return Attribute::StructRet;
242  case UWTable:
243    return Attribute::UWTable;
244  case ZExt:
245    return Attribute::ZExt;
246  case InReg:
247    return Attribute::InReg;
248  case SanitizeThread:
249    return Attribute::SanitizeThread;
250  case SanitizeAddress:
251    return Attribute::SanitizeAddress;
252  case SanitizeMemory:
253    return Attribute::SanitizeMemory;
254  case NonLazyBind:
255    return Attribute::NonLazyBind;
256  case OptimizeNone:
257    return Attribute::OptimizeNone;
258  case ReturnsTwice:
259    return Attribute::ReturnsTwice;
260  case ReadNone:
261    return Attribute::ReadNone;
262  case SanitizeHWAddress:
263    return Attribute::SanitizeHWAddress;
264  case WillReturn:
265    return Attribute::WillReturn;
266  case StackProtectReq:
267    return Attribute::StackProtectReq;
268  case StackProtectStrong:
269    return Attribute::StackProtectStrong;
270  case StackProtect:
271    return Attribute::StackProtect;
272  case NoUndef:
273    return Attribute::NoUndef;
274  case SanitizeMemTag:
275    return Attribute::SanitizeMemTag;
276  case ShadowCallStack:
277    return Attribute::ShadowCallStack;
278  case AllocSize:
279    return Attribute::AllocSize;
280  case AllocatedPointer:
281    return Attribute::AllocatedPointer;
282  case AllocAlign:
283    return Attribute::AllocAlign;
284  case SanitizeSafeStack:
285    return Attribute::SafeStack;
286  }
287  report_fatal_error("bad AttributeKind");
288}
289
290template<typename T> static inline void AddAttributes(T *t, unsigned Index,
291                                                      LLVMAttributeRef *Attrs, size_t AttrsLen) {
292  AttributeList PAL = t->getAttributes();
293  AttrBuilder B(t->getContext());
294  for (LLVMAttributeRef Attr : ArrayRef<LLVMAttributeRef>(Attrs, AttrsLen))
295    B.addAttribute(unwrap(Attr));
296  AttributeList PALNew = PAL.addAttributesAtIndex(t->getContext(), Index, B);
297  t->setAttributes(PALNew);
298}
299
300extern "C" void LLVMRustAddFunctionAttributes(LLVMValueRef Fn, unsigned Index,
301                                              LLVMAttributeRef *Attrs, size_t AttrsLen) {
302  Function *F = unwrap<Function>(Fn);
303  AddAttributes(F, Index, Attrs, AttrsLen);
304}
305
306extern "C" void LLVMRustAddCallSiteAttributes(LLVMValueRef Instr, unsigned Index,
307                                              LLVMAttributeRef *Attrs, size_t AttrsLen) {
308  CallBase *Call = unwrap<CallBase>(Instr);
309  AddAttributes(Call, Index, Attrs, AttrsLen);
310}
311
312extern "C" LLVMAttributeRef LLVMRustCreateAttrNoValue(LLVMContextRef C,
313                                                      LLVMRustAttribute RustAttr) {
314  return wrap(Attribute::get(*unwrap(C), fromRust(RustAttr)));
315}
316
317extern "C" LLVMAttributeRef LLVMRustCreateAlignmentAttr(LLVMContextRef C,
318                                                        uint64_t Bytes) {
319  return wrap(Attribute::getWithAlignment(*unwrap(C), llvm::Align(Bytes)));
320}
321
322extern "C" LLVMAttributeRef LLVMRustCreateDereferenceableAttr(LLVMContextRef C,
323                                                              uint64_t Bytes) {
324  return wrap(Attribute::getWithDereferenceableBytes(*unwrap(C), Bytes));
325}
326
327extern "C" LLVMAttributeRef LLVMRustCreateDereferenceableOrNullAttr(LLVMContextRef C,
328                                                                    uint64_t Bytes) {
329  return wrap(Attribute::getWithDereferenceableOrNullBytes(*unwrap(C), Bytes));
330}
331
332extern "C" LLVMAttributeRef LLVMRustCreateByValAttr(LLVMContextRef C, LLVMTypeRef Ty) {
333  return wrap(Attribute::getWithByValType(*unwrap(C), unwrap(Ty)));
334}
335
336extern "C" LLVMAttributeRef LLVMRustCreateStructRetAttr(LLVMContextRef C, LLVMTypeRef Ty) {
337  return wrap(Attribute::getWithStructRetType(*unwrap(C), unwrap(Ty)));
338}
339
340extern "C" LLVMAttributeRef LLVMRustCreateElementTypeAttr(LLVMContextRef C, LLVMTypeRef Ty) {
341  return wrap(Attribute::get(*unwrap(C), Attribute::ElementType, unwrap(Ty)));
342}
343
344extern "C" LLVMAttributeRef LLVMRustCreateUWTableAttr(LLVMContextRef C, bool Async) {
345  return wrap(Attribute::getWithUWTableKind(
346      *unwrap(C), Async ? UWTableKind::Async : UWTableKind::Sync));
347}
348
349extern "C" LLVMAttributeRef LLVMRustCreateAllocSizeAttr(LLVMContextRef C, uint32_t ElementSizeArg) {
350  return wrap(Attribute::getWithAllocSizeArgs(*unwrap(C), ElementSizeArg,
351#if LLVM_VERSION_LT(16, 0)
352                                              None
353#else
354                                              std::nullopt
355#endif
356                                              ));
357}
358
359// These values **must** match ffi::AllocKindFlags.
360// It _happens_ to match the LLVM values of llvm::AllocFnKind,
361// but that's happenstance and we do explicit conversions before
362// passing them to LLVM.
363enum class LLVMRustAllocKindFlags : uint64_t {
364  Unknown = 0,
365  Alloc = 1,
366  Realloc = 1 << 1,
367  Free = 1 << 2,
368  Uninitialized = 1 << 3,
369  Zeroed = 1 << 4,
370  Aligned = 1 << 5,
371};
372
373static LLVMRustAllocKindFlags operator&(LLVMRustAllocKindFlags A, LLVMRustAllocKindFlags B) {
374  return static_cast<LLVMRustAllocKindFlags>(static_cast<uint64_t>(A) &
375                                      static_cast<uint64_t>(B));
376}
377
378static bool isSet(LLVMRustAllocKindFlags F) { return F != LLVMRustAllocKindFlags::Unknown; }
379
380static llvm::AllocFnKind allocKindFromRust(LLVMRustAllocKindFlags F) {
381  llvm::AllocFnKind AFK = llvm::AllocFnKind::Unknown;
382  if (isSet(F & LLVMRustAllocKindFlags::Alloc)) {
383    AFK |= llvm::AllocFnKind::Alloc;
384  }
385  if (isSet(F & LLVMRustAllocKindFlags::Realloc)) {
386    AFK |= llvm::AllocFnKind::Realloc;
387  }
388  if (isSet(F & LLVMRustAllocKindFlags::Free)) {
389    AFK |= llvm::AllocFnKind::Free;
390  }
391  if (isSet(F & LLVMRustAllocKindFlags::Uninitialized)) {
392    AFK |= llvm::AllocFnKind::Uninitialized;
393  }
394  if (isSet(F & LLVMRustAllocKindFlags::Zeroed)) {
395    AFK |= llvm::AllocFnKind::Zeroed;
396  }
397  if (isSet(F & LLVMRustAllocKindFlags::Aligned)) {
398    AFK |= llvm::AllocFnKind::Aligned;
399  }
400  return AFK;
401}
402
403extern "C" LLVMAttributeRef LLVMRustCreateAllocKindAttr(LLVMContextRef C, uint64_t AllocKindArg) {
404  return wrap(Attribute::get(*unwrap(C), Attribute::AllocKind,
405      static_cast<uint64_t>(allocKindFromRust(static_cast<LLVMRustAllocKindFlags>(AllocKindArg)))));
406}
407
408// Simplified representation of `MemoryEffects` across the FFI boundary.
409//
410// Each variant corresponds to one of the static factory methods on `MemoryEffects`.
411enum class LLVMRustMemoryEffects {
412  None,
413  ReadOnly,
414  InaccessibleMemOnly,
415};
416
417extern "C" LLVMAttributeRef LLVMRustCreateMemoryEffectsAttr(LLVMContextRef C,
418                                                            LLVMRustMemoryEffects Effects) {
419#if LLVM_VERSION_GE(16, 0)
420  switch (Effects) {
421    case LLVMRustMemoryEffects::None:
422      return wrap(Attribute::getWithMemoryEffects(*unwrap(C), MemoryEffects::none()));
423    case LLVMRustMemoryEffects::ReadOnly:
424      return wrap(Attribute::getWithMemoryEffects(*unwrap(C), MemoryEffects::readOnly()));
425    case LLVMRustMemoryEffects::InaccessibleMemOnly:
426      return wrap(Attribute::getWithMemoryEffects(*unwrap(C),
427                                                  MemoryEffects::inaccessibleMemOnly()));
428    default:
429      report_fatal_error("bad MemoryEffects.");
430  }
431#else
432  switch (Effects) {
433    case LLVMRustMemoryEffects::None:
434      return wrap(Attribute::get(*unwrap(C), Attribute::ReadNone));
435    case LLVMRustMemoryEffects::ReadOnly:
436      return wrap(Attribute::get(*unwrap(C), Attribute::ReadOnly));
437    case LLVMRustMemoryEffects::InaccessibleMemOnly:
438      return wrap(Attribute::get(*unwrap(C), Attribute::InaccessibleMemOnly));
439    default:
440      report_fatal_error("bad MemoryEffects.");
441  }
442#endif
443}
444
445// Enable a fast-math flag
446//
447// https://llvm.org/docs/LangRef.html#fast-math-flags
448extern "C" void LLVMRustSetFastMath(LLVMValueRef V) {
449  if (auto I = dyn_cast<Instruction>(unwrap<Value>(V))) {
450    I->setFast(true);
451  }
452}
453
454extern "C" LLVMValueRef
455LLVMRustBuildAtomicLoad(LLVMBuilderRef B, LLVMTypeRef Ty, LLVMValueRef Source,
456                        const char *Name, LLVMAtomicOrdering Order) {
457  Value *Ptr = unwrap(Source);
458  LoadInst *LI = unwrap(B)->CreateLoad(unwrap(Ty), Ptr, Name);
459  LI->setAtomic(fromRust(Order));
460  return wrap(LI);
461}
462
463extern "C" LLVMValueRef LLVMRustBuildAtomicStore(LLVMBuilderRef B,
464                                                 LLVMValueRef V,
465                                                 LLVMValueRef Target,
466                                                 LLVMAtomicOrdering Order) {
467  StoreInst *SI = unwrap(B)->CreateStore(unwrap(V), unwrap(Target));
468  SI->setAtomic(fromRust(Order));
469  return wrap(SI);
470}
471
472enum class LLVMRustAsmDialect {
473  Att,
474  Intel,
475};
476
477static InlineAsm::AsmDialect fromRust(LLVMRustAsmDialect Dialect) {
478  switch (Dialect) {
479  case LLVMRustAsmDialect::Att:
480    return InlineAsm::AD_ATT;
481  case LLVMRustAsmDialect::Intel:
482    return InlineAsm::AD_Intel;
483  default:
484    report_fatal_error("bad AsmDialect.");
485  }
486}
487
488extern "C" LLVMValueRef
489LLVMRustInlineAsm(LLVMTypeRef Ty, char *AsmString, size_t AsmStringLen,
490                  char *Constraints, size_t ConstraintsLen,
491                  LLVMBool HasSideEffects, LLVMBool IsAlignStack,
492                  LLVMRustAsmDialect Dialect, LLVMBool CanThrow) {
493  return wrap(InlineAsm::get(unwrap<FunctionType>(Ty),
494                             StringRef(AsmString, AsmStringLen),
495                             StringRef(Constraints, ConstraintsLen),
496                             HasSideEffects, IsAlignStack,
497                             fromRust(Dialect), CanThrow));
498}
499
500extern "C" bool LLVMRustInlineAsmVerify(LLVMTypeRef Ty, char *Constraints,
501                                        size_t ConstraintsLen) {
502  // llvm::Error converts to true if it is an error.
503  return !llvm::errorToBool(InlineAsm::verify(
504      unwrap<FunctionType>(Ty), StringRef(Constraints, ConstraintsLen)));
505}
506
507typedef DIBuilder *LLVMRustDIBuilderRef;
508
509template <typename DIT> DIT *unwrapDIPtr(LLVMMetadataRef Ref) {
510  return (DIT *)(Ref ? unwrap<MDNode>(Ref) : nullptr);
511}
512
513#define DIDescriptor DIScope
514#define DIArray DINodeArray
515#define unwrapDI unwrapDIPtr
516
517// These values **must** match debuginfo::DIFlags! They also *happen*
518// to match LLVM, but that isn't required as we do giant sets of
519// matching below. The value shouldn't be directly passed to LLVM.
520enum class LLVMRustDIFlags : uint32_t {
521  FlagZero = 0,
522  FlagPrivate = 1,
523  FlagProtected = 2,
524  FlagPublic = 3,
525  FlagFwdDecl = (1 << 2),
526  FlagAppleBlock = (1 << 3),
527  FlagBlockByrefStruct = (1 << 4),
528  FlagVirtual = (1 << 5),
529  FlagArtificial = (1 << 6),
530  FlagExplicit = (1 << 7),
531  FlagPrototyped = (1 << 8),
532  FlagObjcClassComplete = (1 << 9),
533  FlagObjectPointer = (1 << 10),
534  FlagVector = (1 << 11),
535  FlagStaticMember = (1 << 12),
536  FlagLValueReference = (1 << 13),
537  FlagRValueReference = (1 << 14),
538  FlagExternalTypeRef = (1 << 15),
539  FlagIntroducedVirtual = (1 << 18),
540  FlagBitField = (1 << 19),
541  FlagNoReturn = (1 << 20),
542  // Do not add values that are not supported by the minimum LLVM
543  // version we support! see llvm/include/llvm/IR/DebugInfoFlags.def
544};
545
546inline LLVMRustDIFlags operator&(LLVMRustDIFlags A, LLVMRustDIFlags B) {
547  return static_cast<LLVMRustDIFlags>(static_cast<uint32_t>(A) &
548                                      static_cast<uint32_t>(B));
549}
550
551inline LLVMRustDIFlags operator|(LLVMRustDIFlags A, LLVMRustDIFlags B) {
552  return static_cast<LLVMRustDIFlags>(static_cast<uint32_t>(A) |
553                                      static_cast<uint32_t>(B));
554}
555
556inline LLVMRustDIFlags &operator|=(LLVMRustDIFlags &A, LLVMRustDIFlags B) {
557  return A = A | B;
558}
559
560inline bool isSet(LLVMRustDIFlags F) { return F != LLVMRustDIFlags::FlagZero; }
561
562inline LLVMRustDIFlags visibility(LLVMRustDIFlags F) {
563  return static_cast<LLVMRustDIFlags>(static_cast<uint32_t>(F) & 0x3);
564}
565
566static DINode::DIFlags fromRust(LLVMRustDIFlags Flags) {
567  DINode::DIFlags Result = DINode::DIFlags::FlagZero;
568
569  switch (visibility(Flags)) {
570  case LLVMRustDIFlags::FlagPrivate:
571    Result |= DINode::DIFlags::FlagPrivate;
572    break;
573  case LLVMRustDIFlags::FlagProtected:
574    Result |= DINode::DIFlags::FlagProtected;
575    break;
576  case LLVMRustDIFlags::FlagPublic:
577    Result |= DINode::DIFlags::FlagPublic;
578    break;
579  default:
580    // The rest are handled below
581    break;
582  }
583
584  if (isSet(Flags & LLVMRustDIFlags::FlagFwdDecl)) {
585    Result |= DINode::DIFlags::FlagFwdDecl;
586  }
587  if (isSet(Flags & LLVMRustDIFlags::FlagAppleBlock)) {
588    Result |= DINode::DIFlags::FlagAppleBlock;
589  }
590  if (isSet(Flags & LLVMRustDIFlags::FlagVirtual)) {
591    Result |= DINode::DIFlags::FlagVirtual;
592  }
593  if (isSet(Flags & LLVMRustDIFlags::FlagArtificial)) {
594    Result |= DINode::DIFlags::FlagArtificial;
595  }
596  if (isSet(Flags & LLVMRustDIFlags::FlagExplicit)) {
597    Result |= DINode::DIFlags::FlagExplicit;
598  }
599  if (isSet(Flags & LLVMRustDIFlags::FlagPrototyped)) {
600    Result |= DINode::DIFlags::FlagPrototyped;
601  }
602  if (isSet(Flags & LLVMRustDIFlags::FlagObjcClassComplete)) {
603    Result |= DINode::DIFlags::FlagObjcClassComplete;
604  }
605  if (isSet(Flags & LLVMRustDIFlags::FlagObjectPointer)) {
606    Result |= DINode::DIFlags::FlagObjectPointer;
607  }
608  if (isSet(Flags & LLVMRustDIFlags::FlagVector)) {
609    Result |= DINode::DIFlags::FlagVector;
610  }
611  if (isSet(Flags & LLVMRustDIFlags::FlagStaticMember)) {
612    Result |= DINode::DIFlags::FlagStaticMember;
613  }
614  if (isSet(Flags & LLVMRustDIFlags::FlagLValueReference)) {
615    Result |= DINode::DIFlags::FlagLValueReference;
616  }
617  if (isSet(Flags & LLVMRustDIFlags::FlagRValueReference)) {
618    Result |= DINode::DIFlags::FlagRValueReference;
619  }
620  if (isSet(Flags & LLVMRustDIFlags::FlagIntroducedVirtual)) {
621    Result |= DINode::DIFlags::FlagIntroducedVirtual;
622  }
623  if (isSet(Flags & LLVMRustDIFlags::FlagBitField)) {
624    Result |= DINode::DIFlags::FlagBitField;
625  }
626  if (isSet(Flags & LLVMRustDIFlags::FlagNoReturn)) {
627    Result |= DINode::DIFlags::FlagNoReturn;
628  }
629
630  return Result;
631}
632
633// These values **must** match debuginfo::DISPFlags! They also *happen*
634// to match LLVM, but that isn't required as we do giant sets of
635// matching below. The value shouldn't be directly passed to LLVM.
636enum class LLVMRustDISPFlags : uint32_t {
637  SPFlagZero = 0,
638  SPFlagVirtual = 1,
639  SPFlagPureVirtual = 2,
640  SPFlagLocalToUnit = (1 << 2),
641  SPFlagDefinition = (1 << 3),
642  SPFlagOptimized = (1 << 4),
643  SPFlagMainSubprogram = (1 << 5),
644  // Do not add values that are not supported by the minimum LLVM
645  // version we support! see llvm/include/llvm/IR/DebugInfoFlags.def
646  // (In LLVM < 8, createFunction supported these as separate bool arguments.)
647};
648
649inline LLVMRustDISPFlags operator&(LLVMRustDISPFlags A, LLVMRustDISPFlags B) {
650  return static_cast<LLVMRustDISPFlags>(static_cast<uint32_t>(A) &
651                                      static_cast<uint32_t>(B));
652}
653
654inline LLVMRustDISPFlags operator|(LLVMRustDISPFlags A, LLVMRustDISPFlags B) {
655  return static_cast<LLVMRustDISPFlags>(static_cast<uint32_t>(A) |
656                                      static_cast<uint32_t>(B));
657}
658
659inline LLVMRustDISPFlags &operator|=(LLVMRustDISPFlags &A, LLVMRustDISPFlags B) {
660  return A = A | B;
661}
662
663inline bool isSet(LLVMRustDISPFlags F) { return F != LLVMRustDISPFlags::SPFlagZero; }
664
665inline LLVMRustDISPFlags virtuality(LLVMRustDISPFlags F) {
666  return static_cast<LLVMRustDISPFlags>(static_cast<uint32_t>(F) & 0x3);
667}
668
669static DISubprogram::DISPFlags fromRust(LLVMRustDISPFlags SPFlags) {
670  DISubprogram::DISPFlags Result = DISubprogram::DISPFlags::SPFlagZero;
671
672  switch (virtuality(SPFlags)) {
673  case LLVMRustDISPFlags::SPFlagVirtual:
674    Result |= DISubprogram::DISPFlags::SPFlagVirtual;
675    break;
676  case LLVMRustDISPFlags::SPFlagPureVirtual:
677    Result |= DISubprogram::DISPFlags::SPFlagPureVirtual;
678    break;
679  default:
680    // The rest are handled below
681    break;
682  }
683
684  if (isSet(SPFlags & LLVMRustDISPFlags::SPFlagLocalToUnit)) {
685    Result |= DISubprogram::DISPFlags::SPFlagLocalToUnit;
686  }
687  if (isSet(SPFlags & LLVMRustDISPFlags::SPFlagDefinition)) {
688    Result |= DISubprogram::DISPFlags::SPFlagDefinition;
689  }
690  if (isSet(SPFlags & LLVMRustDISPFlags::SPFlagOptimized)) {
691    Result |= DISubprogram::DISPFlags::SPFlagOptimized;
692  }
693  if (isSet(SPFlags & LLVMRustDISPFlags::SPFlagMainSubprogram)) {
694    Result |= DISubprogram::DISPFlags::SPFlagMainSubprogram;
695  }
696
697  return Result;
698}
699
700enum class LLVMRustDebugEmissionKind {
701  NoDebug,
702  FullDebug,
703  LineTablesOnly,
704  DebugDirectivesOnly,
705};
706
707static DICompileUnit::DebugEmissionKind fromRust(LLVMRustDebugEmissionKind Kind) {
708  switch (Kind) {
709  case LLVMRustDebugEmissionKind::NoDebug:
710    return DICompileUnit::DebugEmissionKind::NoDebug;
711  case LLVMRustDebugEmissionKind::FullDebug:
712    return DICompileUnit::DebugEmissionKind::FullDebug;
713  case LLVMRustDebugEmissionKind::LineTablesOnly:
714    return DICompileUnit::DebugEmissionKind::LineTablesOnly;
715  case LLVMRustDebugEmissionKind::DebugDirectivesOnly:
716    return DICompileUnit::DebugEmissionKind::DebugDirectivesOnly;
717  default:
718    report_fatal_error("bad DebugEmissionKind.");
719  }
720}
721
722enum class LLVMRustChecksumKind {
723  None,
724  MD5,
725  SHA1,
726  SHA256,
727};
728
729#if LLVM_VERSION_LT(16, 0)
730static Optional<DIFile::ChecksumKind> fromRust(LLVMRustChecksumKind Kind) {
731#else
732static std::optional<DIFile::ChecksumKind> fromRust(LLVMRustChecksumKind Kind) {
733#endif
734  switch (Kind) {
735  case LLVMRustChecksumKind::None:
736#if LLVM_VERSION_LT(16, 0)
737    return None;
738#else
739    return std::nullopt;
740#endif
741  case LLVMRustChecksumKind::MD5:
742    return DIFile::ChecksumKind::CSK_MD5;
743  case LLVMRustChecksumKind::SHA1:
744    return DIFile::ChecksumKind::CSK_SHA1;
745  case LLVMRustChecksumKind::SHA256:
746    return DIFile::ChecksumKind::CSK_SHA256;
747  default:
748    report_fatal_error("bad ChecksumKind.");
749  }
750}
751
752extern "C" uint32_t LLVMRustDebugMetadataVersion() {
753  return DEBUG_METADATA_VERSION;
754}
755
756extern "C" uint32_t LLVMRustVersionPatch() { return LLVM_VERSION_PATCH; }
757
758extern "C" uint32_t LLVMRustVersionMinor() { return LLVM_VERSION_MINOR; }
759
760extern "C" uint32_t LLVMRustVersionMajor() { return LLVM_VERSION_MAJOR; }
761
762extern "C" void LLVMRustAddModuleFlag(
763    LLVMModuleRef M,
764    Module::ModFlagBehavior MergeBehavior,
765    const char *Name,
766    uint32_t Value) {
767  unwrap(M)->addModuleFlag(MergeBehavior, Name, Value);
768}
769
770extern "C" bool LLVMRustHasModuleFlag(LLVMModuleRef M, const char *Name,
771                                      size_t Len) {
772  return unwrap(M)->getModuleFlag(StringRef(Name, Len)) != nullptr;
773}
774
775extern "C" void LLVMRustGlobalAddMetadata(
776    LLVMValueRef Global, unsigned Kind, LLVMMetadataRef MD) {
777  unwrap<GlobalObject>(Global)->addMetadata(Kind, *unwrap<MDNode>(MD));
778}
779
780extern "C" LLVMRustDIBuilderRef LLVMRustDIBuilderCreate(LLVMModuleRef M) {
781  return new DIBuilder(*unwrap(M));
782}
783
784extern "C" void LLVMRustDIBuilderDispose(LLVMRustDIBuilderRef Builder) {
785  delete Builder;
786}
787
788extern "C" void LLVMRustDIBuilderFinalize(LLVMRustDIBuilderRef Builder) {
789  Builder->finalize();
790}
791
792extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateCompileUnit(
793    LLVMRustDIBuilderRef Builder, unsigned Lang, LLVMMetadataRef FileRef,
794    const char *Producer, size_t ProducerLen, bool isOptimized,
795    const char *Flags, unsigned RuntimeVer,
796    const char *SplitName, size_t SplitNameLen,
797    LLVMRustDebugEmissionKind Kind,
798    uint64_t DWOId, bool SplitDebugInlining) {
799  auto *File = unwrapDI<DIFile>(FileRef);
800
801  return wrap(Builder->createCompileUnit(Lang, File, StringRef(Producer, ProducerLen),
802                                         isOptimized, Flags, RuntimeVer,
803                                         StringRef(SplitName, SplitNameLen),
804                                         fromRust(Kind), DWOId, SplitDebugInlining));
805}
806
807extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateFile(
808    LLVMRustDIBuilderRef Builder,
809    const char *Filename, size_t FilenameLen,
810    const char *Directory, size_t DirectoryLen, LLVMRustChecksumKind CSKind,
811    const char *Checksum, size_t ChecksumLen) {
812
813#if LLVM_VERSION_LT(16, 0)
814  Optional<DIFile::ChecksumKind> llvmCSKind = fromRust(CSKind);
815#else
816  std::optional<DIFile::ChecksumKind> llvmCSKind = fromRust(CSKind);
817#endif
818
819#if LLVM_VERSION_LT(16, 0)
820  Optional<DIFile::ChecksumInfo<StringRef>> CSInfo{};
821#else
822  std::optional<DIFile::ChecksumInfo<StringRef>> CSInfo{};
823#endif
824  if (llvmCSKind)
825    CSInfo.emplace(*llvmCSKind, StringRef{Checksum, ChecksumLen});
826  return wrap(Builder->createFile(StringRef(Filename, FilenameLen),
827                                  StringRef(Directory, DirectoryLen),
828                                  CSInfo));
829}
830
831extern "C" LLVMMetadataRef
832LLVMRustDIBuilderCreateSubroutineType(LLVMRustDIBuilderRef Builder,
833                                      LLVMMetadataRef ParameterTypes) {
834  return wrap(Builder->createSubroutineType(
835      DITypeRefArray(unwrap<MDTuple>(ParameterTypes))));
836}
837
838extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateFunction(
839    LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope,
840    const char *Name, size_t NameLen,
841    const char *LinkageName, size_t LinkageNameLen,
842    LLVMMetadataRef File, unsigned LineNo,
843    LLVMMetadataRef Ty, unsigned ScopeLine, LLVMRustDIFlags Flags,
844    LLVMRustDISPFlags SPFlags, LLVMValueRef MaybeFn, LLVMMetadataRef TParam,
845    LLVMMetadataRef Decl) {
846  DITemplateParameterArray TParams =
847      DITemplateParameterArray(unwrap<MDTuple>(TParam));
848  DISubprogram::DISPFlags llvmSPFlags = fromRust(SPFlags);
849  DINode::DIFlags llvmFlags = fromRust(Flags);
850  DISubprogram *Sub = Builder->createFunction(
851      unwrapDI<DIScope>(Scope),
852      StringRef(Name, NameLen),
853      StringRef(LinkageName, LinkageNameLen),
854      unwrapDI<DIFile>(File), LineNo,
855      unwrapDI<DISubroutineType>(Ty), ScopeLine, llvmFlags,
856      llvmSPFlags, TParams, unwrapDIPtr<DISubprogram>(Decl));
857  if (MaybeFn)
858    unwrap<Function>(MaybeFn)->setSubprogram(Sub);
859  return wrap(Sub);
860}
861
862extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateMethod(
863    LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope,
864    const char *Name, size_t NameLen,
865    const char *LinkageName, size_t LinkageNameLen,
866    LLVMMetadataRef File, unsigned LineNo,
867    LLVMMetadataRef Ty, LLVMRustDIFlags Flags,
868    LLVMRustDISPFlags SPFlags, LLVMMetadataRef TParam) {
869  DITemplateParameterArray TParams =
870      DITemplateParameterArray(unwrap<MDTuple>(TParam));
871  DISubprogram::DISPFlags llvmSPFlags = fromRust(SPFlags);
872  DINode::DIFlags llvmFlags = fromRust(Flags);
873  DISubprogram *Sub = Builder->createMethod(
874      unwrapDI<DIScope>(Scope),
875      StringRef(Name, NameLen),
876      StringRef(LinkageName, LinkageNameLen),
877      unwrapDI<DIFile>(File), LineNo,
878      unwrapDI<DISubroutineType>(Ty),
879      0, 0, nullptr, // VTable params aren't used
880      llvmFlags, llvmSPFlags, TParams);
881  return wrap(Sub);
882}
883
884extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateBasicType(
885    LLVMRustDIBuilderRef Builder, const char *Name, size_t NameLen,
886    uint64_t SizeInBits, unsigned Encoding) {
887  return wrap(Builder->createBasicType(StringRef(Name, NameLen), SizeInBits, Encoding));
888}
889
890extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateTypedef(
891    LLVMRustDIBuilderRef Builder, LLVMMetadataRef Type, const char *Name, size_t NameLen,
892    LLVMMetadataRef File, unsigned LineNo, LLVMMetadataRef Scope) {
893  return wrap(Builder->createTypedef(
894    unwrap<DIType>(Type), StringRef(Name, NameLen), unwrap<DIFile>(File),
895    LineNo, unwrapDIPtr<DIScope>(Scope)));
896}
897
898extern "C" LLVMMetadataRef LLVMRustDIBuilderCreatePointerType(
899    LLVMRustDIBuilderRef Builder, LLVMMetadataRef PointeeTy,
900    uint64_t SizeInBits, uint32_t AlignInBits, unsigned AddressSpace,
901    const char *Name, size_t NameLen) {
902  return wrap(Builder->createPointerType(unwrapDI<DIType>(PointeeTy),
903                                         SizeInBits, AlignInBits,
904                                         AddressSpace,
905                                         StringRef(Name, NameLen)));
906}
907
908extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateStructType(
909    LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope,
910    const char *Name, size_t NameLen,
911    LLVMMetadataRef File, unsigned LineNumber, uint64_t SizeInBits,
912    uint32_t AlignInBits, LLVMRustDIFlags Flags,
913    LLVMMetadataRef DerivedFrom, LLVMMetadataRef Elements,
914    unsigned RunTimeLang, LLVMMetadataRef VTableHolder,
915    const char *UniqueId, size_t UniqueIdLen) {
916  return wrap(Builder->createStructType(
917      unwrapDI<DIDescriptor>(Scope), StringRef(Name, NameLen),
918      unwrapDI<DIFile>(File), LineNumber,
919      SizeInBits, AlignInBits, fromRust(Flags), unwrapDI<DIType>(DerivedFrom),
920      DINodeArray(unwrapDI<MDTuple>(Elements)), RunTimeLang,
921      unwrapDI<DIType>(VTableHolder), StringRef(UniqueId, UniqueIdLen)));
922}
923
924extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateVariantPart(
925    LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope,
926    const char *Name, size_t NameLen,
927    LLVMMetadataRef File, unsigned LineNumber, uint64_t SizeInBits,
928    uint32_t AlignInBits, LLVMRustDIFlags Flags, LLVMMetadataRef Discriminator,
929    LLVMMetadataRef Elements, const char *UniqueId, size_t UniqueIdLen) {
930  return wrap(Builder->createVariantPart(
931      unwrapDI<DIDescriptor>(Scope), StringRef(Name, NameLen),
932      unwrapDI<DIFile>(File), LineNumber,
933      SizeInBits, AlignInBits, fromRust(Flags), unwrapDI<DIDerivedType>(Discriminator),
934      DINodeArray(unwrapDI<MDTuple>(Elements)), StringRef(UniqueId, UniqueIdLen)));
935}
936
937extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateMemberType(
938    LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope,
939    const char *Name, size_t NameLen,
940    LLVMMetadataRef File, unsigned LineNo, uint64_t SizeInBits,
941    uint32_t AlignInBits, uint64_t OffsetInBits, LLVMRustDIFlags Flags,
942    LLVMMetadataRef Ty) {
943  return wrap(Builder->createMemberType(unwrapDI<DIDescriptor>(Scope),
944                                        StringRef(Name, NameLen),
945                                        unwrapDI<DIFile>(File), LineNo,
946                                        SizeInBits, AlignInBits, OffsetInBits,
947                                        fromRust(Flags), unwrapDI<DIType>(Ty)));
948}
949
950extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateVariantMemberType(
951    LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope,
952    const char *Name, size_t NameLen, LLVMMetadataRef File, unsigned LineNo,
953    uint64_t SizeInBits, uint32_t AlignInBits, uint64_t OffsetInBits, LLVMValueRef Discriminant,
954    LLVMRustDIFlags Flags, LLVMMetadataRef Ty) {
955  llvm::ConstantInt* D = nullptr;
956  if (Discriminant) {
957    D = unwrap<llvm::ConstantInt>(Discriminant);
958  }
959  return wrap(Builder->createVariantMemberType(unwrapDI<DIDescriptor>(Scope),
960                                               StringRef(Name, NameLen),
961                                               unwrapDI<DIFile>(File), LineNo,
962                                               SizeInBits, AlignInBits, OffsetInBits, D,
963                                               fromRust(Flags), unwrapDI<DIType>(Ty)));
964}
965
966extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateStaticMemberType(
967    LLVMRustDIBuilderRef Builder,
968    LLVMMetadataRef Scope,
969    const char *Name,
970    size_t NameLen,
971    LLVMMetadataRef File,
972    unsigned LineNo,
973    LLVMMetadataRef Ty,
974    LLVMRustDIFlags Flags,
975    LLVMValueRef val,
976    uint32_t AlignInBits
977) {
978  return wrap(Builder->createStaticMemberType(
979    unwrapDI<DIDescriptor>(Scope),
980    StringRef(Name, NameLen),
981    unwrapDI<DIFile>(File),
982    LineNo,
983    unwrapDI<DIType>(Ty),
984    fromRust(Flags),
985    unwrap<llvm::ConstantInt>(val),
986    AlignInBits
987  ));
988}
989
990extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateLexicalBlock(
991    LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope,
992    LLVMMetadataRef File, unsigned Line, unsigned Col) {
993  return wrap(Builder->createLexicalBlock(unwrapDI<DIDescriptor>(Scope),
994                                          unwrapDI<DIFile>(File), Line, Col));
995}
996
997extern "C" LLVMMetadataRef
998LLVMRustDIBuilderCreateLexicalBlockFile(LLVMRustDIBuilderRef Builder,
999                                        LLVMMetadataRef Scope,
1000                                        LLVMMetadataRef File) {
1001  return wrap(Builder->createLexicalBlockFile(unwrapDI<DIDescriptor>(Scope),
1002                                              unwrapDI<DIFile>(File)));
1003}
1004
1005extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateStaticVariable(
1006    LLVMRustDIBuilderRef Builder, LLVMMetadataRef Context,
1007    const char *Name, size_t NameLen,
1008    const char *LinkageName, size_t LinkageNameLen,
1009    LLVMMetadataRef File, unsigned LineNo,
1010    LLVMMetadataRef Ty, bool IsLocalToUnit, LLVMValueRef V,
1011    LLVMMetadataRef Decl = nullptr, uint32_t AlignInBits = 0) {
1012  llvm::GlobalVariable *InitVal = cast<llvm::GlobalVariable>(unwrap(V));
1013
1014  llvm::DIExpression *InitExpr = nullptr;
1015  if (llvm::ConstantInt *IntVal = llvm::dyn_cast<llvm::ConstantInt>(InitVal)) {
1016    InitExpr = Builder->createConstantValueExpression(
1017        IntVal->getValue().getSExtValue());
1018  } else if (llvm::ConstantFP *FPVal =
1019                 llvm::dyn_cast<llvm::ConstantFP>(InitVal)) {
1020    InitExpr = Builder->createConstantValueExpression(
1021        FPVal->getValueAPF().bitcastToAPInt().getZExtValue());
1022  }
1023
1024  llvm::DIGlobalVariableExpression *VarExpr = Builder->createGlobalVariableExpression(
1025      unwrapDI<DIDescriptor>(Context), StringRef(Name, NameLen),
1026      StringRef(LinkageName, LinkageNameLen),
1027      unwrapDI<DIFile>(File), LineNo, unwrapDI<DIType>(Ty), IsLocalToUnit,
1028      /* isDefined */ true,
1029      InitExpr, unwrapDIPtr<MDNode>(Decl),
1030      /* templateParams */ nullptr,
1031      AlignInBits);
1032
1033  InitVal->setMetadata("dbg", VarExpr);
1034
1035  return wrap(VarExpr);
1036}
1037
1038extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateVariable(
1039    LLVMRustDIBuilderRef Builder, unsigned Tag, LLVMMetadataRef Scope,
1040    const char *Name, size_t NameLen,
1041    LLVMMetadataRef File, unsigned LineNo,
1042    LLVMMetadataRef Ty, bool AlwaysPreserve, LLVMRustDIFlags Flags,
1043    unsigned ArgNo, uint32_t AlignInBits) {
1044  if (Tag == 0x100) { // DW_TAG_auto_variable
1045    return wrap(Builder->createAutoVariable(
1046        unwrapDI<DIDescriptor>(Scope), StringRef(Name, NameLen),
1047        unwrapDI<DIFile>(File), LineNo,
1048        unwrapDI<DIType>(Ty), AlwaysPreserve, fromRust(Flags), AlignInBits));
1049  } else {
1050    return wrap(Builder->createParameterVariable(
1051        unwrapDI<DIDescriptor>(Scope), StringRef(Name, NameLen), ArgNo,
1052        unwrapDI<DIFile>(File), LineNo,
1053        unwrapDI<DIType>(Ty), AlwaysPreserve, fromRust(Flags)));
1054  }
1055}
1056
1057extern "C" LLVMMetadataRef
1058LLVMRustDIBuilderCreateArrayType(LLVMRustDIBuilderRef Builder, uint64_t Size,
1059                                 uint32_t AlignInBits, LLVMMetadataRef Ty,
1060                                 LLVMMetadataRef Subscripts) {
1061  return wrap(
1062      Builder->createArrayType(Size, AlignInBits, unwrapDI<DIType>(Ty),
1063                               DINodeArray(unwrapDI<MDTuple>(Subscripts))));
1064}
1065
1066extern "C" LLVMMetadataRef
1067LLVMRustDIBuilderGetOrCreateSubrange(LLVMRustDIBuilderRef Builder, int64_t Lo,
1068                                     int64_t Count) {
1069  return wrap(Builder->getOrCreateSubrange(Lo, Count));
1070}
1071
1072extern "C" LLVMMetadataRef
1073LLVMRustDIBuilderGetOrCreateArray(LLVMRustDIBuilderRef Builder,
1074                                  LLVMMetadataRef *Ptr, unsigned Count) {
1075  Metadata **DataValue = unwrap(Ptr);
1076  return wrap(
1077      Builder->getOrCreateArray(ArrayRef<Metadata *>(DataValue, Count)).get());
1078}
1079
1080extern "C" LLVMValueRef LLVMRustDIBuilderInsertDeclareAtEnd(
1081    LLVMRustDIBuilderRef Builder, LLVMValueRef V, LLVMMetadataRef VarInfo,
1082    uint64_t *AddrOps, unsigned AddrOpsCount, LLVMMetadataRef DL,
1083    LLVMBasicBlockRef InsertAtEnd) {
1084  return wrap(Builder->insertDeclare(
1085      unwrap(V), unwrap<DILocalVariable>(VarInfo),
1086      Builder->createExpression(llvm::ArrayRef<uint64_t>(AddrOps, AddrOpsCount)),
1087      DebugLoc(cast<MDNode>(unwrap(DL))),
1088      unwrap(InsertAtEnd)));
1089}
1090
1091extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateEnumerator(
1092    LLVMRustDIBuilderRef Builder, const char *Name, size_t NameLen,
1093    const uint64_t Value[2], unsigned SizeInBits, bool IsUnsigned) {
1094  return wrap(Builder->createEnumerator(StringRef(Name, NameLen),
1095      APSInt(APInt(SizeInBits, ArrayRef<uint64_t>(Value, 2)), IsUnsigned)));
1096}
1097
1098extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateEnumerationType(
1099    LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope,
1100    const char *Name, size_t NameLen,
1101    LLVMMetadataRef File, unsigned LineNumber, uint64_t SizeInBits,
1102    uint32_t AlignInBits, LLVMMetadataRef Elements,
1103    LLVMMetadataRef ClassTy, bool IsScoped) {
1104  return wrap(Builder->createEnumerationType(
1105      unwrapDI<DIDescriptor>(Scope), StringRef(Name, NameLen),
1106      unwrapDI<DIFile>(File), LineNumber,
1107      SizeInBits, AlignInBits, DINodeArray(unwrapDI<MDTuple>(Elements)),
1108      unwrapDI<DIType>(ClassTy), "", IsScoped));
1109}
1110
1111extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateUnionType(
1112    LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope,
1113    const char *Name, size_t NameLen,
1114    LLVMMetadataRef File, unsigned LineNumber, uint64_t SizeInBits,
1115    uint32_t AlignInBits, LLVMRustDIFlags Flags, LLVMMetadataRef Elements,
1116    unsigned RunTimeLang, const char *UniqueId, size_t UniqueIdLen) {
1117  return wrap(Builder->createUnionType(
1118      unwrapDI<DIDescriptor>(Scope), StringRef(Name, NameLen), unwrapDI<DIFile>(File),
1119      LineNumber, SizeInBits, AlignInBits, fromRust(Flags),
1120      DINodeArray(unwrapDI<MDTuple>(Elements)), RunTimeLang,
1121      StringRef(UniqueId, UniqueIdLen)));
1122}
1123
1124extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateTemplateTypeParameter(
1125    LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope,
1126    const char *Name, size_t NameLen, LLVMMetadataRef Ty) {
1127  bool IsDefault = false; // FIXME: should we ever set this true?
1128  return wrap(Builder->createTemplateTypeParameter(
1129      unwrapDI<DIDescriptor>(Scope), StringRef(Name, NameLen), unwrapDI<DIType>(Ty), IsDefault));
1130}
1131
1132extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateNameSpace(
1133    LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope,
1134    const char *Name, size_t NameLen, bool ExportSymbols) {
1135  return wrap(Builder->createNameSpace(
1136      unwrapDI<DIDescriptor>(Scope), StringRef(Name, NameLen), ExportSymbols
1137  ));
1138}
1139
1140extern "C" void
1141LLVMRustDICompositeTypeReplaceArrays(LLVMRustDIBuilderRef Builder,
1142                                     LLVMMetadataRef CompositeTy,
1143                                     LLVMMetadataRef Elements,
1144                                     LLVMMetadataRef Params) {
1145  DICompositeType *Tmp = unwrapDI<DICompositeType>(CompositeTy);
1146  Builder->replaceArrays(Tmp, DINodeArray(unwrap<MDTuple>(Elements)),
1147                         DINodeArray(unwrap<MDTuple>(Params)));
1148}
1149
1150extern "C" LLVMMetadataRef
1151LLVMRustDIBuilderCreateDebugLocation(unsigned Line, unsigned Column,
1152                                     LLVMMetadataRef ScopeRef,
1153                                     LLVMMetadataRef InlinedAt) {
1154  MDNode *Scope = unwrapDIPtr<MDNode>(ScopeRef);
1155  DILocation *Loc = DILocation::get(
1156      Scope->getContext(), Line, Column, Scope,
1157      unwrapDIPtr<MDNode>(InlinedAt));
1158  return wrap(Loc);
1159}
1160
1161extern "C" uint64_t LLVMRustDIBuilderCreateOpDeref() {
1162  return dwarf::DW_OP_deref;
1163}
1164
1165extern "C" uint64_t LLVMRustDIBuilderCreateOpPlusUconst() {
1166  return dwarf::DW_OP_plus_uconst;
1167}
1168
1169extern "C" int64_t LLVMRustDIBuilderCreateOpLLVMFragment() {
1170  return dwarf::DW_OP_LLVM_fragment;
1171}
1172
1173extern "C" void LLVMRustWriteTypeToString(LLVMTypeRef Ty, RustStringRef Str) {
1174  RawRustStringOstream OS(Str);
1175  unwrap<llvm::Type>(Ty)->print(OS);
1176}
1177
1178extern "C" void LLVMRustWriteValueToString(LLVMValueRef V,
1179                                           RustStringRef Str) {
1180  RawRustStringOstream OS(Str);
1181  if (!V) {
1182    OS << "(null)";
1183  } else {
1184    OS << "(";
1185    unwrap<llvm::Value>(V)->getType()->print(OS);
1186    OS << ":";
1187    unwrap<llvm::Value>(V)->print(OS);
1188    OS << ")";
1189  }
1190}
1191
1192// LLVMArrayType function does not support 64-bit ElementCount
1193// FIXME: replace with LLVMArrayType2 when bumped minimal version to llvm-17
1194// https://github.com/llvm/llvm-project/commit/35276f16e5a2cae0dfb49c0fbf874d4d2f177acc
1195extern "C" LLVMTypeRef LLVMRustArrayType(LLVMTypeRef ElementTy,
1196                                         uint64_t ElementCount) {
1197  return wrap(ArrayType::get(unwrap(ElementTy), ElementCount));
1198}
1199
1200DEFINE_SIMPLE_CONVERSION_FUNCTIONS(Twine, LLVMTwineRef)
1201
1202extern "C" void LLVMRustWriteTwineToString(LLVMTwineRef T, RustStringRef Str) {
1203  RawRustStringOstream OS(Str);
1204  unwrap(T)->print(OS);
1205}
1206
1207extern "C" void LLVMRustUnpackOptimizationDiagnostic(
1208    LLVMDiagnosticInfoRef DI, RustStringRef PassNameOut,
1209    LLVMValueRef *FunctionOut, unsigned* Line, unsigned* Column,
1210    RustStringRef FilenameOut, RustStringRef MessageOut) {
1211  // Undefined to call this not on an optimization diagnostic!
1212  llvm::DiagnosticInfoOptimizationBase *Opt =
1213      static_cast<llvm::DiagnosticInfoOptimizationBase *>(unwrap(DI));
1214
1215  RawRustStringOstream PassNameOS(PassNameOut);
1216  PassNameOS << Opt->getPassName();
1217  *FunctionOut = wrap(&Opt->getFunction());
1218
1219  RawRustStringOstream FilenameOS(FilenameOut);
1220  DiagnosticLocation loc = Opt->getLocation();
1221  if (loc.isValid()) {
1222    *Line = loc.getLine();
1223    *Column = loc.getColumn();
1224    FilenameOS << loc.getAbsolutePath();
1225  }
1226
1227  RawRustStringOstream MessageOS(MessageOut);
1228  MessageOS << Opt->getMsg();
1229}
1230
1231enum class LLVMRustDiagnosticLevel {
1232    Error,
1233    Warning,
1234    Note,
1235    Remark,
1236};
1237
1238extern "C" void
1239LLVMRustUnpackInlineAsmDiagnostic(LLVMDiagnosticInfoRef DI,
1240                                  LLVMRustDiagnosticLevel *LevelOut,
1241                                  unsigned *CookieOut,
1242                                  LLVMTwineRef *MessageOut) {
1243  // Undefined to call this not on an inline assembly diagnostic!
1244  llvm::DiagnosticInfoInlineAsm *IA =
1245      static_cast<llvm::DiagnosticInfoInlineAsm *>(unwrap(DI));
1246
1247  *CookieOut = IA->getLocCookie();
1248  *MessageOut = wrap(&IA->getMsgStr());
1249
1250  switch (IA->getSeverity()) {
1251    case DS_Error:
1252      *LevelOut = LLVMRustDiagnosticLevel::Error;
1253      break;
1254    case DS_Warning:
1255      *LevelOut = LLVMRustDiagnosticLevel::Warning;
1256      break;
1257    case DS_Note:
1258      *LevelOut = LLVMRustDiagnosticLevel::Note;
1259      break;
1260    case DS_Remark:
1261      *LevelOut = LLVMRustDiagnosticLevel::Remark;
1262      break;
1263    default:
1264      report_fatal_error("Invalid LLVMRustDiagnosticLevel value!");
1265  }
1266}
1267
1268extern "C" void LLVMRustWriteDiagnosticInfoToString(LLVMDiagnosticInfoRef DI,
1269                                                    RustStringRef Str) {
1270  RawRustStringOstream OS(Str);
1271  DiagnosticPrinterRawOStream DP(OS);
1272  unwrap(DI)->print(DP);
1273}
1274
1275enum class LLVMRustDiagnosticKind {
1276  Other,
1277  InlineAsm,
1278  StackSize,
1279  DebugMetadataVersion,
1280  SampleProfile,
1281  OptimizationRemark,
1282  OptimizationRemarkMissed,
1283  OptimizationRemarkAnalysis,
1284  OptimizationRemarkAnalysisFPCommute,
1285  OptimizationRemarkAnalysisAliasing,
1286  OptimizationRemarkOther,
1287  OptimizationFailure,
1288  PGOProfile,
1289  Linker,
1290  Unsupported,
1291  SrcMgr,
1292};
1293
1294static LLVMRustDiagnosticKind toRust(DiagnosticKind Kind) {
1295  switch (Kind) {
1296  case DK_InlineAsm:
1297    return LLVMRustDiagnosticKind::InlineAsm;
1298  case DK_StackSize:
1299    return LLVMRustDiagnosticKind::StackSize;
1300  case DK_DebugMetadataVersion:
1301    return LLVMRustDiagnosticKind::DebugMetadataVersion;
1302  case DK_SampleProfile:
1303    return LLVMRustDiagnosticKind::SampleProfile;
1304  case DK_OptimizationRemark:
1305  case DK_MachineOptimizationRemark:
1306    return LLVMRustDiagnosticKind::OptimizationRemark;
1307  case DK_OptimizationRemarkMissed:
1308  case DK_MachineOptimizationRemarkMissed:
1309    return LLVMRustDiagnosticKind::OptimizationRemarkMissed;
1310  case DK_OptimizationRemarkAnalysis:
1311  case DK_MachineOptimizationRemarkAnalysis:
1312    return LLVMRustDiagnosticKind::OptimizationRemarkAnalysis;
1313  case DK_OptimizationRemarkAnalysisFPCommute:
1314    return LLVMRustDiagnosticKind::OptimizationRemarkAnalysisFPCommute;
1315  case DK_OptimizationRemarkAnalysisAliasing:
1316    return LLVMRustDiagnosticKind::OptimizationRemarkAnalysisAliasing;
1317  case DK_PGOProfile:
1318    return LLVMRustDiagnosticKind::PGOProfile;
1319  case DK_Linker:
1320    return LLVMRustDiagnosticKind::Linker;
1321  case DK_Unsupported:
1322    return LLVMRustDiagnosticKind::Unsupported;
1323  case DK_SrcMgr:
1324    return LLVMRustDiagnosticKind::SrcMgr;
1325  default:
1326    return (Kind >= DK_FirstRemark && Kind <= DK_LastRemark)
1327               ? LLVMRustDiagnosticKind::OptimizationRemarkOther
1328               : LLVMRustDiagnosticKind::Other;
1329  }
1330}
1331
1332extern "C" LLVMRustDiagnosticKind
1333LLVMRustGetDiagInfoKind(LLVMDiagnosticInfoRef DI) {
1334  return toRust((DiagnosticKind)unwrap(DI)->getKind());
1335}
1336
1337// This is kept distinct from LLVMGetTypeKind, because when
1338// a new type kind is added, the Rust-side enum must be
1339// updated or UB will result.
1340extern "C" LLVMTypeKind LLVMRustGetTypeKind(LLVMTypeRef Ty) {
1341  switch (unwrap(Ty)->getTypeID()) {
1342  case Type::VoidTyID:
1343    return LLVMVoidTypeKind;
1344  case Type::HalfTyID:
1345    return LLVMHalfTypeKind;
1346  case Type::FloatTyID:
1347    return LLVMFloatTypeKind;
1348  case Type::DoubleTyID:
1349    return LLVMDoubleTypeKind;
1350  case Type::X86_FP80TyID:
1351    return LLVMX86_FP80TypeKind;
1352  case Type::FP128TyID:
1353    return LLVMFP128TypeKind;
1354  case Type::PPC_FP128TyID:
1355    return LLVMPPC_FP128TypeKind;
1356  case Type::LabelTyID:
1357    return LLVMLabelTypeKind;
1358  case Type::MetadataTyID:
1359    return LLVMMetadataTypeKind;
1360  case Type::IntegerTyID:
1361    return LLVMIntegerTypeKind;
1362  case Type::FunctionTyID:
1363    return LLVMFunctionTypeKind;
1364  case Type::StructTyID:
1365    return LLVMStructTypeKind;
1366  case Type::ArrayTyID:
1367    return LLVMArrayTypeKind;
1368  case Type::PointerTyID:
1369    return LLVMPointerTypeKind;
1370  case Type::FixedVectorTyID:
1371    return LLVMVectorTypeKind;
1372  case Type::X86_MMXTyID:
1373    return LLVMX86_MMXTypeKind;
1374  case Type::TokenTyID:
1375    return LLVMTokenTypeKind;
1376  case Type::ScalableVectorTyID:
1377    return LLVMScalableVectorTypeKind;
1378  case Type::BFloatTyID:
1379    return LLVMBFloatTypeKind;
1380  case Type::X86_AMXTyID:
1381    return LLVMX86_AMXTypeKind;
1382  default:
1383    {
1384      std::string error;
1385      llvm::raw_string_ostream stream(error);
1386      stream << "Rust does not support the TypeID: " << unwrap(Ty)->getTypeID()
1387             << " for the type: " << *unwrap(Ty);
1388      stream.flush();
1389      report_fatal_error(error.c_str());
1390    }
1391  }
1392}
1393
1394DEFINE_SIMPLE_CONVERSION_FUNCTIONS(SMDiagnostic, LLVMSMDiagnosticRef)
1395
1396extern "C" LLVMSMDiagnosticRef LLVMRustGetSMDiagnostic(
1397    LLVMDiagnosticInfoRef DI, unsigned *Cookie) {
1398  llvm::DiagnosticInfoSrcMgr *SM = static_cast<llvm::DiagnosticInfoSrcMgr *>(unwrap(DI));
1399  *Cookie = SM->getLocCookie();
1400  return wrap(&SM->getSMDiag());
1401}
1402
1403extern "C" bool LLVMRustUnpackSMDiagnostic(LLVMSMDiagnosticRef DRef,
1404                                           RustStringRef MessageOut,
1405                                           RustStringRef BufferOut,
1406                                           LLVMRustDiagnosticLevel* LevelOut,
1407                                           unsigned* LocOut,
1408                                           unsigned* RangesOut,
1409                                           size_t* NumRanges) {
1410  SMDiagnostic& D = *unwrap(DRef);
1411  RawRustStringOstream MessageOS(MessageOut);
1412  MessageOS << D.getMessage();
1413
1414  switch (D.getKind()) {
1415    case SourceMgr::DK_Error:
1416      *LevelOut = LLVMRustDiagnosticLevel::Error;
1417      break;
1418    case SourceMgr::DK_Warning:
1419      *LevelOut = LLVMRustDiagnosticLevel::Warning;
1420      break;
1421    case SourceMgr::DK_Note:
1422      *LevelOut = LLVMRustDiagnosticLevel::Note;
1423      break;
1424    case SourceMgr::DK_Remark:
1425      *LevelOut = LLVMRustDiagnosticLevel::Remark;
1426      break;
1427    default:
1428      report_fatal_error("Invalid LLVMRustDiagnosticLevel value!");
1429  }
1430
1431  if (D.getLoc() == SMLoc())
1432    return false;
1433
1434  const SourceMgr &LSM = *D.getSourceMgr();
1435  const MemoryBuffer *LBuf = LSM.getMemoryBuffer(LSM.FindBufferContainingLoc(D.getLoc()));
1436  LLVMRustStringWriteImpl(BufferOut, LBuf->getBufferStart(), LBuf->getBufferSize());
1437
1438  *LocOut = D.getLoc().getPointer() - LBuf->getBufferStart();
1439
1440  *NumRanges = std::min(*NumRanges, D.getRanges().size());
1441  size_t LineStart = *LocOut - (size_t)D.getColumnNo();
1442  for (size_t i = 0; i < *NumRanges; i++) {
1443    RangesOut[i * 2] = LineStart + D.getRanges()[i].first;
1444    RangesOut[i * 2 + 1] = LineStart + D.getRanges()[i].second;
1445  }
1446
1447  return true;
1448}
1449
1450extern "C" OperandBundleDef *LLVMRustBuildOperandBundleDef(const char *Name,
1451                                                           LLVMValueRef *Inputs,
1452                                                           unsigned NumInputs) {
1453  return new OperandBundleDef(Name, ArrayRef<Value*>(unwrap(Inputs), NumInputs));
1454}
1455
1456extern "C" void LLVMRustFreeOperandBundleDef(OperandBundleDef *Bundle) {
1457  delete Bundle;
1458}
1459
1460extern "C" LLVMValueRef LLVMRustBuildCall(LLVMBuilderRef B, LLVMTypeRef Ty, LLVMValueRef Fn,
1461                                          LLVMValueRef *Args, unsigned NumArgs,
1462                                          OperandBundleDef **OpBundles,
1463                                          unsigned NumOpBundles) {
1464  Value *Callee = unwrap(Fn);
1465  FunctionType *FTy = unwrap<FunctionType>(Ty);
1466  return wrap(unwrap(B)->CreateCall(
1467      FTy, Callee, ArrayRef<Value*>(unwrap(Args), NumArgs),
1468      ArrayRef<OperandBundleDef>(*OpBundles, NumOpBundles)));
1469}
1470
1471extern "C" LLVMValueRef LLVMRustGetInstrProfIncrementIntrinsic(LLVMModuleRef M) {
1472  return wrap(llvm::Intrinsic::getDeclaration(unwrap(M),
1473              (llvm::Intrinsic::ID)llvm::Intrinsic::instrprof_increment));
1474}
1475
1476extern "C" LLVMValueRef LLVMRustBuildMemCpy(LLVMBuilderRef B,
1477                                            LLVMValueRef Dst, unsigned DstAlign,
1478                                            LLVMValueRef Src, unsigned SrcAlign,
1479                                            LLVMValueRef Size, bool IsVolatile) {
1480  return wrap(unwrap(B)->CreateMemCpy(
1481      unwrap(Dst), MaybeAlign(DstAlign),
1482      unwrap(Src), MaybeAlign(SrcAlign),
1483      unwrap(Size), IsVolatile));
1484}
1485
1486extern "C" LLVMValueRef LLVMRustBuildMemMove(LLVMBuilderRef B,
1487                                             LLVMValueRef Dst, unsigned DstAlign,
1488                                             LLVMValueRef Src, unsigned SrcAlign,
1489                                             LLVMValueRef Size, bool IsVolatile) {
1490  return wrap(unwrap(B)->CreateMemMove(
1491      unwrap(Dst), MaybeAlign(DstAlign),
1492      unwrap(Src), MaybeAlign(SrcAlign),
1493      unwrap(Size), IsVolatile));
1494}
1495
1496extern "C" LLVMValueRef LLVMRustBuildMemSet(LLVMBuilderRef B,
1497                                            LLVMValueRef Dst, unsigned DstAlign,
1498                                            LLVMValueRef Val,
1499                                            LLVMValueRef Size, bool IsVolatile) {
1500  return wrap(unwrap(B)->CreateMemSet(
1501      unwrap(Dst), unwrap(Val), unwrap(Size), MaybeAlign(DstAlign), IsVolatile));
1502}
1503
1504extern "C" LLVMValueRef
1505LLVMRustBuildInvoke(LLVMBuilderRef B, LLVMTypeRef Ty, LLVMValueRef Fn,
1506                    LLVMValueRef *Args, unsigned NumArgs,
1507                    LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch,
1508                    OperandBundleDef **OpBundles, unsigned NumOpBundles,
1509                    const char *Name) {
1510  Value *Callee = unwrap(Fn);
1511  FunctionType *FTy = unwrap<FunctionType>(Ty);
1512  return wrap(unwrap(B)->CreateInvoke(FTy, Callee, unwrap(Then), unwrap(Catch),
1513                                      ArrayRef<Value*>(unwrap(Args), NumArgs),
1514                                      ArrayRef<OperandBundleDef>(*OpBundles, NumOpBundles),
1515                                      Name));
1516}
1517
1518extern "C" void LLVMRustPositionBuilderAtStart(LLVMBuilderRef B,
1519                                               LLVMBasicBlockRef BB) {
1520  auto Point = unwrap(BB)->getFirstInsertionPt();
1521  unwrap(B)->SetInsertPoint(unwrap(BB), Point);
1522}
1523
1524extern "C" void LLVMRustSetComdat(LLVMModuleRef M, LLVMValueRef V,
1525                                  const char *Name, size_t NameLen) {
1526  Triple TargetTriple(unwrap(M)->getTargetTriple());
1527  GlobalObject *GV = unwrap<GlobalObject>(V);
1528  if (TargetTriple.supportsCOMDAT()) {
1529    StringRef NameRef(Name, NameLen);
1530    GV->setComdat(unwrap(M)->getOrInsertComdat(NameRef));
1531  }
1532}
1533
1534enum class LLVMRustLinkage {
1535  ExternalLinkage = 0,
1536  AvailableExternallyLinkage = 1,
1537  LinkOnceAnyLinkage = 2,
1538  LinkOnceODRLinkage = 3,
1539  WeakAnyLinkage = 4,
1540  WeakODRLinkage = 5,
1541  AppendingLinkage = 6,
1542  InternalLinkage = 7,
1543  PrivateLinkage = 8,
1544  ExternalWeakLinkage = 9,
1545  CommonLinkage = 10,
1546};
1547
1548static LLVMRustLinkage toRust(LLVMLinkage Linkage) {
1549  switch (Linkage) {
1550  case LLVMExternalLinkage:
1551    return LLVMRustLinkage::ExternalLinkage;
1552  case LLVMAvailableExternallyLinkage:
1553    return LLVMRustLinkage::AvailableExternallyLinkage;
1554  case LLVMLinkOnceAnyLinkage:
1555    return LLVMRustLinkage::LinkOnceAnyLinkage;
1556  case LLVMLinkOnceODRLinkage:
1557    return LLVMRustLinkage::LinkOnceODRLinkage;
1558  case LLVMWeakAnyLinkage:
1559    return LLVMRustLinkage::WeakAnyLinkage;
1560  case LLVMWeakODRLinkage:
1561    return LLVMRustLinkage::WeakODRLinkage;
1562  case LLVMAppendingLinkage:
1563    return LLVMRustLinkage::AppendingLinkage;
1564  case LLVMInternalLinkage:
1565    return LLVMRustLinkage::InternalLinkage;
1566  case LLVMPrivateLinkage:
1567    return LLVMRustLinkage::PrivateLinkage;
1568  case LLVMExternalWeakLinkage:
1569    return LLVMRustLinkage::ExternalWeakLinkage;
1570  case LLVMCommonLinkage:
1571    return LLVMRustLinkage::CommonLinkage;
1572  default:
1573    report_fatal_error("Invalid LLVMRustLinkage value!");
1574  }
1575}
1576
1577static LLVMLinkage fromRust(LLVMRustLinkage Linkage) {
1578  switch (Linkage) {
1579  case LLVMRustLinkage::ExternalLinkage:
1580    return LLVMExternalLinkage;
1581  case LLVMRustLinkage::AvailableExternallyLinkage:
1582    return LLVMAvailableExternallyLinkage;
1583  case LLVMRustLinkage::LinkOnceAnyLinkage:
1584    return LLVMLinkOnceAnyLinkage;
1585  case LLVMRustLinkage::LinkOnceODRLinkage:
1586    return LLVMLinkOnceODRLinkage;
1587  case LLVMRustLinkage::WeakAnyLinkage:
1588    return LLVMWeakAnyLinkage;
1589  case LLVMRustLinkage::WeakODRLinkage:
1590    return LLVMWeakODRLinkage;
1591  case LLVMRustLinkage::AppendingLinkage:
1592    return LLVMAppendingLinkage;
1593  case LLVMRustLinkage::InternalLinkage:
1594    return LLVMInternalLinkage;
1595  case LLVMRustLinkage::PrivateLinkage:
1596    return LLVMPrivateLinkage;
1597  case LLVMRustLinkage::ExternalWeakLinkage:
1598    return LLVMExternalWeakLinkage;
1599  case LLVMRustLinkage::CommonLinkage:
1600    return LLVMCommonLinkage;
1601  }
1602  report_fatal_error("Invalid LLVMRustLinkage value!");
1603}
1604
1605extern "C" LLVMRustLinkage LLVMRustGetLinkage(LLVMValueRef V) {
1606  return toRust(LLVMGetLinkage(V));
1607}
1608
1609extern "C" void LLVMRustSetLinkage(LLVMValueRef V,
1610                                   LLVMRustLinkage RustLinkage) {
1611  LLVMSetLinkage(V, fromRust(RustLinkage));
1612}
1613
1614extern "C" bool LLVMRustConstIntGetZExtValue(LLVMValueRef CV, uint64_t *value) {
1615    auto C = unwrap<llvm::ConstantInt>(CV);
1616    if (C->getBitWidth() > 64)
1617      return false;
1618    *value = C->getZExtValue();
1619    return true;
1620}
1621
1622// Returns true if both high and low were successfully set. Fails in case constant wasn’t any of
1623// the common sizes (1, 8, 16, 32, 64, 128 bits)
1624extern "C" bool LLVMRustConstInt128Get(LLVMValueRef CV, bool sext, uint64_t *high, uint64_t *low)
1625{
1626    auto C = unwrap<llvm::ConstantInt>(CV);
1627    if (C->getBitWidth() > 128) { return false; }
1628    APInt AP;
1629    if (sext) {
1630        AP = C->getValue().sext(128);
1631    } else {
1632        AP = C->getValue().zext(128);
1633    }
1634    *low = AP.getLoBits(64).getZExtValue();
1635    *high = AP.getHiBits(64).getZExtValue();
1636    return true;
1637}
1638
1639enum class LLVMRustVisibility {
1640  Default = 0,
1641  Hidden = 1,
1642  Protected = 2,
1643};
1644
1645static LLVMRustVisibility toRust(LLVMVisibility Vis) {
1646  switch (Vis) {
1647  case LLVMDefaultVisibility:
1648    return LLVMRustVisibility::Default;
1649  case LLVMHiddenVisibility:
1650    return LLVMRustVisibility::Hidden;
1651  case LLVMProtectedVisibility:
1652    return LLVMRustVisibility::Protected;
1653  }
1654  report_fatal_error("Invalid LLVMRustVisibility value!");
1655}
1656
1657static LLVMVisibility fromRust(LLVMRustVisibility Vis) {
1658  switch (Vis) {
1659  case LLVMRustVisibility::Default:
1660    return LLVMDefaultVisibility;
1661  case LLVMRustVisibility::Hidden:
1662    return LLVMHiddenVisibility;
1663  case LLVMRustVisibility::Protected:
1664    return LLVMProtectedVisibility;
1665  }
1666  report_fatal_error("Invalid LLVMRustVisibility value!");
1667}
1668
1669extern "C" LLVMRustVisibility LLVMRustGetVisibility(LLVMValueRef V) {
1670  return toRust(LLVMGetVisibility(V));
1671}
1672
1673extern "C" void LLVMRustSetVisibility(LLVMValueRef V,
1674                                      LLVMRustVisibility RustVisibility) {
1675  LLVMSetVisibility(V, fromRust(RustVisibility));
1676}
1677
1678extern "C" void LLVMRustSetDSOLocal(LLVMValueRef Global, bool is_dso_local) {
1679  unwrap<GlobalValue>(Global)->setDSOLocal(is_dso_local);
1680}
1681
1682struct LLVMRustModuleBuffer {
1683  std::string data;
1684};
1685
1686extern "C" LLVMRustModuleBuffer*
1687LLVMRustModuleBufferCreate(LLVMModuleRef M) {
1688  auto Ret = std::make_unique<LLVMRustModuleBuffer>();
1689  {
1690    raw_string_ostream OS(Ret->data);
1691    WriteBitcodeToFile(*unwrap(M), OS);
1692  }
1693  return Ret.release();
1694}
1695
1696extern "C" void
1697LLVMRustModuleBufferFree(LLVMRustModuleBuffer *Buffer) {
1698  delete Buffer;
1699}
1700
1701extern "C" const void*
1702LLVMRustModuleBufferPtr(const LLVMRustModuleBuffer *Buffer) {
1703  return Buffer->data.data();
1704}
1705
1706extern "C" size_t
1707LLVMRustModuleBufferLen(const LLVMRustModuleBuffer *Buffer) {
1708  return Buffer->data.length();
1709}
1710
1711extern "C" uint64_t
1712LLVMRustModuleCost(LLVMModuleRef M) {
1713  auto f = unwrap(M)->functions();
1714  return std::distance(std::begin(f), std::end(f));
1715}
1716
1717extern "C" void
1718LLVMRustModuleInstructionStats(LLVMModuleRef M, RustStringRef Str)
1719{
1720  RawRustStringOstream OS(Str);
1721  llvm::json::OStream JOS(OS);
1722  auto Module = unwrap(M);
1723
1724  JOS.object([&] {
1725    JOS.attribute("module", Module->getName());
1726    JOS.attribute("total", Module->getInstructionCount());
1727  });
1728}
1729
1730// Vector reductions:
1731extern "C" LLVMValueRef
1732LLVMRustBuildVectorReduceFAdd(LLVMBuilderRef B, LLVMValueRef Acc, LLVMValueRef Src) {
1733    return wrap(unwrap(B)->CreateFAddReduce(unwrap(Acc),unwrap(Src)));
1734}
1735extern "C" LLVMValueRef
1736LLVMRustBuildVectorReduceFMul(LLVMBuilderRef B, LLVMValueRef Acc, LLVMValueRef Src) {
1737    return wrap(unwrap(B)->CreateFMulReduce(unwrap(Acc),unwrap(Src)));
1738}
1739extern "C" LLVMValueRef
1740LLVMRustBuildVectorReduceAdd(LLVMBuilderRef B, LLVMValueRef Src) {
1741    return wrap(unwrap(B)->CreateAddReduce(unwrap(Src)));
1742}
1743extern "C" LLVMValueRef
1744LLVMRustBuildVectorReduceMul(LLVMBuilderRef B, LLVMValueRef Src) {
1745    return wrap(unwrap(B)->CreateMulReduce(unwrap(Src)));
1746}
1747extern "C" LLVMValueRef
1748LLVMRustBuildVectorReduceAnd(LLVMBuilderRef B, LLVMValueRef Src) {
1749    return wrap(unwrap(B)->CreateAndReduce(unwrap(Src)));
1750}
1751extern "C" LLVMValueRef
1752LLVMRustBuildVectorReduceOr(LLVMBuilderRef B, LLVMValueRef Src) {
1753    return wrap(unwrap(B)->CreateOrReduce(unwrap(Src)));
1754}
1755extern "C" LLVMValueRef
1756LLVMRustBuildVectorReduceXor(LLVMBuilderRef B, LLVMValueRef Src) {
1757    return wrap(unwrap(B)->CreateXorReduce(unwrap(Src)));
1758}
1759extern "C" LLVMValueRef
1760LLVMRustBuildVectorReduceMin(LLVMBuilderRef B, LLVMValueRef Src, bool IsSigned) {
1761    return wrap(unwrap(B)->CreateIntMinReduce(unwrap(Src), IsSigned));
1762}
1763extern "C" LLVMValueRef
1764LLVMRustBuildVectorReduceMax(LLVMBuilderRef B, LLVMValueRef Src, bool IsSigned) {
1765    return wrap(unwrap(B)->CreateIntMaxReduce(unwrap(Src), IsSigned));
1766}
1767extern "C" LLVMValueRef
1768LLVMRustBuildVectorReduceFMin(LLVMBuilderRef B, LLVMValueRef Src, bool NoNaN) {
1769  Instruction *I = unwrap(B)->CreateFPMinReduce(unwrap(Src));
1770  I->setHasNoNaNs(NoNaN);
1771  return wrap(I);
1772}
1773extern "C" LLVMValueRef
1774LLVMRustBuildVectorReduceFMax(LLVMBuilderRef B, LLVMValueRef Src, bool NoNaN) {
1775  Instruction *I = unwrap(B)->CreateFPMaxReduce(unwrap(Src));
1776  I->setHasNoNaNs(NoNaN);
1777  return wrap(I);
1778}
1779
1780extern "C" LLVMValueRef
1781LLVMRustBuildMinNum(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS) {
1782    return wrap(unwrap(B)->CreateMinNum(unwrap(LHS),unwrap(RHS)));
1783}
1784extern "C" LLVMValueRef
1785LLVMRustBuildMaxNum(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS) {
1786    return wrap(unwrap(B)->CreateMaxNum(unwrap(LHS),unwrap(RHS)));
1787}
1788
1789// This struct contains all necessary info about a symbol exported from a DLL.
1790struct LLVMRustCOFFShortExport {
1791  const char* name;
1792  bool ordinal_present;
1793  // The value of `ordinal` is only meaningful if `ordinal_present` is true.
1794  uint16_t ordinal;
1795};
1796
1797// Machine must be a COFF machine type, as defined in PE specs.
1798extern "C" LLVMRustResult LLVMRustWriteImportLibrary(
1799  const char* ImportName,
1800  const char* Path,
1801  const LLVMRustCOFFShortExport* Exports,
1802  size_t NumExports,
1803  uint16_t Machine,
1804  bool MinGW)
1805{
1806  std::vector<llvm::object::COFFShortExport> ConvertedExports;
1807  ConvertedExports.reserve(NumExports);
1808
1809  for (size_t i = 0; i < NumExports; ++i) {
1810    bool ordinal_present = Exports[i].ordinal_present;
1811    uint16_t ordinal = ordinal_present ? Exports[i].ordinal : 0;
1812    ConvertedExports.push_back(llvm::object::COFFShortExport{
1813      Exports[i].name,  // Name
1814      std::string{},    // ExtName
1815      std::string{},    // SymbolName
1816      std::string{},    // AliasTarget
1817      ordinal,          // Ordinal
1818      ordinal_present,  // Noname
1819      false,            // Data
1820      false,            // Private
1821      false             // Constant
1822    });
1823  }
1824
1825  auto Error = llvm::object::writeImportLibrary(
1826    ImportName,
1827    Path,
1828    ConvertedExports,
1829    static_cast<llvm::COFF::MachineTypes>(Machine),
1830    MinGW);
1831  if (Error) {
1832    std::string errorString;
1833    llvm::raw_string_ostream stream(errorString);
1834    stream << Error;
1835    stream.flush();
1836    LLVMRustSetLastError(errorString.c_str());
1837    return LLVMRustResult::Failure;
1838  } else {
1839    return LLVMRustResult::Success;
1840  }
1841}
1842
1843// Transfers ownership of DiagnosticHandler unique_ptr to the caller.
1844extern "C" DiagnosticHandler *
1845LLVMRustContextGetDiagnosticHandler(LLVMContextRef C) {
1846  std::unique_ptr<DiagnosticHandler> DH = unwrap(C)->getDiagnosticHandler();
1847  return DH.release();
1848}
1849
1850// Sets unique_ptr to object of DiagnosticHandler to provide custom diagnostic
1851// handling. Ownership of the handler is moved to the LLVMContext.
1852extern "C" void LLVMRustContextSetDiagnosticHandler(LLVMContextRef C,
1853                                                    DiagnosticHandler *DH) {
1854  unwrap(C)->setDiagnosticHandler(std::unique_ptr<DiagnosticHandler>(DH));
1855}
1856
1857using LLVMDiagnosticHandlerTy = DiagnosticHandler::DiagnosticHandlerTy;
1858
1859// Configures a diagnostic handler that invokes provided callback when a
1860// backend needs to emit a diagnostic.
1861//
1862// When RemarkAllPasses is true, remarks are enabled for all passes. Otherwise
1863// the RemarkPasses array specifies individual passes for which remarks will be
1864// enabled.
1865//
1866// If RemarkFilePath is not NULL, optimization remarks will be streamed directly into this file,
1867// bypassing the diagnostics handler.
1868extern "C" void LLVMRustContextConfigureDiagnosticHandler(
1869    LLVMContextRef C, LLVMDiagnosticHandlerTy DiagnosticHandlerCallback,
1870    void *DiagnosticHandlerContext, bool RemarkAllPasses,
1871    const char * const * RemarkPasses, size_t RemarkPassesLen,
1872    const char * RemarkFilePath,
1873    bool PGOAvailable
1874) {
1875
1876  class RustDiagnosticHandler final : public DiagnosticHandler {
1877  public:
1878    RustDiagnosticHandler(
1879      LLVMDiagnosticHandlerTy DiagnosticHandlerCallback,
1880      void *DiagnosticHandlerContext,
1881      bool RemarkAllPasses,
1882      std::vector<std::string> RemarkPasses,
1883      std::unique_ptr<ToolOutputFile> RemarksFile,
1884      std::unique_ptr<llvm::remarks::RemarkStreamer> RemarkStreamer,
1885      std::unique_ptr<LLVMRemarkStreamer> LlvmRemarkStreamer
1886    )
1887        : DiagnosticHandlerCallback(DiagnosticHandlerCallback),
1888          DiagnosticHandlerContext(DiagnosticHandlerContext),
1889          RemarkAllPasses(RemarkAllPasses),
1890          RemarkPasses(std::move(RemarkPasses)),
1891          RemarksFile(std::move(RemarksFile)),
1892          RemarkStreamer(std::move(RemarkStreamer)),
1893          LlvmRemarkStreamer(std::move(LlvmRemarkStreamer)) {}
1894
1895    virtual bool handleDiagnostics(const DiagnosticInfo &DI) override {
1896      // If this diagnostic is one of the optimization remark kinds, we can check if it's enabled
1897      // before emitting it. This can avoid many short-lived allocations when unpacking the
1898      // diagnostic and converting its various C++ strings into rust strings.
1899      // FIXME: some diagnostic infos still allocate before we get here, and avoiding that would be
1900      // good in the future. That will require changing a few call sites in LLVM.
1901      if (auto *OptDiagBase = dyn_cast<DiagnosticInfoOptimizationBase>(&DI)) {
1902        if (OptDiagBase->isEnabled()) {
1903          if (this->LlvmRemarkStreamer) {
1904            this->LlvmRemarkStreamer->emit(*OptDiagBase);
1905            return true;
1906          }
1907        } else {
1908          return true;
1909        }
1910      }
1911      if (DiagnosticHandlerCallback) {
1912        DiagnosticHandlerCallback(DI, DiagnosticHandlerContext);
1913        return true;
1914      }
1915      return false;
1916    }
1917
1918    bool isAnalysisRemarkEnabled(StringRef PassName) const override {
1919      return isRemarkEnabled(PassName);
1920    }
1921
1922    bool isMissedOptRemarkEnabled(StringRef PassName) const override {
1923      return isRemarkEnabled(PassName);
1924    }
1925
1926    bool isPassedOptRemarkEnabled(StringRef PassName) const override {
1927      return isRemarkEnabled(PassName);
1928    }
1929
1930    bool isAnyRemarkEnabled() const override {
1931      return RemarkAllPasses || !RemarkPasses.empty();
1932    }
1933
1934  private:
1935    bool isRemarkEnabled(StringRef PassName) const {
1936      if (RemarkAllPasses)
1937        return true;
1938
1939      for (auto &Pass : RemarkPasses)
1940        if (Pass == PassName)
1941          return true;
1942
1943      return false;
1944    }
1945
1946    LLVMDiagnosticHandlerTy DiagnosticHandlerCallback = nullptr;
1947    void *DiagnosticHandlerContext = nullptr;
1948
1949    bool RemarkAllPasses = false;
1950    std::vector<std::string> RemarkPasses;
1951
1952    // Since LlvmRemarkStreamer contains a pointer to RemarkStreamer, the ordering of the three
1953    // members below is important.
1954    std::unique_ptr<ToolOutputFile> RemarksFile;
1955    std::unique_ptr<llvm::remarks::RemarkStreamer> RemarkStreamer;
1956    std::unique_ptr<LLVMRemarkStreamer> LlvmRemarkStreamer;
1957  };
1958
1959  std::vector<std::string> Passes;
1960  for (size_t I = 0; I != RemarkPassesLen; ++I)
1961  {
1962    Passes.push_back(RemarkPasses[I]);
1963  }
1964
1965  // We need to hold onto both the streamers and the opened file
1966  std::unique_ptr<ToolOutputFile> RemarkFile;
1967  std::unique_ptr<llvm::remarks::RemarkStreamer> RemarkStreamer;
1968  std::unique_ptr<LLVMRemarkStreamer> LlvmRemarkStreamer;
1969
1970  if (RemarkFilePath != nullptr) {
1971    if (PGOAvailable) {
1972      // Enable PGO hotness data for remarks, if available
1973      unwrap(C)->setDiagnosticsHotnessRequested(true);
1974    }
1975
1976    std::error_code EC;
1977    RemarkFile = std::make_unique<ToolOutputFile>(
1978      RemarkFilePath,
1979      EC,
1980      llvm::sys::fs::OF_TextWithCRLF
1981    );
1982    if (EC) {
1983      std::string Error = std::string("Cannot create remark file: ") +
1984              toString(errorCodeToError(EC));
1985      report_fatal_error(Twine(Error));
1986    }
1987
1988    // Do not delete the file after we gather remarks
1989    RemarkFile->keep();
1990
1991    auto RemarkSerializer = remarks::createRemarkSerializer(
1992      llvm::remarks::Format::YAML,
1993      remarks::SerializerMode::Separate,
1994      RemarkFile->os()
1995    );
1996    if (Error E = RemarkSerializer.takeError())
1997    {
1998      std::string Error = std::string("Cannot create remark serializer: ") + toString(std::move(E));
1999      report_fatal_error(Twine(Error));
2000    }
2001    RemarkStreamer = std::make_unique<llvm::remarks::RemarkStreamer>(std::move(*RemarkSerializer));
2002    LlvmRemarkStreamer = std::make_unique<LLVMRemarkStreamer>(*RemarkStreamer);
2003  }
2004
2005  unwrap(C)->setDiagnosticHandler(std::make_unique<RustDiagnosticHandler>(
2006    DiagnosticHandlerCallback,
2007    DiagnosticHandlerContext,
2008    RemarkAllPasses,
2009    Passes,
2010    std::move(RemarkFile),
2011    std::move(RemarkStreamer),
2012    std::move(LlvmRemarkStreamer)
2013  ));
2014}
2015
2016extern "C" void LLVMRustGetMangledName(LLVMValueRef V, RustStringRef Str) {
2017  RawRustStringOstream OS(Str);
2018  GlobalValue *GV = unwrap<GlobalValue>(V);
2019  Mangler().getNameWithPrefix(OS, GV, true);
2020}
2021
2022extern "C" int32_t LLVMRustGetElementTypeArgIndex(LLVMValueRef CallSite) {
2023    auto *CB = unwrap<CallBase>(CallSite);
2024    switch (CB->getIntrinsicID()) {
2025        case Intrinsic::arm_ldrex:
2026            return 0;
2027        case Intrinsic::arm_strex:
2028            return 1;
2029    }
2030    return -1;
2031}
2032
2033extern "C" bool LLVMRustIsBitcode(char *ptr, size_t len) {
2034  return identify_magic(StringRef(ptr, len)) == file_magic::bitcode;
2035}
2036
2037extern "C" bool LLVMRustIsNonGVFunctionPointerTy(LLVMValueRef V) {
2038  if (unwrap<Value>(V)->getType()->isPointerTy()) {
2039    if (auto *GV = dyn_cast<GlobalValue>(unwrap<Value>(V))) {
2040      if (GV->getValueType()->isFunctionTy())
2041        return false;
2042    }
2043    return true;
2044  }
2045  return false;
2046}
2047
2048extern "C" bool LLVMRustLLVMHasZlibCompressionForDebugSymbols() {
2049#if LLVM_VERSION_GE(16, 0)
2050  return llvm::compression::zlib::isAvailable();
2051#else
2052  return false;
2053#endif
2054}
2055
2056extern "C" bool LLVMRustLLVMHasZstdCompressionForDebugSymbols() {
2057#if LLVM_VERSION_GE(16, 0)
2058  return llvm::compression::zstd::isAvailable();
2059#else
2060  return false;
2061#endif
2062}