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