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