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