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, unsigned ID,
2556 LLVMTypeRef *OverloadTypes,
2557 size_t OverloadCount) {
2558 ArrayRef<Type *> OverloadTys(unwrap(Tys: OverloadTypes), OverloadCount);
2559 auto IID = llvm_map_to_intrinsic_id(ID);
2560 return wrap(
2561 P: llvm::Intrinsic::getOrInsertDeclaration(M: unwrap(P: Mod), id: IID, OverloadTys));
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 *OverloadTypes,
2573 size_t OverloadCount) {
2574 auto IID = llvm_map_to_intrinsic_id(ID);
2575 ArrayRef<Type *> OverloadTys(unwrap(Tys: OverloadTypes), OverloadCount);
2576 return wrap(P: llvm::Intrinsic::getType(Context&: *unwrap(P: Ctx), id: IID, OverloadTys));
2577}
2578
2579char *LLVMIntrinsicCopyOverloadedName(unsigned ID, LLVMTypeRef *OverloadTypes,
2580 size_t OverloadCount,
2581 size_t *NameLength) {
2582 auto IID = llvm_map_to_intrinsic_id(ID);
2583 ArrayRef<Type *> OverloadTys(unwrap(Tys: OverloadTypes), OverloadCount);
2584 auto Str = llvm::Intrinsic::getNameNoUnnamedTypes(Id: IID, OverloadTys);
2585 *NameLength = Str.length();
2586 return strdup(s: Str.c_str());
2587}
2588
2589char *LLVMIntrinsicCopyOverloadedName2(LLVMModuleRef Mod, unsigned ID,
2590 LLVMTypeRef *OverloadTypes,
2591 size_t OverloadCount,
2592 size_t *NameLength) {
2593 auto IID = llvm_map_to_intrinsic_id(ID);
2594 ArrayRef<Type *> OverloadTys(unwrap(Tys: OverloadTypes), OverloadCount);
2595 auto Str = llvm::Intrinsic::getName(Id: IID, OverloadTys, M: unwrap(P: Mod));
2596 *NameLength = Str.length();
2597 return strdup(s: Str.c_str());
2598}
2599
2600unsigned LLVMLookupIntrinsicID(const char *Name, size_t NameLen) {
2601 return Intrinsic::lookupIntrinsicID(Name: {Name, NameLen});
2602}
2603
2604LLVMBool LLVMIntrinsicIsOverloaded(unsigned ID) {
2605 auto IID = llvm_map_to_intrinsic_id(ID);
2606 return llvm::Intrinsic::isOverloaded(id: IID);
2607}
2608
2609unsigned LLVMGetFunctionCallConv(LLVMValueRef Fn) {
2610 return unwrap<Function>(P: Fn)->getCallingConv();
2611}
2612
2613void LLVMSetFunctionCallConv(LLVMValueRef Fn, unsigned CC) {
2614 return unwrap<Function>(P: Fn)->setCallingConv(
2615 static_cast<CallingConv::ID>(CC));
2616}
2617
2618const char *LLVMGetGC(LLVMValueRef Fn) {
2619 Function *F = unwrap<Function>(P: Fn);
2620 return F->hasGC()? F->getGC().c_str() : nullptr;
2621}
2622
2623void LLVMSetGC(LLVMValueRef Fn, const char *GC) {
2624 Function *F = unwrap<Function>(P: Fn);
2625 if (GC)
2626 F->setGC(GC);
2627 else
2628 F->clearGC();
2629}
2630
2631LLVMValueRef LLVMGetPrefixData(LLVMValueRef Fn) {
2632 Function *F = unwrap<Function>(P: Fn);
2633 return wrap(P: F->getPrefixData());
2634}
2635
2636LLVMBool LLVMHasPrefixData(LLVMValueRef Fn) {
2637 Function *F = unwrap<Function>(P: Fn);
2638 return F->hasPrefixData();
2639}
2640
2641void LLVMSetPrefixData(LLVMValueRef Fn, LLVMValueRef prefixData) {
2642 Function *F = unwrap<Function>(P: Fn);
2643 Constant *prefix = unwrap<Constant>(P: prefixData);
2644 F->setPrefixData(prefix);
2645}
2646
2647LLVMValueRef LLVMGetPrologueData(LLVMValueRef Fn) {
2648 Function *F = unwrap<Function>(P: Fn);
2649 return wrap(P: F->getPrologueData());
2650}
2651
2652LLVMBool LLVMHasPrologueData(LLVMValueRef Fn) {
2653 Function *F = unwrap<Function>(P: Fn);
2654 return F->hasPrologueData();
2655}
2656
2657void LLVMSetPrologueData(LLVMValueRef Fn, LLVMValueRef prologueData) {
2658 Function *F = unwrap<Function>(P: Fn);
2659 Constant *prologue = unwrap<Constant>(P: prologueData);
2660 F->setPrologueData(prologue);
2661}
2662
2663void LLVMAddAttributeAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx,
2664 LLVMAttributeRef A) {
2665 unwrap<Function>(P: F)->addAttributeAtIndex(i: Idx, Attr: unwrap(Attr: A));
2666}
2667
2668unsigned LLVMGetAttributeCountAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx) {
2669 auto AS = unwrap<Function>(P: F)->getAttributes().getAttributes(Index: Idx);
2670 return AS.getNumAttributes();
2671}
2672
2673void LLVMGetAttributesAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx,
2674 LLVMAttributeRef *Attrs) {
2675 auto AS = unwrap<Function>(P: F)->getAttributes().getAttributes(Index: Idx);
2676 for (auto A : AS)
2677 *Attrs++ = wrap(Attr: A);
2678}
2679
2680LLVMAttributeRef LLVMGetEnumAttributeAtIndex(LLVMValueRef F,
2681 LLVMAttributeIndex Idx,
2682 unsigned KindID) {
2683 return wrap(Attr: unwrap<Function>(P: F)->getAttributeAtIndex(
2684 i: Idx, Kind: (Attribute::AttrKind)KindID));
2685}
2686
2687LLVMAttributeRef LLVMGetStringAttributeAtIndex(LLVMValueRef F,
2688 LLVMAttributeIndex Idx,
2689 const char *K, unsigned KLen) {
2690 return wrap(
2691 Attr: unwrap<Function>(P: F)->getAttributeAtIndex(i: Idx, Kind: StringRef(K, KLen)));
2692}
2693
2694void LLVMRemoveEnumAttributeAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx,
2695 unsigned KindID) {
2696 unwrap<Function>(P: F)->removeAttributeAtIndex(i: Idx, Kind: (Attribute::AttrKind)KindID);
2697}
2698
2699void LLVMRemoveStringAttributeAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx,
2700 const char *K, unsigned KLen) {
2701 unwrap<Function>(P: F)->removeAttributeAtIndex(i: Idx, Kind: StringRef(K, KLen));
2702}
2703
2704void LLVMAddTargetDependentFunctionAttr(LLVMValueRef Fn, const char *A,
2705 const char *V) {
2706 Function *Func = unwrap<Function>(P: Fn);
2707 Attribute Attr = Attribute::get(Context&: Func->getContext(), Kind: A, Val: V);
2708 Func->addFnAttr(Attr);
2709}
2710
2711/*--.. Operations on parameters ............................................--*/
2712
2713unsigned LLVMCountParams(LLVMValueRef FnRef) {
2714 // This function is strictly redundant to
2715 // LLVMCountParamTypes(LLVMGlobalGetValueType(FnRef))
2716 return unwrap<Function>(P: FnRef)->arg_size();
2717}
2718
2719void LLVMGetParams(LLVMValueRef FnRef, LLVMValueRef *ParamRefs) {
2720 Function *Fn = unwrap<Function>(P: FnRef);
2721 for (Argument &A : Fn->args())
2722 *ParamRefs++ = wrap(P: &A);
2723}
2724
2725LLVMValueRef LLVMGetParam(LLVMValueRef FnRef, unsigned index) {
2726 Function *Fn = unwrap<Function>(P: FnRef);
2727 return wrap(P: &Fn->arg_begin()[index]);
2728}
2729
2730LLVMValueRef LLVMGetParamParent(LLVMValueRef V) {
2731 return wrap(P: unwrap<Argument>(P: V)->getParent());
2732}
2733
2734LLVMValueRef LLVMGetFirstParam(LLVMValueRef Fn) {
2735 Function *Func = unwrap<Function>(P: Fn);
2736 Function::arg_iterator I = Func->arg_begin();
2737 if (I == Func->arg_end())
2738 return nullptr;
2739 return wrap(P: &*I);
2740}
2741
2742LLVMValueRef LLVMGetLastParam(LLVMValueRef Fn) {
2743 Function *Func = unwrap<Function>(P: Fn);
2744 Function::arg_iterator I = Func->arg_end();
2745 if (I == Func->arg_begin())
2746 return nullptr;
2747 return wrap(P: &*--I);
2748}
2749
2750LLVMValueRef LLVMGetNextParam(LLVMValueRef Arg) {
2751 Argument *A = unwrap<Argument>(P: Arg);
2752 Function *Fn = A->getParent();
2753 if (A->getArgNo() + 1 >= Fn->arg_size())
2754 return nullptr;
2755 return wrap(P: &Fn->arg_begin()[A->getArgNo() + 1]);
2756}
2757
2758LLVMValueRef LLVMGetPreviousParam(LLVMValueRef Arg) {
2759 Argument *A = unwrap<Argument>(P: Arg);
2760 if (A->getArgNo() == 0)
2761 return nullptr;
2762 return wrap(P: &A->getParent()->arg_begin()[A->getArgNo() - 1]);
2763}
2764
2765void LLVMSetParamAlignment(LLVMValueRef Arg, unsigned align) {
2766 Argument *A = unwrap<Argument>(P: Arg);
2767 A->addAttr(Attr: Attribute::getWithAlignment(Context&: A->getContext(), Alignment: Align(align)));
2768}
2769
2770/*--.. Operations on ifuncs ................................................--*/
2771
2772LLVMValueRef LLVMAddGlobalIFunc(LLVMModuleRef M,
2773 const char *Name, size_t NameLen,
2774 LLVMTypeRef Ty, unsigned AddrSpace,
2775 LLVMValueRef Resolver) {
2776 return wrap(P: GlobalIFunc::create(Ty: unwrap(P: Ty), AddressSpace: AddrSpace,
2777 Linkage: GlobalValue::ExternalLinkage,
2778 Name: StringRef(Name, NameLen),
2779 Resolver: unwrap<Constant>(P: Resolver), Parent: unwrap(P: M)));
2780}
2781
2782LLVMValueRef LLVMGetNamedGlobalIFunc(LLVMModuleRef M,
2783 const char *Name, size_t NameLen) {
2784 return wrap(P: unwrap(P: M)->getNamedIFunc(Name: StringRef(Name, NameLen)));
2785}
2786
2787LLVMValueRef LLVMGetFirstGlobalIFunc(LLVMModuleRef M) {
2788 Module *Mod = unwrap(P: M);
2789 Module::ifunc_iterator I = Mod->ifunc_begin();
2790 if (I == Mod->ifunc_end())
2791 return nullptr;
2792 return wrap(P: &*I);
2793}
2794
2795LLVMValueRef LLVMGetLastGlobalIFunc(LLVMModuleRef M) {
2796 Module *Mod = unwrap(P: M);
2797 Module::ifunc_iterator I = Mod->ifunc_end();
2798 if (I == Mod->ifunc_begin())
2799 return nullptr;
2800 return wrap(P: &*--I);
2801}
2802
2803LLVMValueRef LLVMGetNextGlobalIFunc(LLVMValueRef IFunc) {
2804 GlobalIFunc *GIF = unwrap<GlobalIFunc>(P: IFunc);
2805 Module::ifunc_iterator I(GIF);
2806 if (++I == GIF->getParent()->ifunc_end())
2807 return nullptr;
2808 return wrap(P: &*I);
2809}
2810
2811LLVMValueRef LLVMGetPreviousGlobalIFunc(LLVMValueRef IFunc) {
2812 GlobalIFunc *GIF = unwrap<GlobalIFunc>(P: IFunc);
2813 Module::ifunc_iterator I(GIF);
2814 if (I == GIF->getParent()->ifunc_begin())
2815 return nullptr;
2816 return wrap(P: &*--I);
2817}
2818
2819LLVMValueRef LLVMGetGlobalIFuncResolver(LLVMValueRef IFunc) {
2820 return wrap(P: unwrap<GlobalIFunc>(P: IFunc)->getResolver());
2821}
2822
2823void LLVMSetGlobalIFuncResolver(LLVMValueRef IFunc, LLVMValueRef Resolver) {
2824 unwrap<GlobalIFunc>(P: IFunc)->setResolver(unwrap<Constant>(P: Resolver));
2825}
2826
2827void LLVMEraseGlobalIFunc(LLVMValueRef IFunc) {
2828 unwrap<GlobalIFunc>(P: IFunc)->eraseFromParent();
2829}
2830
2831void LLVMRemoveGlobalIFunc(LLVMValueRef IFunc) {
2832 unwrap<GlobalIFunc>(P: IFunc)->removeFromParent();
2833}
2834
2835/*--.. Operations on operand bundles........................................--*/
2836
2837LLVMOperandBundleRef LLVMCreateOperandBundle(const char *Tag, size_t TagLen,
2838 LLVMValueRef *Args,
2839 unsigned NumArgs) {
2840 return wrap(P: new OperandBundleDef(std::string(Tag, TagLen),
2841 ArrayRef(unwrap(Vals: Args), NumArgs)));
2842}
2843
2844void LLVMDisposeOperandBundle(LLVMOperandBundleRef Bundle) {
2845 delete unwrap(P: Bundle);
2846}
2847
2848const char *LLVMGetOperandBundleTag(LLVMOperandBundleRef Bundle, size_t *Len) {
2849 StringRef Str = unwrap(P: Bundle)->getTag();
2850 *Len = Str.size();
2851 return Str.data();
2852}
2853
2854unsigned LLVMGetNumOperandBundleArgs(LLVMOperandBundleRef Bundle) {
2855 return unwrap(P: Bundle)->inputs().size();
2856}
2857
2858LLVMValueRef LLVMGetOperandBundleArgAtIndex(LLVMOperandBundleRef Bundle,
2859 unsigned Index) {
2860 return wrap(P: unwrap(P: Bundle)->inputs()[Index]);
2861}
2862
2863/*--.. Operations on basic blocks ..........................................--*/
2864
2865LLVMValueRef LLVMBasicBlockAsValue(LLVMBasicBlockRef BB) {
2866 return wrap(P: static_cast<Value*>(unwrap(P: BB)));
2867}
2868
2869LLVMBool LLVMValueIsBasicBlock(LLVMValueRef Val) {
2870 return isa<BasicBlock>(Val: unwrap(P: Val));
2871}
2872
2873LLVMBasicBlockRef LLVMValueAsBasicBlock(LLVMValueRef Val) {
2874 return wrap(P: unwrap<BasicBlock>(P: Val));
2875}
2876
2877const char *LLVMGetBasicBlockName(LLVMBasicBlockRef BB) {
2878 return unwrap(P: BB)->getName().data();
2879}
2880
2881LLVMValueRef LLVMGetBasicBlockParent(LLVMBasicBlockRef BB) {
2882 return wrap(P: unwrap(P: BB)->getParent());
2883}
2884
2885LLVMValueRef LLVMGetBasicBlockTerminator(LLVMBasicBlockRef BB) {
2886 return wrap(P: unwrap(P: BB)->getTerminatorOrNull());
2887}
2888
2889unsigned LLVMCountBasicBlocks(LLVMValueRef FnRef) {
2890 return unwrap<Function>(P: FnRef)->size();
2891}
2892
2893void LLVMGetBasicBlocks(LLVMValueRef FnRef, LLVMBasicBlockRef *BasicBlocksRefs){
2894 Function *Fn = unwrap<Function>(P: FnRef);
2895 for (BasicBlock &BB : *Fn)
2896 *BasicBlocksRefs++ = wrap(P: &BB);
2897}
2898
2899LLVMBasicBlockRef LLVMGetEntryBasicBlock(LLVMValueRef Fn) {
2900 return wrap(P: &unwrap<Function>(P: Fn)->getEntryBlock());
2901}
2902
2903LLVMBasicBlockRef LLVMGetFirstBasicBlock(LLVMValueRef Fn) {
2904 Function *Func = unwrap<Function>(P: Fn);
2905 Function::iterator I = Func->begin();
2906 if (I == Func->end())
2907 return nullptr;
2908 return wrap(P: &*I);
2909}
2910
2911LLVMBasicBlockRef LLVMGetLastBasicBlock(LLVMValueRef Fn) {
2912 Function *Func = unwrap<Function>(P: Fn);
2913 Function::iterator I = Func->end();
2914 if (I == Func->begin())
2915 return nullptr;
2916 return wrap(P: &*--I);
2917}
2918
2919LLVMBasicBlockRef LLVMGetNextBasicBlock(LLVMBasicBlockRef BB) {
2920 BasicBlock *Block = unwrap(P: BB);
2921 Function::iterator I(Block);
2922 if (++I == Block->getParent()->end())
2923 return nullptr;
2924 return wrap(P: &*I);
2925}
2926
2927LLVMBasicBlockRef LLVMGetPreviousBasicBlock(LLVMBasicBlockRef BB) {
2928 BasicBlock *Block = unwrap(P: BB);
2929 Function::iterator I(Block);
2930 if (I == Block->getParent()->begin())
2931 return nullptr;
2932 return wrap(P: &*--I);
2933}
2934
2935LLVMBasicBlockRef LLVMCreateBasicBlockInContext(LLVMContextRef C,
2936 const char *Name) {
2937 return wrap(P: llvm::BasicBlock::Create(Context&: *unwrap(P: C), Name));
2938}
2939
2940void LLVMInsertExistingBasicBlockAfterInsertBlock(LLVMBuilderRef Builder,
2941 LLVMBasicBlockRef BB) {
2942 BasicBlock *ToInsert = unwrap(P: BB);
2943 BasicBlock *CurBB = unwrap(P: Builder)->GetInsertBlock();
2944 assert(CurBB && "current insertion point is invalid!");
2945 CurBB->getParent()->insert(Position: std::next(x: CurBB->getIterator()), BB: ToInsert);
2946}
2947
2948void LLVMAppendExistingBasicBlock(LLVMValueRef Fn,
2949 LLVMBasicBlockRef BB) {
2950 unwrap<Function>(P: Fn)->insert(Position: unwrap<Function>(P: Fn)->end(), BB: unwrap(P: BB));
2951}
2952
2953LLVMBasicBlockRef LLVMAppendBasicBlockInContext(LLVMContextRef C,
2954 LLVMValueRef FnRef,
2955 const char *Name) {
2956 return wrap(P: BasicBlock::Create(Context&: *unwrap(P: C), Name, Parent: unwrap<Function>(P: FnRef)));
2957}
2958
2959LLVMBasicBlockRef LLVMAppendBasicBlock(LLVMValueRef FnRef, const char *Name) {
2960 return LLVMAppendBasicBlockInContext(C: getGlobalContextForCAPI(), FnRef, Name);
2961}
2962
2963LLVMBasicBlockRef LLVMInsertBasicBlockInContext(LLVMContextRef C,
2964 LLVMBasicBlockRef BBRef,
2965 const char *Name) {
2966 BasicBlock *BB = unwrap(P: BBRef);
2967 return wrap(P: BasicBlock::Create(Context&: *unwrap(P: C), Name, Parent: BB->getParent(), InsertBefore: BB));
2968}
2969
2970LLVMBasicBlockRef LLVMInsertBasicBlock(LLVMBasicBlockRef BBRef,
2971 const char *Name) {
2972 return LLVMInsertBasicBlockInContext(C: getGlobalContextForCAPI(), BBRef, Name);
2973}
2974
2975void LLVMDeleteBasicBlock(LLVMBasicBlockRef BBRef) {
2976 unwrap(P: BBRef)->eraseFromParent();
2977}
2978
2979void LLVMRemoveBasicBlockFromParent(LLVMBasicBlockRef BBRef) {
2980 unwrap(P: BBRef)->removeFromParent();
2981}
2982
2983void LLVMMoveBasicBlockBefore(LLVMBasicBlockRef BB, LLVMBasicBlockRef MovePos) {
2984 unwrap(P: BB)->moveBefore(MovePos: unwrap(P: MovePos));
2985}
2986
2987void LLVMMoveBasicBlockAfter(LLVMBasicBlockRef BB, LLVMBasicBlockRef MovePos) {
2988 unwrap(P: BB)->moveAfter(MovePos: unwrap(P: MovePos));
2989}
2990
2991/*--.. Operations on instructions ..........................................--*/
2992
2993LLVMBasicBlockRef LLVMGetInstructionParent(LLVMValueRef Inst) {
2994 return wrap(P: unwrap<Instruction>(P: Inst)->getParent());
2995}
2996
2997LLVMValueRef LLVMGetFirstInstruction(LLVMBasicBlockRef BB) {
2998 BasicBlock *Block = unwrap(P: BB);
2999 BasicBlock::iterator I = Block->begin();
3000 if (I == Block->end())
3001 return nullptr;
3002 return wrap(P: &*I);
3003}
3004
3005LLVMValueRef LLVMGetLastInstruction(LLVMBasicBlockRef BB) {
3006 BasicBlock *Block = unwrap(P: BB);
3007 BasicBlock::iterator I = Block->end();
3008 if (I == Block->begin())
3009 return nullptr;
3010 return wrap(P: &*--I);
3011}
3012
3013LLVMValueRef LLVMGetNextInstruction(LLVMValueRef Inst) {
3014 Instruction *Instr = unwrap<Instruction>(P: Inst);
3015 BasicBlock::iterator I(Instr);
3016 if (++I == Instr->getParent()->end())
3017 return nullptr;
3018 return wrap(P: &*I);
3019}
3020
3021LLVMValueRef LLVMGetPreviousInstruction(LLVMValueRef Inst) {
3022 Instruction *Instr = unwrap<Instruction>(P: Inst);
3023 BasicBlock::iterator I(Instr);
3024 if (I == Instr->getParent()->begin())
3025 return nullptr;
3026 return wrap(P: &*--I);
3027}
3028
3029void LLVMInstructionRemoveFromParent(LLVMValueRef Inst) {
3030 unwrap<Instruction>(P: Inst)->removeFromParent();
3031}
3032
3033void LLVMInstructionEraseFromParent(LLVMValueRef Inst) {
3034 unwrap<Instruction>(P: Inst)->eraseFromParent();
3035}
3036
3037void LLVMDeleteInstruction(LLVMValueRef Inst) {
3038 unwrap<Instruction>(P: Inst)->deleteValue();
3039}
3040
3041LLVMIntPredicate LLVMGetICmpPredicate(LLVMValueRef Inst) {
3042 if (ICmpInst *I = dyn_cast<ICmpInst>(Val: unwrap(P: Inst)))
3043 return (LLVMIntPredicate)I->getPredicate();
3044 return (LLVMIntPredicate)0;
3045}
3046
3047LLVMBool LLVMGetICmpSameSign(LLVMValueRef Inst) {
3048 return unwrap<ICmpInst>(P: Inst)->hasSameSign();
3049}
3050
3051void LLVMSetICmpSameSign(LLVMValueRef Inst, LLVMBool SameSign) {
3052 unwrap<ICmpInst>(P: Inst)->setSameSign(SameSign);
3053}
3054
3055LLVMRealPredicate LLVMGetFCmpPredicate(LLVMValueRef Inst) {
3056 if (FCmpInst *I = dyn_cast<FCmpInst>(Val: unwrap(P: Inst)))
3057 return (LLVMRealPredicate)I->getPredicate();
3058 return (LLVMRealPredicate)0;
3059}
3060
3061LLVMOpcode LLVMGetInstructionOpcode(LLVMValueRef Inst) {
3062 if (Instruction *C = dyn_cast<Instruction>(Val: unwrap(P: Inst)))
3063 return map_to_llvmopcode(opcode: C->getOpcode());
3064 return (LLVMOpcode)0;
3065}
3066
3067LLVMValueRef LLVMInstructionClone(LLVMValueRef Inst) {
3068 if (Instruction *C = dyn_cast<Instruction>(Val: unwrap(P: Inst)))
3069 return wrap(P: C->clone());
3070 return nullptr;
3071}
3072
3073LLVMValueRef LLVMIsATerminatorInst(LLVMValueRef Inst) {
3074 Instruction *I = dyn_cast<Instruction>(Val: unwrap(P: Inst));
3075 return (I && I->isTerminator()) ? wrap(P: I) : nullptr;
3076}
3077
3078LLVMDbgRecordRef LLVMGetFirstDbgRecord(LLVMValueRef Inst) {
3079 Instruction *Instr = unwrap<Instruction>(P: Inst);
3080 if (!Instr->DebugMarker)
3081 return nullptr;
3082 auto I = Instr->DebugMarker->StoredDbgRecords.begin();
3083 if (I == Instr->DebugMarker->StoredDbgRecords.end())
3084 return nullptr;
3085 return wrap(P: &*I);
3086}
3087
3088LLVMDbgRecordRef LLVMGetLastDbgRecord(LLVMValueRef Inst) {
3089 Instruction *Instr = unwrap<Instruction>(P: Inst);
3090 if (!Instr->DebugMarker)
3091 return nullptr;
3092 auto I = Instr->DebugMarker->StoredDbgRecords.rbegin();
3093 if (I == Instr->DebugMarker->StoredDbgRecords.rend())
3094 return nullptr;
3095 return wrap(P: &*I);
3096}
3097
3098LLVMDbgRecordRef LLVMGetNextDbgRecord(LLVMDbgRecordRef Rec) {
3099 DbgRecord *Record = unwrap<DbgRecord>(P: Rec);
3100 simple_ilist<DbgRecord>::iterator I(Record);
3101 if (++I == Record->getInstruction()->DebugMarker->StoredDbgRecords.end())
3102 return nullptr;
3103 return wrap(P: &*I);
3104}
3105
3106LLVMDbgRecordRef LLVMGetPreviousDbgRecord(LLVMDbgRecordRef Rec) {
3107 DbgRecord *Record = unwrap<DbgRecord>(P: Rec);
3108 simple_ilist<DbgRecord>::iterator I(Record);
3109 if (I == Record->getInstruction()->DebugMarker->StoredDbgRecords.begin())
3110 return nullptr;
3111 return wrap(P: &*--I);
3112}
3113
3114LLVMMetadataRef LLVMDbgRecordGetDebugLoc(LLVMDbgRecordRef Rec) {
3115 return wrap(P: unwrap<DbgRecord>(P: Rec)->getDebugLoc().getAsMDNode());
3116}
3117
3118LLVMDbgRecordKind LLVMDbgRecordGetKind(LLVMDbgRecordRef Rec) {
3119 DbgRecord *Record = unwrap<DbgRecord>(P: Rec);
3120 if (isa<DbgLabelRecord>(Val: Record))
3121 return LLVMDbgRecordLabel;
3122 DbgVariableRecord *VariableRecord = dyn_cast<DbgVariableRecord>(Val: Record);
3123 assert(VariableRecord && "unexpected record");
3124 if (VariableRecord->isDbgDeclare())
3125 return LLVMDbgRecordDeclare;
3126 if (VariableRecord->isDbgValue())
3127 return LLVMDbgRecordValue;
3128 assert(VariableRecord->isDbgAssign() && "unexpected record");
3129 return LLVMDbgRecordAssign;
3130}
3131
3132LLVMValueRef LLVMDbgVariableRecordGetValue(LLVMDbgRecordRef Rec,
3133 unsigned OpIdx) {
3134 return wrap(P: unwrap<DbgVariableRecord>(P: Rec)->getValue(OpIdx));
3135}
3136
3137LLVMMetadataRef LLVMDbgVariableRecordGetVariable(LLVMDbgRecordRef Rec) {
3138 return wrap(P: unwrap<DbgVariableRecord>(P: Rec)->getRawVariable());
3139}
3140
3141LLVMMetadataRef LLVMDbgVariableRecordGetExpression(LLVMDbgRecordRef Rec) {
3142 return wrap(P: unwrap<DbgVariableRecord>(P: Rec)->getRawExpression());
3143}
3144
3145unsigned LLVMGetNumArgOperands(LLVMValueRef Instr) {
3146 if (FuncletPadInst *FPI = dyn_cast<FuncletPadInst>(Val: unwrap(P: Instr))) {
3147 return FPI->arg_size();
3148 }
3149 return unwrap<CallBase>(P: Instr)->arg_size();
3150}
3151
3152/*--.. Call and invoke instructions ........................................--*/
3153
3154unsigned LLVMGetInstructionCallConv(LLVMValueRef Instr) {
3155 return unwrap<CallBase>(P: Instr)->getCallingConv();
3156}
3157
3158void LLVMSetInstructionCallConv(LLVMValueRef Instr, unsigned CC) {
3159 return unwrap<CallBase>(P: Instr)->setCallingConv(
3160 static_cast<CallingConv::ID>(CC));
3161}
3162
3163void LLVMSetInstrParamAlignment(LLVMValueRef Instr, LLVMAttributeIndex Idx,
3164 unsigned align) {
3165 auto *Call = unwrap<CallBase>(P: Instr);
3166 Attribute AlignAttr =
3167 Attribute::getWithAlignment(Context&: Call->getContext(), Alignment: Align(align));
3168 Call->addAttributeAtIndex(i: Idx, Attr: AlignAttr);
3169}
3170
3171void LLVMAddCallSiteAttribute(LLVMValueRef C, LLVMAttributeIndex Idx,
3172 LLVMAttributeRef A) {
3173 unwrap<CallBase>(P: C)->addAttributeAtIndex(i: Idx, Attr: unwrap(Attr: A));
3174}
3175
3176unsigned LLVMGetCallSiteAttributeCount(LLVMValueRef C,
3177 LLVMAttributeIndex Idx) {
3178 auto *Call = unwrap<CallBase>(P: C);
3179 auto AS = Call->getAttributes().getAttributes(Index: Idx);
3180 return AS.getNumAttributes();
3181}
3182
3183void LLVMGetCallSiteAttributes(LLVMValueRef C, LLVMAttributeIndex Idx,
3184 LLVMAttributeRef *Attrs) {
3185 auto *Call = unwrap<CallBase>(P: C);
3186 auto AS = Call->getAttributes().getAttributes(Index: Idx);
3187 for (auto A : AS)
3188 *Attrs++ = wrap(Attr: A);
3189}
3190
3191LLVMAttributeRef LLVMGetCallSiteEnumAttribute(LLVMValueRef C,
3192 LLVMAttributeIndex Idx,
3193 unsigned KindID) {
3194 return wrap(Attr: unwrap<CallBase>(P: C)->getAttributeAtIndex(
3195 i: Idx, Kind: (Attribute::AttrKind)KindID));
3196}
3197
3198LLVMAttributeRef LLVMGetCallSiteStringAttribute(LLVMValueRef C,
3199 LLVMAttributeIndex Idx,
3200 const char *K, unsigned KLen) {
3201 return wrap(
3202 Attr: unwrap<CallBase>(P: C)->getAttributeAtIndex(i: Idx, Kind: StringRef(K, KLen)));
3203}
3204
3205void LLVMRemoveCallSiteEnumAttribute(LLVMValueRef C, LLVMAttributeIndex Idx,
3206 unsigned KindID) {
3207 unwrap<CallBase>(P: C)->removeAttributeAtIndex(i: Idx, Kind: (Attribute::AttrKind)KindID);
3208}
3209
3210void LLVMRemoveCallSiteStringAttribute(LLVMValueRef C, LLVMAttributeIndex Idx,
3211 const char *K, unsigned KLen) {
3212 unwrap<CallBase>(P: C)->removeAttributeAtIndex(i: Idx, Kind: StringRef(K, KLen));
3213}
3214
3215LLVMValueRef LLVMGetCalledValue(LLVMValueRef Instr) {
3216 return wrap(P: unwrap<CallBase>(P: Instr)->getCalledOperand());
3217}
3218
3219LLVMTypeRef LLVMGetCalledFunctionType(LLVMValueRef Instr) {
3220 return wrap(P: unwrap<CallBase>(P: Instr)->getFunctionType());
3221}
3222
3223unsigned LLVMGetNumOperandBundles(LLVMValueRef C) {
3224 return unwrap<CallBase>(P: C)->getNumOperandBundles();
3225}
3226
3227LLVMOperandBundleRef LLVMGetOperandBundleAtIndex(LLVMValueRef C,
3228 unsigned Index) {
3229 return wrap(
3230 P: new OperandBundleDef(unwrap<CallBase>(P: C)->getOperandBundleAt(Index)));
3231}
3232
3233/*--.. Operations on call instructions (only) ..............................--*/
3234
3235LLVMBool LLVMIsTailCall(LLVMValueRef Call) {
3236 return unwrap<CallInst>(P: Call)->isTailCall();
3237}
3238
3239void LLVMSetTailCall(LLVMValueRef Call, LLVMBool isTailCall) {
3240 unwrap<CallInst>(P: Call)->setTailCall(isTailCall);
3241}
3242
3243LLVMTailCallKind LLVMGetTailCallKind(LLVMValueRef Call) {
3244 return (LLVMTailCallKind)unwrap<CallInst>(P: Call)->getTailCallKind();
3245}
3246
3247void LLVMSetTailCallKind(LLVMValueRef Call, LLVMTailCallKind kind) {
3248 unwrap<CallInst>(P: Call)->setTailCallKind((CallInst::TailCallKind)kind);
3249}
3250
3251/*--.. Operations on invoke instructions (only) ............................--*/
3252
3253LLVMBasicBlockRef LLVMGetNormalDest(LLVMValueRef Invoke) {
3254 return wrap(P: unwrap<InvokeInst>(P: Invoke)->getNormalDest());
3255}
3256
3257LLVMBasicBlockRef LLVMGetUnwindDest(LLVMValueRef Invoke) {
3258 if (CleanupReturnInst *CRI = dyn_cast<CleanupReturnInst>(Val: unwrap(P: Invoke))) {
3259 return wrap(P: CRI->getUnwindDest());
3260 } else if (CatchSwitchInst *CSI = dyn_cast<CatchSwitchInst>(Val: unwrap(P: Invoke))) {
3261 return wrap(P: CSI->getUnwindDest());
3262 }
3263 return wrap(P: unwrap<InvokeInst>(P: Invoke)->getUnwindDest());
3264}
3265
3266void LLVMSetNormalDest(LLVMValueRef Invoke, LLVMBasicBlockRef B) {
3267 unwrap<InvokeInst>(P: Invoke)->setNormalDest(unwrap(P: B));
3268}
3269
3270void LLVMSetUnwindDest(LLVMValueRef Invoke, LLVMBasicBlockRef B) {
3271 if (CleanupReturnInst *CRI = dyn_cast<CleanupReturnInst>(Val: unwrap(P: Invoke))) {
3272 return CRI->setUnwindDest(unwrap(P: B));
3273 } else if (CatchSwitchInst *CSI = dyn_cast<CatchSwitchInst>(Val: unwrap(P: Invoke))) {
3274 return CSI->setUnwindDest(unwrap(P: B));
3275 }
3276 unwrap<InvokeInst>(P: Invoke)->setUnwindDest(unwrap(P: B));
3277}
3278
3279LLVMBasicBlockRef LLVMGetCallBrDefaultDest(LLVMValueRef CallBr) {
3280 return wrap(P: unwrap<CallBrInst>(P: CallBr)->getDefaultDest());
3281}
3282
3283unsigned LLVMGetCallBrNumIndirectDests(LLVMValueRef CallBr) {
3284 return unwrap<CallBrInst>(P: CallBr)->getNumIndirectDests();
3285}
3286
3287LLVMBasicBlockRef LLVMGetCallBrIndirectDest(LLVMValueRef CallBr, unsigned Idx) {
3288 return wrap(P: unwrap<CallBrInst>(P: CallBr)->getIndirectDest(i: Idx));
3289}
3290
3291/*--.. Operations on terminators ...........................................--*/
3292
3293unsigned LLVMGetNumSuccessors(LLVMValueRef Term) {
3294 return unwrap<Instruction>(P: Term)->getNumSuccessors();
3295}
3296
3297LLVMBasicBlockRef LLVMGetSuccessor(LLVMValueRef Term, unsigned i) {
3298 return wrap(P: unwrap<Instruction>(P: Term)->getSuccessor(Idx: i));
3299}
3300
3301void LLVMSetSuccessor(LLVMValueRef Term, unsigned i, LLVMBasicBlockRef block) {
3302 return unwrap<Instruction>(P: Term)->setSuccessor(Idx: i, BB: unwrap(P: block));
3303}
3304
3305/*--.. Operations on branch instructions (only) ............................--*/
3306
3307LLVMBool LLVMIsConditional(LLVMValueRef Branch) {
3308 return isa<CondBrInst>(Val: unwrap<Instruction>(P: Branch));
3309}
3310
3311LLVMValueRef LLVMGetCondition(LLVMValueRef Branch) {
3312 return wrap(P: unwrap<CondBrInst>(P: Branch)->getCondition());
3313}
3314
3315void LLVMSetCondition(LLVMValueRef Branch, LLVMValueRef Cond) {
3316 return unwrap<CondBrInst>(P: Branch)->setCondition(unwrap(P: Cond));
3317}
3318
3319/*--.. Operations on switch instructions (only) ............................--*/
3320
3321LLVMBasicBlockRef LLVMGetSwitchDefaultDest(LLVMValueRef Switch) {
3322 return wrap(P: unwrap<SwitchInst>(P: Switch)->getDefaultDest());
3323}
3324
3325LLVMValueRef LLVMGetSwitchCaseValue(LLVMValueRef Switch, unsigned i) {
3326 assert(i > 0 && i <= unwrap<SwitchInst>(Switch)->getNumCases());
3327 auto It = unwrap<SwitchInst>(P: Switch)->case_begin() + (i - 1);
3328 return wrap(P: It->getCaseValue());
3329}
3330
3331void LLVMSetSwitchCaseValue(LLVMValueRef Switch, unsigned i,
3332 LLVMValueRef CaseValue) {
3333 assert(i > 0 && i <= unwrap<SwitchInst>(Switch)->getNumCases());
3334 auto It = unwrap<SwitchInst>(P: Switch)->case_begin() + (i - 1);
3335 It->setValue(unwrap<ConstantInt>(P: CaseValue));
3336}
3337
3338/*--.. Operations on alloca instructions (only) ............................--*/
3339
3340LLVMTypeRef LLVMGetAllocatedType(LLVMValueRef Alloca) {
3341 return wrap(P: unwrap<AllocaInst>(P: Alloca)->getAllocatedType());
3342}
3343
3344/*--.. Operations on gep instructions (only) ...............................--*/
3345
3346LLVMBool LLVMIsInBounds(LLVMValueRef GEP) {
3347 return unwrap<GEPOperator>(P: GEP)->isInBounds();
3348}
3349
3350void LLVMSetIsInBounds(LLVMValueRef GEP, LLVMBool InBounds) {
3351 return unwrap<GetElementPtrInst>(P: GEP)->setIsInBounds(InBounds);
3352}
3353
3354LLVMTypeRef LLVMGetGEPSourceElementType(LLVMValueRef GEP) {
3355 return wrap(P: unwrap<GEPOperator>(P: GEP)->getSourceElementType());
3356}
3357
3358LLVMGEPNoWrapFlags LLVMGEPGetNoWrapFlags(LLVMValueRef GEP) {
3359 GEPOperator *GEPOp = unwrap<GEPOperator>(P: GEP);
3360 return mapToLLVMGEPNoWrapFlags(GEPFlags: GEPOp->getNoWrapFlags());
3361}
3362
3363void LLVMGEPSetNoWrapFlags(LLVMValueRef GEP, LLVMGEPNoWrapFlags NoWrapFlags) {
3364 GetElementPtrInst *GEPInst = unwrap<GetElementPtrInst>(P: GEP);
3365 GEPInst->setNoWrapFlags(mapFromLLVMGEPNoWrapFlags(GEPFlags: NoWrapFlags));
3366}
3367
3368/*--.. Operations on phi nodes .............................................--*/
3369
3370void LLVMAddIncoming(LLVMValueRef PhiNode, LLVMValueRef *IncomingValues,
3371 LLVMBasicBlockRef *IncomingBlocks, unsigned Count) {
3372 PHINode *PhiVal = unwrap<PHINode>(P: PhiNode);
3373 for (unsigned I = 0; I != Count; ++I)
3374 PhiVal->addIncoming(V: unwrap(P: IncomingValues[I]), BB: unwrap(P: IncomingBlocks[I]));
3375}
3376
3377unsigned LLVMCountIncoming(LLVMValueRef PhiNode) {
3378 return unwrap<PHINode>(P: PhiNode)->getNumIncomingValues();
3379}
3380
3381LLVMValueRef LLVMGetIncomingValue(LLVMValueRef PhiNode, unsigned Index) {
3382 return wrap(P: unwrap<PHINode>(P: PhiNode)->getIncomingValue(i: Index));
3383}
3384
3385LLVMBasicBlockRef LLVMGetIncomingBlock(LLVMValueRef PhiNode, unsigned Index) {
3386 return wrap(P: unwrap<PHINode>(P: PhiNode)->getIncomingBlock(i: Index));
3387}
3388
3389/*--.. Operations on extractvalue and insertvalue nodes ....................--*/
3390
3391unsigned LLVMGetNumIndices(LLVMValueRef Inst) {
3392 auto *I = unwrap(P: Inst);
3393 if (auto *GEP = dyn_cast<GEPOperator>(Val: I))
3394 return GEP->getNumIndices();
3395 if (auto *EV = dyn_cast<ExtractValueInst>(Val: I))
3396 return EV->getNumIndices();
3397 if (auto *IV = dyn_cast<InsertValueInst>(Val: I))
3398 return IV->getNumIndices();
3399 llvm_unreachable(
3400 "LLVMGetNumIndices applies only to extractvalue and insertvalue!");
3401}
3402
3403const unsigned *LLVMGetIndices(LLVMValueRef Inst) {
3404 auto *I = unwrap(P: Inst);
3405 if (auto *EV = dyn_cast<ExtractValueInst>(Val: I))
3406 return EV->getIndices().data();
3407 if (auto *IV = dyn_cast<InsertValueInst>(Val: I))
3408 return IV->getIndices().data();
3409 llvm_unreachable(
3410 "LLVMGetIndices applies only to extractvalue and insertvalue!");
3411}
3412
3413
3414/*===-- Instruction builders ----------------------------------------------===*/
3415
3416LLVMBuilderRef LLVMCreateBuilderInContext(LLVMContextRef C) {
3417 return wrap(P: new IRBuilder<>(*unwrap(P: C)));
3418}
3419
3420LLVMBuilderRef LLVMCreateBuilder(void) {
3421 return LLVMCreateBuilderInContext(C: getGlobalContextForCAPI());
3422}
3423
3424static void LLVMPositionBuilderImpl(IRBuilder<> *Builder, BasicBlock *Block,
3425 Instruction *Instr, bool BeforeDbgRecords) {
3426 BasicBlock::iterator I = Instr ? Instr->getIterator() : Block->end();
3427 I.setHeadBit(BeforeDbgRecords);
3428 Builder->SetInsertPoint(TheBB: Block, IP: I);
3429}
3430
3431void LLVMPositionBuilder(LLVMBuilderRef Builder, LLVMBasicBlockRef Block,
3432 LLVMValueRef Instr) {
3433 return LLVMPositionBuilderImpl(Builder: unwrap(P: Builder), Block: unwrap(P: Block),
3434 Instr: unwrap<Instruction>(P: Instr), BeforeDbgRecords: false);
3435}
3436
3437void LLVMPositionBuilderBeforeDbgRecords(LLVMBuilderRef Builder,
3438 LLVMBasicBlockRef Block,
3439 LLVMValueRef Instr) {
3440 return LLVMPositionBuilderImpl(Builder: unwrap(P: Builder), Block: unwrap(P: Block),
3441 Instr: unwrap<Instruction>(P: Instr), BeforeDbgRecords: true);
3442}
3443
3444void LLVMPositionBuilderBefore(LLVMBuilderRef Builder, LLVMValueRef Instr) {
3445 Instruction *I = unwrap<Instruction>(P: Instr);
3446 return LLVMPositionBuilderImpl(Builder: unwrap(P: Builder), Block: I->getParent(), Instr: I, BeforeDbgRecords: false);
3447}
3448
3449void LLVMPositionBuilderBeforeInstrAndDbgRecords(LLVMBuilderRef Builder,
3450 LLVMValueRef Instr) {
3451 Instruction *I = unwrap<Instruction>(P: Instr);
3452 return LLVMPositionBuilderImpl(Builder: unwrap(P: Builder), Block: I->getParent(), Instr: I, BeforeDbgRecords: true);
3453}
3454
3455void LLVMPositionBuilderAtEnd(LLVMBuilderRef Builder, LLVMBasicBlockRef Block) {
3456 BasicBlock *BB = unwrap(P: Block);
3457 unwrap(P: Builder)->SetInsertPoint(BB);
3458}
3459
3460LLVMBasicBlockRef LLVMGetInsertBlock(LLVMBuilderRef Builder) {
3461 return wrap(P: unwrap(P: Builder)->GetInsertBlock());
3462}
3463
3464void LLVMClearInsertionPosition(LLVMBuilderRef Builder) {
3465 unwrap(P: Builder)->ClearInsertionPoint();
3466}
3467
3468void LLVMInsertIntoBuilder(LLVMBuilderRef Builder, LLVMValueRef Instr) {
3469 unwrap(P: Builder)->Insert(I: unwrap<Instruction>(P: Instr));
3470}
3471
3472void LLVMInsertIntoBuilderWithName(LLVMBuilderRef Builder, LLVMValueRef Instr,
3473 const char *Name) {
3474 unwrap(P: Builder)->Insert(I: unwrap<Instruction>(P: Instr), Name);
3475}
3476
3477void LLVMDisposeBuilder(LLVMBuilderRef Builder) {
3478 delete unwrap(P: Builder);
3479}
3480
3481/*--.. Metadata builders ...................................................--*/
3482
3483LLVMMetadataRef LLVMGetCurrentDebugLocation2(LLVMBuilderRef Builder) {
3484 return wrap(P: unwrap(P: Builder)->getCurrentDebugLocation().getAsMDNode());
3485}
3486
3487void LLVMSetCurrentDebugLocation2(LLVMBuilderRef Builder, LLVMMetadataRef Loc) {
3488 if (Loc)
3489 unwrap(P: Builder)->SetCurrentDebugLocation(DebugLoc(unwrap<DILocation>(P: Loc)));
3490 else
3491 unwrap(P: Builder)->SetCurrentDebugLocation(DebugLoc());
3492}
3493
3494void LLVMSetCurrentDebugLocation(LLVMBuilderRef Builder, LLVMValueRef L) {
3495 DILocation *Loc =
3496 L ? cast<DILocation>(Val: unwrap<MetadataAsValue>(P: L)->getMetadata()) : nullptr;
3497 unwrap(P: Builder)->SetCurrentDebugLocation(DebugLoc(Loc));
3498}
3499
3500LLVMValueRef LLVMGetCurrentDebugLocation(LLVMBuilderRef Builder) {
3501 LLVMContext &Context = unwrap(P: Builder)->getContext();
3502 return wrap(P: MetadataAsValue::get(
3503 Context, MD: unwrap(P: Builder)->getCurrentDebugLocation().getAsMDNode()));
3504}
3505
3506void LLVMSetInstDebugLocation(LLVMBuilderRef Builder, LLVMValueRef Inst) {
3507 unwrap(P: Builder)->SetInstDebugLocation(unwrap<Instruction>(P: Inst));
3508}
3509
3510void LLVMAddMetadataToInst(LLVMBuilderRef Builder, LLVMValueRef Inst) {
3511 unwrap(P: Builder)->SetInstDebugLocation(unwrap<Instruction>(P: Inst));
3512}
3513
3514void LLVMBuilderSetDefaultFPMathTag(LLVMBuilderRef Builder,
3515 LLVMMetadataRef FPMathTag) {
3516
3517 unwrap(P: Builder)->setDefaultFPMathTag(FPMathTag
3518 ? unwrap<MDNode>(P: FPMathTag)
3519 : nullptr);
3520}
3521
3522LLVMContextRef LLVMGetBuilderContext(LLVMBuilderRef Builder) {
3523 return wrap(P: &unwrap(P: Builder)->getContext());
3524}
3525
3526LLVMMetadataRef LLVMBuilderGetDefaultFPMathTag(LLVMBuilderRef Builder) {
3527 return wrap(P: unwrap(P: Builder)->getDefaultFPMathTag());
3528}
3529
3530/*--.. Instruction builders ................................................--*/
3531
3532LLVMValueRef LLVMBuildRetVoid(LLVMBuilderRef B) {
3533 return wrap(P: unwrap(P: B)->CreateRetVoid());
3534}
3535
3536LLVMValueRef LLVMBuildRet(LLVMBuilderRef B, LLVMValueRef V) {
3537 return wrap(P: unwrap(P: B)->CreateRet(V: unwrap(P: V)));
3538}
3539
3540LLVMValueRef LLVMBuildAggregateRet(LLVMBuilderRef B, LLVMValueRef *RetVals,
3541 unsigned N) {
3542 return wrap(P: unwrap(P: B)->CreateAggregateRet(RetVals: {unwrap(Vals: RetVals), N}));
3543}
3544
3545LLVMValueRef LLVMBuildBr(LLVMBuilderRef B, LLVMBasicBlockRef Dest) {
3546 return wrap(P: unwrap(P: B)->CreateBr(Dest: unwrap(P: Dest)));
3547}
3548
3549LLVMValueRef LLVMBuildCondBr(LLVMBuilderRef B, LLVMValueRef If,
3550 LLVMBasicBlockRef Then, LLVMBasicBlockRef Else) {
3551 return wrap(P: unwrap(P: B)->CreateCondBr(Cond: unwrap(P: If), True: unwrap(P: Then), False: unwrap(P: Else)));
3552}
3553
3554LLVMValueRef LLVMBuildSwitch(LLVMBuilderRef B, LLVMValueRef V,
3555 LLVMBasicBlockRef Else, unsigned NumCases) {
3556 return wrap(P: unwrap(P: B)->CreateSwitch(V: unwrap(P: V), Dest: unwrap(P: Else), NumCases));
3557}
3558
3559LLVMValueRef LLVMBuildIndirectBr(LLVMBuilderRef B, LLVMValueRef Addr,
3560 unsigned NumDests) {
3561 return wrap(P: unwrap(P: B)->CreateIndirectBr(Addr: unwrap(P: Addr), NumDests));
3562}
3563
3564LLVMValueRef LLVMBuildCallBr(LLVMBuilderRef B, LLVMTypeRef Ty, LLVMValueRef Fn,
3565 LLVMBasicBlockRef DefaultDest,
3566 LLVMBasicBlockRef *IndirectDests,
3567 unsigned NumIndirectDests, LLVMValueRef *Args,
3568 unsigned NumArgs, LLVMOperandBundleRef *Bundles,
3569 unsigned NumBundles, const char *Name) {
3570
3571 SmallVector<OperandBundleDef, 8> OBs;
3572 for (auto *Bundle : ArrayRef(Bundles, NumBundles)) {
3573 OperandBundleDef *OB = unwrap(P: Bundle);
3574 OBs.push_back(Elt: *OB);
3575 }
3576
3577 return wrap(P: unwrap(P: B)->CreateCallBr(
3578 Ty: unwrap<FunctionType>(P: Ty), Callee: unwrap(P: Fn), DefaultDest: unwrap(P: DefaultDest),
3579 IndirectDests: ArrayRef(unwrap(BBs: IndirectDests), NumIndirectDests),
3580 Args: ArrayRef<Value *>(unwrap(Vals: Args), NumArgs), OpBundles: OBs, Name));
3581}
3582
3583LLVMValueRef LLVMBuildInvoke2(LLVMBuilderRef B, LLVMTypeRef Ty, LLVMValueRef Fn,
3584 LLVMValueRef *Args, unsigned NumArgs,
3585 LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch,
3586 const char *Name) {
3587 return wrap(P: unwrap(P: B)->CreateInvoke(Ty: unwrap<FunctionType>(P: Ty), Callee: unwrap(P: Fn),
3588 NormalDest: unwrap(P: Then), UnwindDest: unwrap(P: Catch),
3589 Args: ArrayRef(unwrap(Vals: Args), NumArgs), Name));
3590}
3591
3592LLVMValueRef LLVMBuildInvokeWithOperandBundles(
3593 LLVMBuilderRef B, LLVMTypeRef Ty, LLVMValueRef Fn, LLVMValueRef *Args,
3594 unsigned NumArgs, LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch,
3595 LLVMOperandBundleRef *Bundles, unsigned NumBundles, const char *Name) {
3596 SmallVector<OperandBundleDef, 8> OBs;
3597 for (auto *Bundle : ArrayRef(Bundles, NumBundles)) {
3598 OperandBundleDef *OB = unwrap(P: Bundle);
3599 OBs.push_back(Elt: *OB);
3600 }
3601 return wrap(P: unwrap(P: B)->CreateInvoke(
3602 Ty: unwrap<FunctionType>(P: Ty), Callee: unwrap(P: Fn), NormalDest: unwrap(P: Then), UnwindDest: unwrap(P: Catch),
3603 Args: ArrayRef(unwrap(Vals: Args), NumArgs), OpBundles: OBs, Name));
3604}
3605
3606LLVMValueRef LLVMBuildLandingPad(LLVMBuilderRef B, LLVMTypeRef Ty,
3607 LLVMValueRef PersFn, unsigned NumClauses,
3608 const char *Name) {
3609 // The personality used to live on the landingpad instruction, but now it
3610 // lives on the parent function. For compatibility, take the provided
3611 // personality and put it on the parent function.
3612 if (PersFn)
3613 unwrap(P: B)->GetInsertBlock()->getParent()->setPersonalityFn(
3614 unwrap<Function>(P: PersFn));
3615 return wrap(P: unwrap(P: B)->CreateLandingPad(Ty: unwrap(P: Ty), NumClauses, Name));
3616}
3617
3618LLVMValueRef LLVMBuildCatchPad(LLVMBuilderRef B, LLVMValueRef ParentPad,
3619 LLVMValueRef *Args, unsigned NumArgs,
3620 const char *Name) {
3621 return wrap(P: unwrap(P: B)->CreateCatchPad(ParentPad: unwrap(P: ParentPad),
3622 Args: ArrayRef(unwrap(Vals: Args), NumArgs), Name));
3623}
3624
3625LLVMValueRef LLVMBuildCleanupPad(LLVMBuilderRef B, LLVMValueRef ParentPad,
3626 LLVMValueRef *Args, unsigned NumArgs,
3627 const char *Name) {
3628 if (ParentPad == nullptr) {
3629 Type *Ty = Type::getTokenTy(C&: unwrap(P: B)->getContext());
3630 ParentPad = wrap(P: Constant::getNullValue(Ty));
3631 }
3632 return wrap(P: unwrap(P: B)->CreateCleanupPad(
3633 ParentPad: unwrap(P: ParentPad), Args: ArrayRef(unwrap(Vals: Args), NumArgs), Name));
3634}
3635
3636LLVMValueRef LLVMBuildResume(LLVMBuilderRef B, LLVMValueRef Exn) {
3637 return wrap(P: unwrap(P: B)->CreateResume(Exn: unwrap(P: Exn)));
3638}
3639
3640LLVMValueRef LLVMBuildCatchSwitch(LLVMBuilderRef B, LLVMValueRef ParentPad,
3641 LLVMBasicBlockRef UnwindBB,
3642 unsigned NumHandlers, const char *Name) {
3643 if (ParentPad == nullptr) {
3644 Type *Ty = Type::getTokenTy(C&: unwrap(P: B)->getContext());
3645 ParentPad = wrap(P: Constant::getNullValue(Ty));
3646 }
3647 return wrap(P: unwrap(P: B)->CreateCatchSwitch(ParentPad: unwrap(P: ParentPad), UnwindBB: unwrap(P: UnwindBB),
3648 NumHandlers, Name));
3649}
3650
3651LLVMValueRef LLVMBuildCatchRet(LLVMBuilderRef B, LLVMValueRef CatchPad,
3652 LLVMBasicBlockRef BB) {
3653 return wrap(P: unwrap(P: B)->CreateCatchRet(CatchPad: unwrap<CatchPadInst>(P: CatchPad),
3654 BB: unwrap(P: BB)));
3655}
3656
3657LLVMValueRef LLVMBuildCleanupRet(LLVMBuilderRef B, LLVMValueRef CatchPad,
3658 LLVMBasicBlockRef BB) {
3659 return wrap(P: unwrap(P: B)->CreateCleanupRet(CleanupPad: unwrap<CleanupPadInst>(P: CatchPad),
3660 UnwindBB: unwrap(P: BB)));
3661}
3662
3663LLVMValueRef LLVMBuildUnreachable(LLVMBuilderRef B) {
3664 return wrap(P: unwrap(P: B)->CreateUnreachable());
3665}
3666
3667void LLVMAddCase(LLVMValueRef Switch, LLVMValueRef OnVal,
3668 LLVMBasicBlockRef Dest) {
3669 unwrap<SwitchInst>(P: Switch)->addCase(OnVal: unwrap<ConstantInt>(P: OnVal), Dest: unwrap(P: Dest));
3670}
3671
3672void LLVMAddDestination(LLVMValueRef IndirectBr, LLVMBasicBlockRef Dest) {
3673 unwrap<IndirectBrInst>(P: IndirectBr)->addDestination(Dest: unwrap(P: Dest));
3674}
3675
3676unsigned LLVMGetNumClauses(LLVMValueRef LandingPad) {
3677 return unwrap<LandingPadInst>(P: LandingPad)->getNumClauses();
3678}
3679
3680LLVMValueRef LLVMGetClause(LLVMValueRef LandingPad, unsigned Idx) {
3681 return wrap(P: unwrap<LandingPadInst>(P: LandingPad)->getClause(Idx));
3682}
3683
3684void LLVMAddClause(LLVMValueRef LandingPad, LLVMValueRef ClauseVal) {
3685 unwrap<LandingPadInst>(P: LandingPad)->addClause(ClauseVal: unwrap<Constant>(P: ClauseVal));
3686}
3687
3688LLVMBool LLVMIsCleanup(LLVMValueRef LandingPad) {
3689 return unwrap<LandingPadInst>(P: LandingPad)->isCleanup();
3690}
3691
3692void LLVMSetCleanup(LLVMValueRef LandingPad, LLVMBool Val) {
3693 unwrap<LandingPadInst>(P: LandingPad)->setCleanup(Val);
3694}
3695
3696void LLVMAddHandler(LLVMValueRef CatchSwitch, LLVMBasicBlockRef Dest) {
3697 unwrap<CatchSwitchInst>(P: CatchSwitch)->addHandler(Dest: unwrap(P: Dest));
3698}
3699
3700unsigned LLVMGetNumHandlers(LLVMValueRef CatchSwitch) {
3701 return unwrap<CatchSwitchInst>(P: CatchSwitch)->getNumHandlers();
3702}
3703
3704void LLVMGetHandlers(LLVMValueRef CatchSwitch, LLVMBasicBlockRef *Handlers) {
3705 CatchSwitchInst *CSI = unwrap<CatchSwitchInst>(P: CatchSwitch);
3706 for (const BasicBlock *H : CSI->handlers())
3707 *Handlers++ = wrap(P: H);
3708}
3709
3710LLVMValueRef LLVMGetParentCatchSwitch(LLVMValueRef CatchPad) {
3711 return wrap(P: unwrap<CatchPadInst>(P: CatchPad)->getCatchSwitch());
3712}
3713
3714void LLVMSetParentCatchSwitch(LLVMValueRef CatchPad, LLVMValueRef CatchSwitch) {
3715 unwrap<CatchPadInst>(P: CatchPad)
3716 ->setCatchSwitch(unwrap<CatchSwitchInst>(P: CatchSwitch));
3717}
3718
3719/*--.. Funclets ...........................................................--*/
3720
3721LLVMValueRef LLVMGetArgOperand(LLVMValueRef Funclet, unsigned i) {
3722 return wrap(P: unwrap<FuncletPadInst>(P: Funclet)->getArgOperand(i));
3723}
3724
3725void LLVMSetArgOperand(LLVMValueRef Funclet, unsigned i, LLVMValueRef value) {
3726 unwrap<FuncletPadInst>(P: Funclet)->setArgOperand(i, v: unwrap(P: value));
3727}
3728
3729/*--.. Arithmetic ..........................................................--*/
3730
3731static FastMathFlags mapFromLLVMFastMathFlags(LLVMFastMathFlags FMF) {
3732 FastMathFlags NewFMF;
3733 NewFMF.setAllowReassoc((FMF & LLVMFastMathAllowReassoc) != 0);
3734 NewFMF.setNoNaNs((FMF & LLVMFastMathNoNaNs) != 0);
3735 NewFMF.setNoInfs((FMF & LLVMFastMathNoInfs) != 0);
3736 NewFMF.setNoSignedZeros((FMF & LLVMFastMathNoSignedZeros) != 0);
3737 NewFMF.setAllowReciprocal((FMF & LLVMFastMathAllowReciprocal) != 0);
3738 NewFMF.setAllowContract((FMF & LLVMFastMathAllowContract) != 0);
3739 NewFMF.setApproxFunc((FMF & LLVMFastMathApproxFunc) != 0);
3740
3741 return NewFMF;
3742}
3743
3744static LLVMFastMathFlags mapToLLVMFastMathFlags(FastMathFlags FMF) {
3745 LLVMFastMathFlags NewFMF = LLVMFastMathNone;
3746 if (FMF.allowReassoc())
3747 NewFMF |= LLVMFastMathAllowReassoc;
3748 if (FMF.noNaNs())
3749 NewFMF |= LLVMFastMathNoNaNs;
3750 if (FMF.noInfs())
3751 NewFMF |= LLVMFastMathNoInfs;
3752 if (FMF.noSignedZeros())
3753 NewFMF |= LLVMFastMathNoSignedZeros;
3754 if (FMF.allowReciprocal())
3755 NewFMF |= LLVMFastMathAllowReciprocal;
3756 if (FMF.allowContract())
3757 NewFMF |= LLVMFastMathAllowContract;
3758 if (FMF.approxFunc())
3759 NewFMF |= LLVMFastMathApproxFunc;
3760
3761 return NewFMF;
3762}
3763
3764LLVMValueRef LLVMBuildAdd(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
3765 const char *Name) {
3766 return wrap(P: unwrap(P: B)->CreateAdd(LHS: unwrap(P: LHS), RHS: unwrap(P: RHS), Name));
3767}
3768
3769LLVMValueRef LLVMBuildNSWAdd(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
3770 const char *Name) {
3771 return wrap(P: unwrap(P: B)->CreateNSWAdd(LHS: unwrap(P: LHS), RHS: unwrap(P: RHS), Name));
3772}
3773
3774LLVMValueRef LLVMBuildNUWAdd(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
3775 const char *Name) {
3776 return wrap(P: unwrap(P: B)->CreateNUWAdd(LHS: unwrap(P: LHS), RHS: unwrap(P: RHS), Name));
3777}
3778
3779LLVMValueRef LLVMBuildFAdd(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
3780 const char *Name) {
3781 return wrap(P: unwrap(P: B)->CreateFAdd(L: unwrap(P: LHS), R: unwrap(P: RHS), Name));
3782}
3783
3784LLVMValueRef LLVMBuildSub(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
3785 const char *Name) {
3786 return wrap(P: unwrap(P: B)->CreateSub(LHS: unwrap(P: LHS), RHS: unwrap(P: RHS), Name));
3787}
3788
3789LLVMValueRef LLVMBuildNSWSub(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
3790 const char *Name) {
3791 return wrap(P: unwrap(P: B)->CreateNSWSub(LHS: unwrap(P: LHS), RHS: unwrap(P: RHS), Name));
3792}
3793
3794LLVMValueRef LLVMBuildNUWSub(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
3795 const char *Name) {
3796 return wrap(P: unwrap(P: B)->CreateNUWSub(LHS: unwrap(P: LHS), RHS: unwrap(P: RHS), Name));
3797}
3798
3799LLVMValueRef LLVMBuildFSub(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
3800 const char *Name) {
3801 return wrap(P: unwrap(P: B)->CreateFSub(L: unwrap(P: LHS), R: unwrap(P: RHS), Name));
3802}
3803
3804LLVMValueRef LLVMBuildMul(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
3805 const char *Name) {
3806 return wrap(P: unwrap(P: B)->CreateMul(LHS: unwrap(P: LHS), RHS: unwrap(P: RHS), Name));
3807}
3808
3809LLVMValueRef LLVMBuildNSWMul(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
3810 const char *Name) {
3811 return wrap(P: unwrap(P: B)->CreateNSWMul(LHS: unwrap(P: LHS), RHS: unwrap(P: RHS), Name));
3812}
3813
3814LLVMValueRef LLVMBuildNUWMul(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
3815 const char *Name) {
3816 return wrap(P: unwrap(P: B)->CreateNUWMul(LHS: unwrap(P: LHS), RHS: unwrap(P: RHS), Name));
3817}
3818
3819LLVMValueRef LLVMBuildFMul(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
3820 const char *Name) {
3821 return wrap(P: unwrap(P: B)->CreateFMul(L: unwrap(P: LHS), R: unwrap(P: RHS), Name));
3822}
3823
3824LLVMValueRef LLVMBuildUDiv(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
3825 const char *Name) {
3826 return wrap(P: unwrap(P: B)->CreateUDiv(LHS: unwrap(P: LHS), RHS: unwrap(P: RHS), Name));
3827}
3828
3829LLVMValueRef LLVMBuildExactUDiv(LLVMBuilderRef B, LLVMValueRef LHS,
3830 LLVMValueRef RHS, const char *Name) {
3831 return wrap(P: unwrap(P: B)->CreateExactUDiv(LHS: unwrap(P: LHS), RHS: unwrap(P: RHS), Name));
3832}
3833
3834LLVMValueRef LLVMBuildSDiv(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
3835 const char *Name) {
3836 return wrap(P: unwrap(P: B)->CreateSDiv(LHS: unwrap(P: LHS), RHS: unwrap(P: RHS), Name));
3837}
3838
3839LLVMValueRef LLVMBuildExactSDiv(LLVMBuilderRef B, LLVMValueRef LHS,
3840 LLVMValueRef RHS, const char *Name) {
3841 return wrap(P: unwrap(P: B)->CreateExactSDiv(LHS: unwrap(P: LHS), RHS: unwrap(P: RHS), Name));
3842}
3843
3844LLVMValueRef LLVMBuildFDiv(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
3845 const char *Name) {
3846 return wrap(P: unwrap(P: B)->CreateFDiv(L: unwrap(P: LHS), R: unwrap(P: RHS), Name));
3847}
3848
3849LLVMValueRef LLVMBuildURem(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
3850 const char *Name) {
3851 return wrap(P: unwrap(P: B)->CreateURem(LHS: unwrap(P: LHS), RHS: unwrap(P: RHS), Name));
3852}
3853
3854LLVMValueRef LLVMBuildSRem(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
3855 const char *Name) {
3856 return wrap(P: unwrap(P: B)->CreateSRem(LHS: unwrap(P: LHS), RHS: unwrap(P: RHS), Name));
3857}
3858
3859LLVMValueRef LLVMBuildFRem(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
3860 const char *Name) {
3861 return wrap(P: unwrap(P: B)->CreateFRem(L: unwrap(P: LHS), R: unwrap(P: RHS), Name));
3862}
3863
3864LLVMValueRef LLVMBuildShl(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
3865 const char *Name) {
3866 return wrap(P: unwrap(P: B)->CreateShl(LHS: unwrap(P: LHS), RHS: unwrap(P: RHS), Name));
3867}
3868
3869LLVMValueRef LLVMBuildLShr(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
3870 const char *Name) {
3871 return wrap(P: unwrap(P: B)->CreateLShr(LHS: unwrap(P: LHS), RHS: unwrap(P: RHS), Name));
3872}
3873
3874LLVMValueRef LLVMBuildAShr(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
3875 const char *Name) {
3876 return wrap(P: unwrap(P: B)->CreateAShr(LHS: unwrap(P: LHS), RHS: unwrap(P: RHS), Name));
3877}
3878
3879LLVMValueRef LLVMBuildAnd(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
3880 const char *Name) {
3881 return wrap(P: unwrap(P: B)->CreateAnd(LHS: unwrap(P: LHS), RHS: unwrap(P: RHS), Name));
3882}
3883
3884LLVMValueRef LLVMBuildOr(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
3885 const char *Name) {
3886 return wrap(P: unwrap(P: B)->CreateOr(LHS: unwrap(P: LHS), RHS: unwrap(P: RHS), Name));
3887}
3888
3889LLVMValueRef LLVMBuildXor(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS,
3890 const char *Name) {
3891 return wrap(P: unwrap(P: B)->CreateXor(LHS: unwrap(P: LHS), RHS: unwrap(P: RHS), Name));
3892}
3893
3894LLVMValueRef LLVMBuildBinOp(LLVMBuilderRef B, LLVMOpcode Op,
3895 LLVMValueRef LHS, LLVMValueRef RHS,
3896 const char *Name) {
3897 return wrap(P: unwrap(P: B)->CreateBinOp(Opc: Instruction::BinaryOps(map_from_llvmopcode(code: Op)), LHS: unwrap(P: LHS),
3898 RHS: unwrap(P: RHS), Name));
3899}
3900
3901LLVMValueRef LLVMBuildNeg(LLVMBuilderRef B, LLVMValueRef V, const char *Name) {
3902 return wrap(P: unwrap(P: B)->CreateNeg(V: unwrap(P: V), Name));
3903}
3904
3905LLVMValueRef LLVMBuildNSWNeg(LLVMBuilderRef B, LLVMValueRef V,
3906 const char *Name) {
3907 return wrap(P: unwrap(P: B)->CreateNSWNeg(V: unwrap(P: V), Name));
3908}
3909
3910LLVMValueRef LLVMBuildNUWNeg(LLVMBuilderRef B, LLVMValueRef V,
3911 const char *Name) {
3912 Value *Neg = unwrap(P: B)->CreateNeg(V: unwrap(P: V), Name);
3913 if (auto *I = dyn_cast<BinaryOperator>(Val: Neg))
3914 I->setHasNoUnsignedWrap();
3915 return wrap(P: Neg);
3916}
3917
3918LLVMValueRef LLVMBuildFNeg(LLVMBuilderRef B, LLVMValueRef V, const char *Name) {
3919 return wrap(P: unwrap(P: B)->CreateFNeg(V: unwrap(P: V), Name));
3920}
3921
3922LLVMValueRef LLVMBuildNot(LLVMBuilderRef B, LLVMValueRef V, const char *Name) {
3923 return wrap(P: unwrap(P: B)->CreateNot(V: unwrap(P: V), Name));
3924}
3925
3926LLVMBool LLVMGetNUW(LLVMValueRef ArithInst) {
3927 Value *P = unwrap<Value>(P: ArithInst);
3928 return cast<Instruction>(Val: P)->hasNoUnsignedWrap();
3929}
3930
3931void LLVMSetNUW(LLVMValueRef ArithInst, LLVMBool HasNUW) {
3932 Value *P = unwrap<Value>(P: ArithInst);
3933 cast<Instruction>(Val: P)->setHasNoUnsignedWrap(HasNUW);
3934}
3935
3936LLVMBool LLVMGetNSW(LLVMValueRef ArithInst) {
3937 Value *P = unwrap<Value>(P: ArithInst);
3938 return cast<Instruction>(Val: P)->hasNoSignedWrap();
3939}
3940
3941void LLVMSetNSW(LLVMValueRef ArithInst, LLVMBool HasNSW) {
3942 Value *P = unwrap<Value>(P: ArithInst);
3943 cast<Instruction>(Val: P)->setHasNoSignedWrap(HasNSW);
3944}
3945
3946LLVMBool LLVMGetExact(LLVMValueRef DivOrShrInst) {
3947 Value *P = unwrap<Value>(P: DivOrShrInst);
3948 return cast<Instruction>(Val: P)->isExact();
3949}
3950
3951void LLVMSetExact(LLVMValueRef DivOrShrInst, LLVMBool IsExact) {
3952 Value *P = unwrap<Value>(P: DivOrShrInst);
3953 cast<Instruction>(Val: P)->setIsExact(IsExact);
3954}
3955
3956LLVMBool LLVMGetNNeg(LLVMValueRef NonNegInst) {
3957 Value *P = unwrap<Value>(P: NonNegInst);
3958 return cast<Instruction>(Val: P)->hasNonNeg();
3959}
3960
3961void LLVMSetNNeg(LLVMValueRef NonNegInst, LLVMBool IsNonNeg) {
3962 Value *P = unwrap<Value>(P: NonNegInst);
3963 cast<Instruction>(Val: P)->setNonNeg(IsNonNeg);
3964}
3965
3966LLVMFastMathFlags LLVMGetFastMathFlags(LLVMValueRef FPMathInst) {
3967 Value *P = unwrap<Value>(P: FPMathInst);
3968 FastMathFlags FMF = cast<Instruction>(Val: P)->getFastMathFlags();
3969 return mapToLLVMFastMathFlags(FMF);
3970}
3971
3972void LLVMSetFastMathFlags(LLVMValueRef FPMathInst, LLVMFastMathFlags FMF) {
3973 Value *P = unwrap<Value>(P: FPMathInst);
3974 cast<Instruction>(Val: P)->setFastMathFlags(mapFromLLVMFastMathFlags(FMF));
3975}
3976
3977LLVMBool LLVMCanValueUseFastMathFlags(LLVMValueRef V) {
3978 Value *Val = unwrap<Value>(P: V);
3979 return isa<FPMathOperator>(Val);
3980}
3981
3982LLVMBool LLVMGetIsDisjoint(LLVMValueRef Inst) {
3983 Value *P = unwrap<Value>(P: Inst);
3984 return cast<PossiblyDisjointInst>(Val: P)->isDisjoint();
3985}
3986
3987void LLVMSetIsDisjoint(LLVMValueRef Inst, LLVMBool IsDisjoint) {
3988 Value *P = unwrap<Value>(P: Inst);
3989 cast<PossiblyDisjointInst>(Val: P)->setIsDisjoint(IsDisjoint);
3990}
3991
3992/*--.. Memory ..............................................................--*/
3993
3994LLVMValueRef LLVMBuildMalloc(LLVMBuilderRef B, LLVMTypeRef Ty,
3995 const char *Name) {
3996 Type* ITy = Type::getInt32Ty(C&: unwrap(P: B)->GetInsertBlock()->getContext());
3997 Constant* AllocSize = ConstantExpr::getSizeOf(Ty: unwrap(P: Ty));
3998 AllocSize = ConstantExpr::getTruncOrBitCast(C: AllocSize, Ty: ITy);
3999 return wrap(P: unwrap(P: B)->CreateMalloc(IntPtrTy: ITy, AllocTy: unwrap(P: Ty), AllocSize, ArraySize: nullptr,
4000 MallocF: nullptr, Name));
4001}
4002
4003LLVMValueRef LLVMBuildArrayMalloc(LLVMBuilderRef B, LLVMTypeRef Ty,
4004 LLVMValueRef Val, const char *Name) {
4005 Type* ITy = Type::getInt32Ty(C&: unwrap(P: B)->GetInsertBlock()->getContext());
4006 Constant* AllocSize = ConstantExpr::getSizeOf(Ty: unwrap(P: Ty));
4007 AllocSize = ConstantExpr::getTruncOrBitCast(C: AllocSize, Ty: ITy);
4008 return wrap(P: unwrap(P: B)->CreateMalloc(IntPtrTy: ITy, AllocTy: unwrap(P: Ty), AllocSize, ArraySize: unwrap(P: Val),
4009 MallocF: nullptr, Name));
4010}
4011
4012LLVMValueRef LLVMBuildMemSet(LLVMBuilderRef B, LLVMValueRef Ptr,
4013 LLVMValueRef Val, LLVMValueRef Len,
4014 unsigned Align) {
4015 return wrap(P: unwrap(P: B)->CreateMemSet(Ptr: unwrap(P: Ptr), Val: unwrap(P: Val), Size: unwrap(P: Len),
4016 Align: MaybeAlign(Align)));
4017}
4018
4019LLVMValueRef LLVMBuildMemCpy(LLVMBuilderRef B,
4020 LLVMValueRef Dst, unsigned DstAlign,
4021 LLVMValueRef Src, unsigned SrcAlign,
4022 LLVMValueRef Size) {
4023 return wrap(P: unwrap(P: B)->CreateMemCpy(Dst: unwrap(P: Dst), DstAlign: MaybeAlign(DstAlign),
4024 Src: unwrap(P: Src), SrcAlign: MaybeAlign(SrcAlign),
4025 Size: unwrap(P: Size)));
4026}
4027
4028LLVMValueRef LLVMBuildMemMove(LLVMBuilderRef B,
4029 LLVMValueRef Dst, unsigned DstAlign,
4030 LLVMValueRef Src, unsigned SrcAlign,
4031 LLVMValueRef Size) {
4032 return wrap(P: unwrap(P: B)->CreateMemMove(Dst: unwrap(P: Dst), DstAlign: MaybeAlign(DstAlign),
4033 Src: unwrap(P: Src), SrcAlign: MaybeAlign(SrcAlign),
4034 Size: unwrap(P: Size)));
4035}
4036
4037LLVMValueRef LLVMBuildAlloca(LLVMBuilderRef B, LLVMTypeRef Ty,
4038 const char *Name) {
4039 return wrap(P: unwrap(P: B)->CreateAlloca(Ty: unwrap(P: Ty), ArraySize: nullptr, Name));
4040}
4041
4042LLVMValueRef LLVMBuildArrayAlloca(LLVMBuilderRef B, LLVMTypeRef Ty,
4043 LLVMValueRef Val, const char *Name) {
4044 return wrap(P: unwrap(P: B)->CreateAlloca(Ty: unwrap(P: Ty), ArraySize: unwrap(P: Val), Name));
4045}
4046
4047LLVMValueRef LLVMBuildFree(LLVMBuilderRef B, LLVMValueRef PointerVal) {
4048 return wrap(P: unwrap(P: B)->CreateFree(Source: unwrap(P: PointerVal)));
4049}
4050
4051LLVMValueRef LLVMBuildLoad2(LLVMBuilderRef B, LLVMTypeRef Ty,
4052 LLVMValueRef PointerVal, const char *Name) {
4053 return wrap(P: unwrap(P: B)->CreateLoad(Ty: unwrap(P: Ty), Ptr: unwrap(P: PointerVal), Name));
4054}
4055
4056LLVMValueRef LLVMBuildStore(LLVMBuilderRef B, LLVMValueRef Val,
4057 LLVMValueRef PointerVal) {
4058 return wrap(P: unwrap(P: B)->CreateStore(Val: unwrap(P: Val), Ptr: unwrap(P: PointerVal)));
4059}
4060
4061static AtomicOrdering mapFromLLVMOrdering(LLVMAtomicOrdering Ordering) {
4062 switch (Ordering) {
4063 case LLVMAtomicOrderingNotAtomic: return AtomicOrdering::NotAtomic;
4064 case LLVMAtomicOrderingUnordered: return AtomicOrdering::Unordered;
4065 case LLVMAtomicOrderingMonotonic: return AtomicOrdering::Monotonic;
4066 case LLVMAtomicOrderingAcquire: return AtomicOrdering::Acquire;
4067 case LLVMAtomicOrderingRelease: return AtomicOrdering::Release;
4068 case LLVMAtomicOrderingAcquireRelease:
4069 return AtomicOrdering::AcquireRelease;
4070 case LLVMAtomicOrderingSequentiallyConsistent:
4071 return AtomicOrdering::SequentiallyConsistent;
4072 }
4073
4074 llvm_unreachable("Invalid LLVMAtomicOrdering value!");
4075}
4076
4077static LLVMAtomicOrdering mapToLLVMOrdering(AtomicOrdering Ordering) {
4078 switch (Ordering) {
4079 case AtomicOrdering::NotAtomic: return LLVMAtomicOrderingNotAtomic;
4080 case AtomicOrdering::Unordered: return LLVMAtomicOrderingUnordered;
4081 case AtomicOrdering::Monotonic: return LLVMAtomicOrderingMonotonic;
4082 case AtomicOrdering::Acquire: return LLVMAtomicOrderingAcquire;
4083 case AtomicOrdering::Release: return LLVMAtomicOrderingRelease;
4084 case AtomicOrdering::AcquireRelease:
4085 return LLVMAtomicOrderingAcquireRelease;
4086 case AtomicOrdering::SequentiallyConsistent:
4087 return LLVMAtomicOrderingSequentiallyConsistent;
4088 }
4089
4090 llvm_unreachable("Invalid AtomicOrdering value!");
4091}
4092
4093static AtomicRMWInst::BinOp mapFromLLVMRMWBinOp(LLVMAtomicRMWBinOp BinOp) {
4094 switch (BinOp) {
4095 case LLVMAtomicRMWBinOpXchg: return AtomicRMWInst::Xchg;
4096 case LLVMAtomicRMWBinOpAdd: return AtomicRMWInst::Add;
4097 case LLVMAtomicRMWBinOpSub: return AtomicRMWInst::Sub;
4098 case LLVMAtomicRMWBinOpAnd: return AtomicRMWInst::And;
4099 case LLVMAtomicRMWBinOpNand: return AtomicRMWInst::Nand;
4100 case LLVMAtomicRMWBinOpOr: return AtomicRMWInst::Or;
4101 case LLVMAtomicRMWBinOpXor: return AtomicRMWInst::Xor;
4102 case LLVMAtomicRMWBinOpMax: return AtomicRMWInst::Max;
4103 case LLVMAtomicRMWBinOpMin: return AtomicRMWInst::Min;
4104 case LLVMAtomicRMWBinOpUMax: return AtomicRMWInst::UMax;
4105 case LLVMAtomicRMWBinOpUMin: return AtomicRMWInst::UMin;
4106 case LLVMAtomicRMWBinOpFAdd: return AtomicRMWInst::FAdd;
4107 case LLVMAtomicRMWBinOpFSub: return AtomicRMWInst::FSub;
4108 case LLVMAtomicRMWBinOpFMax: return AtomicRMWInst::FMax;
4109 case LLVMAtomicRMWBinOpFMin: return AtomicRMWInst::FMin;
4110 case LLVMAtomicRMWBinOpFMaximum:
4111 return AtomicRMWInst::FMaximum;
4112 case LLVMAtomicRMWBinOpFMinimum:
4113 return AtomicRMWInst::FMinimum;
4114 case LLVMAtomicRMWBinOpFMaximumNum:
4115 return AtomicRMWInst::FMaximumNum;
4116 case LLVMAtomicRMWBinOpFMinimumNum:
4117 return AtomicRMWInst::FMinimumNum;
4118 case LLVMAtomicRMWBinOpUIncWrap:
4119 return AtomicRMWInst::UIncWrap;
4120 case LLVMAtomicRMWBinOpUDecWrap:
4121 return AtomicRMWInst::UDecWrap;
4122 case LLVMAtomicRMWBinOpUSubCond:
4123 return AtomicRMWInst::USubCond;
4124 case LLVMAtomicRMWBinOpUSubSat:
4125 return AtomicRMWInst::USubSat;
4126 }
4127
4128 llvm_unreachable("Invalid LLVMAtomicRMWBinOp value!");
4129}
4130
4131static LLVMAtomicRMWBinOp mapToLLVMRMWBinOp(AtomicRMWInst::BinOp BinOp) {
4132 switch (BinOp) {
4133 case AtomicRMWInst::Xchg: return LLVMAtomicRMWBinOpXchg;
4134 case AtomicRMWInst::Add: return LLVMAtomicRMWBinOpAdd;
4135 case AtomicRMWInst::Sub: return LLVMAtomicRMWBinOpSub;
4136 case AtomicRMWInst::And: return LLVMAtomicRMWBinOpAnd;
4137 case AtomicRMWInst::Nand: return LLVMAtomicRMWBinOpNand;
4138 case AtomicRMWInst::Or: return LLVMAtomicRMWBinOpOr;
4139 case AtomicRMWInst::Xor: return LLVMAtomicRMWBinOpXor;
4140 case AtomicRMWInst::Max: return LLVMAtomicRMWBinOpMax;
4141 case AtomicRMWInst::Min: return LLVMAtomicRMWBinOpMin;
4142 case AtomicRMWInst::UMax: return LLVMAtomicRMWBinOpUMax;
4143 case AtomicRMWInst::UMin: return LLVMAtomicRMWBinOpUMin;
4144 case AtomicRMWInst::FAdd: return LLVMAtomicRMWBinOpFAdd;
4145 case AtomicRMWInst::FSub: return LLVMAtomicRMWBinOpFSub;
4146 case AtomicRMWInst::FMax: return LLVMAtomicRMWBinOpFMax;
4147 case AtomicRMWInst::FMin: return LLVMAtomicRMWBinOpFMin;
4148 case AtomicRMWInst::FMaximum:
4149 return LLVMAtomicRMWBinOpFMaximum;
4150 case AtomicRMWInst::FMinimum:
4151 return LLVMAtomicRMWBinOpFMinimum;
4152 case AtomicRMWInst::FMaximumNum:
4153 return LLVMAtomicRMWBinOpFMaximumNum;
4154 case AtomicRMWInst::FMinimumNum:
4155 return LLVMAtomicRMWBinOpFMinimumNum;
4156 case AtomicRMWInst::UIncWrap:
4157 return LLVMAtomicRMWBinOpUIncWrap;
4158 case AtomicRMWInst::UDecWrap:
4159 return LLVMAtomicRMWBinOpUDecWrap;
4160 case AtomicRMWInst::USubCond:
4161 return LLVMAtomicRMWBinOpUSubCond;
4162 case AtomicRMWInst::USubSat:
4163 return LLVMAtomicRMWBinOpUSubSat;
4164 default: break;
4165 }
4166
4167 llvm_unreachable("Invalid AtomicRMWBinOp value!");
4168}
4169
4170LLVMValueRef LLVMBuildFence(LLVMBuilderRef B, LLVMAtomicOrdering Ordering,
4171 LLVMBool isSingleThread, const char *Name) {
4172 return wrap(
4173 P: unwrap(P: B)->CreateFence(Ordering: mapFromLLVMOrdering(Ordering),
4174 SSID: isSingleThread ? SyncScope::SingleThread
4175 : SyncScope::System,
4176 Name));
4177}
4178
4179LLVMValueRef LLVMBuildFenceSyncScope(LLVMBuilderRef B,
4180 LLVMAtomicOrdering Ordering, unsigned SSID,
4181 const char *Name) {
4182 return wrap(
4183 P: unwrap(P: B)->CreateFence(Ordering: mapFromLLVMOrdering(Ordering), SSID, Name));
4184}
4185
4186LLVMValueRef LLVMBuildGEP2(LLVMBuilderRef B, LLVMTypeRef Ty,
4187 LLVMValueRef Pointer, LLVMValueRef *Indices,
4188 unsigned NumIndices, const char *Name) {
4189 ArrayRef<Value *> IdxList(unwrap(Vals: Indices), NumIndices);
4190 return wrap(P: unwrap(P: B)->CreateGEP(Ty: unwrap(P: Ty), Ptr: unwrap(P: Pointer), IdxList, Name));
4191}
4192
4193LLVMValueRef LLVMBuildInBoundsGEP2(LLVMBuilderRef B, LLVMTypeRef Ty,
4194 LLVMValueRef Pointer, LLVMValueRef *Indices,
4195 unsigned NumIndices, const char *Name) {
4196 ArrayRef<Value *> IdxList(unwrap(Vals: Indices), NumIndices);
4197 return wrap(
4198 P: unwrap(P: B)->CreateInBoundsGEP(Ty: unwrap(P: Ty), Ptr: unwrap(P: Pointer), IdxList, Name));
4199}
4200
4201LLVMValueRef LLVMBuildGEPWithNoWrapFlags(LLVMBuilderRef B, LLVMTypeRef Ty,
4202 LLVMValueRef Pointer,
4203 LLVMValueRef *Indices,
4204 unsigned NumIndices, const char *Name,
4205 LLVMGEPNoWrapFlags NoWrapFlags) {
4206 ArrayRef<Value *> IdxList(unwrap(Vals: Indices), NumIndices);
4207 return wrap(P: unwrap(P: B)->CreateGEP(Ty: unwrap(P: Ty), Ptr: unwrap(P: Pointer), IdxList, Name,
4208 NW: mapFromLLVMGEPNoWrapFlags(GEPFlags: NoWrapFlags)));
4209}
4210
4211LLVMValueRef LLVMBuildStructGEP2(LLVMBuilderRef B, LLVMTypeRef Ty,
4212 LLVMValueRef Pointer, unsigned Idx,
4213 const char *Name) {
4214 return wrap(
4215 P: unwrap(P: B)->CreateStructGEP(Ty: unwrap(P: Ty), Ptr: unwrap(P: Pointer), Idx, Name));
4216}
4217
4218LLVMValueRef LLVMBuildGlobalString(LLVMBuilderRef B, const char *Str,
4219 const char *Name) {
4220 return wrap(P: unwrap(P: B)->CreateGlobalString(Str, Name));
4221}
4222
4223LLVMValueRef LLVMBuildGlobalStringPtr(LLVMBuilderRef B, const char *Str,
4224 const char *Name) {
4225 return wrap(P: unwrap(P: B)->CreateGlobalString(Str, Name));
4226}
4227
4228LLVMBool LLVMGetVolatile(LLVMValueRef Inst) {
4229 return cast<Instruction>(Val: unwrap(P: Inst))->isVolatile();
4230}
4231
4232void LLVMSetVolatile(LLVMValueRef MemAccessInst, LLVMBool isVolatile) {
4233 Value *P = unwrap(P: MemAccessInst);
4234 if (LoadInst *LI = dyn_cast<LoadInst>(Val: P))
4235 return LI->setVolatile(isVolatile);
4236 if (StoreInst *SI = dyn_cast<StoreInst>(Val: P))
4237 return SI->setVolatile(isVolatile);
4238 if (AtomicRMWInst *AI = dyn_cast<AtomicRMWInst>(Val: P))
4239 return AI->setVolatile(isVolatile);
4240 return cast<AtomicCmpXchgInst>(Val: P)->setVolatile(isVolatile);
4241}
4242
4243LLVMBool LLVMGetWeak(LLVMValueRef CmpXchgInst) {
4244 return unwrap<AtomicCmpXchgInst>(P: CmpXchgInst)->isWeak();
4245}
4246
4247void LLVMSetWeak(LLVMValueRef CmpXchgInst, LLVMBool isWeak) {
4248 return unwrap<AtomicCmpXchgInst>(P: CmpXchgInst)->setWeak(isWeak);
4249}
4250
4251LLVMAtomicOrdering LLVMGetOrdering(LLVMValueRef MemAccessInst) {
4252 Value *P = unwrap(P: MemAccessInst);
4253 AtomicOrdering O;
4254 if (LoadInst *LI = dyn_cast<LoadInst>(Val: P))
4255 O = LI->getOrdering();
4256 else if (StoreInst *SI = dyn_cast<StoreInst>(Val: P))
4257 O = SI->getOrdering();
4258 else if (FenceInst *FI = dyn_cast<FenceInst>(Val: P))
4259 O = FI->getOrdering();
4260 else
4261 O = cast<AtomicRMWInst>(Val: P)->getOrdering();
4262 return mapToLLVMOrdering(Ordering: O);
4263}
4264
4265void LLVMSetOrdering(LLVMValueRef MemAccessInst, LLVMAtomicOrdering Ordering) {
4266 Value *P = unwrap(P: MemAccessInst);
4267 AtomicOrdering O = mapFromLLVMOrdering(Ordering);
4268
4269 if (LoadInst *LI = dyn_cast<LoadInst>(Val: P))
4270 return LI->setOrdering(O);
4271 else if (FenceInst *FI = dyn_cast<FenceInst>(Val: P))
4272 return FI->setOrdering(O);
4273 else if (AtomicRMWInst *ARWI = dyn_cast<AtomicRMWInst>(Val: P))
4274 return ARWI->setOrdering(O);
4275 return cast<StoreInst>(Val: P)->setOrdering(O);
4276}
4277
4278LLVMAtomicRMWBinOp LLVMGetAtomicRMWBinOp(LLVMValueRef Inst) {
4279 return mapToLLVMRMWBinOp(BinOp: unwrap<AtomicRMWInst>(P: Inst)->getOperation());
4280}
4281
4282void LLVMSetAtomicRMWBinOp(LLVMValueRef Inst, LLVMAtomicRMWBinOp BinOp) {
4283 unwrap<AtomicRMWInst>(P: Inst)->setOperation(mapFromLLVMRMWBinOp(BinOp));
4284}
4285
4286/*--.. Casts ...............................................................--*/
4287
4288LLVMValueRef LLVMBuildTrunc(LLVMBuilderRef B, LLVMValueRef Val,
4289 LLVMTypeRef DestTy, const char *Name) {
4290 return wrap(P: unwrap(P: B)->CreateTrunc(V: unwrap(P: Val), DestTy: unwrap(P: DestTy), Name));
4291}
4292
4293LLVMValueRef LLVMBuildZExt(LLVMBuilderRef B, LLVMValueRef Val,
4294 LLVMTypeRef DestTy, const char *Name) {
4295 return wrap(P: unwrap(P: B)->CreateZExt(V: unwrap(P: Val), DestTy: unwrap(P: DestTy), Name));
4296}
4297
4298LLVMValueRef LLVMBuildSExt(LLVMBuilderRef B, LLVMValueRef Val,
4299 LLVMTypeRef DestTy, const char *Name) {
4300 return wrap(P: unwrap(P: B)->CreateSExt(V: unwrap(P: Val), DestTy: unwrap(P: DestTy), Name));
4301}
4302
4303LLVMValueRef LLVMBuildFPToUI(LLVMBuilderRef B, LLVMValueRef Val,
4304 LLVMTypeRef DestTy, const char *Name) {
4305 return wrap(P: unwrap(P: B)->CreateFPToUI(V: unwrap(P: Val), DestTy: unwrap(P: DestTy), Name));
4306}
4307
4308LLVMValueRef LLVMBuildFPToSI(LLVMBuilderRef B, LLVMValueRef Val,
4309 LLVMTypeRef DestTy, const char *Name) {
4310 return wrap(P: unwrap(P: B)->CreateFPToSI(V: unwrap(P: Val), DestTy: unwrap(P: DestTy), Name));
4311}
4312
4313LLVMValueRef LLVMBuildUIToFP(LLVMBuilderRef B, LLVMValueRef Val,
4314 LLVMTypeRef DestTy, const char *Name) {
4315 return wrap(P: unwrap(P: B)->CreateUIToFP(V: unwrap(P: Val), DestTy: unwrap(P: DestTy), Name));
4316}
4317
4318LLVMValueRef LLVMBuildSIToFP(LLVMBuilderRef B, LLVMValueRef Val,
4319 LLVMTypeRef DestTy, const char *Name) {
4320 return wrap(P: unwrap(P: B)->CreateSIToFP(V: unwrap(P: Val), DestTy: unwrap(P: DestTy), Name));
4321}
4322
4323LLVMValueRef LLVMBuildFPTrunc(LLVMBuilderRef B, LLVMValueRef Val,
4324 LLVMTypeRef DestTy, const char *Name) {
4325 return wrap(P: unwrap(P: B)->CreateFPTrunc(V: unwrap(P: Val), DestTy: unwrap(P: DestTy), Name));
4326}
4327
4328LLVMValueRef LLVMBuildFPExt(LLVMBuilderRef B, LLVMValueRef Val,
4329 LLVMTypeRef DestTy, const char *Name) {
4330 return wrap(P: unwrap(P: B)->CreateFPExt(V: unwrap(P: Val), DestTy: unwrap(P: DestTy), Name));
4331}
4332
4333LLVMValueRef LLVMBuildPtrToInt(LLVMBuilderRef B, LLVMValueRef Val,
4334 LLVMTypeRef DestTy, const char *Name) {
4335 return wrap(P: unwrap(P: B)->CreatePtrToInt(V: unwrap(P: Val), DestTy: unwrap(P: DestTy), Name));
4336}
4337
4338LLVMValueRef LLVMBuildIntToPtr(LLVMBuilderRef B, LLVMValueRef Val,
4339 LLVMTypeRef DestTy, const char *Name) {
4340 return wrap(P: unwrap(P: B)->CreateIntToPtr(V: unwrap(P: Val), DestTy: unwrap(P: DestTy), Name));
4341}
4342
4343LLVMValueRef LLVMBuildBitCast(LLVMBuilderRef B, LLVMValueRef Val,
4344 LLVMTypeRef DestTy, const char *Name) {
4345 return wrap(P: unwrap(P: B)->CreateBitCast(V: unwrap(P: Val), DestTy: unwrap(P: DestTy), Name));
4346}
4347
4348LLVMValueRef LLVMBuildAddrSpaceCast(LLVMBuilderRef B, LLVMValueRef Val,
4349 LLVMTypeRef DestTy, const char *Name) {
4350 return wrap(P: unwrap(P: B)->CreateAddrSpaceCast(V: unwrap(P: Val), DestTy: unwrap(P: DestTy), Name));
4351}
4352
4353LLVMValueRef LLVMBuildZExtOrBitCast(LLVMBuilderRef B, LLVMValueRef Val,
4354 LLVMTypeRef DestTy, const char *Name) {
4355 return wrap(P: unwrap(P: B)->CreateZExtOrBitCast(V: unwrap(P: Val), DestTy: unwrap(P: DestTy),
4356 Name));
4357}
4358
4359LLVMValueRef LLVMBuildSExtOrBitCast(LLVMBuilderRef B, LLVMValueRef Val,
4360 LLVMTypeRef DestTy, const char *Name) {
4361 return wrap(P: unwrap(P: B)->CreateSExtOrBitCast(V: unwrap(P: Val), DestTy: unwrap(P: DestTy),
4362 Name));
4363}
4364
4365LLVMValueRef LLVMBuildTruncOrBitCast(LLVMBuilderRef B, LLVMValueRef Val,
4366 LLVMTypeRef DestTy, const char *Name) {
4367 return wrap(P: unwrap(P: B)->CreateTruncOrBitCast(V: unwrap(P: Val), DestTy: unwrap(P: DestTy),
4368 Name));
4369}
4370
4371LLVMValueRef LLVMBuildCast(LLVMBuilderRef B, LLVMOpcode Op, LLVMValueRef Val,
4372 LLVMTypeRef DestTy, const char *Name) {
4373 return wrap(P: unwrap(P: B)->CreateCast(Op: Instruction::CastOps(map_from_llvmopcode(code: Op)), V: unwrap(P: Val),
4374 DestTy: unwrap(P: DestTy), Name));
4375}
4376
4377LLVMValueRef LLVMBuildPointerCast(LLVMBuilderRef B, LLVMValueRef Val,
4378 LLVMTypeRef DestTy, const char *Name) {
4379 return wrap(P: unwrap(P: B)->CreatePointerCast(V: unwrap(P: Val), DestTy: unwrap(P: DestTy), Name));
4380}
4381
4382LLVMValueRef LLVMBuildIntCast2(LLVMBuilderRef B, LLVMValueRef Val,
4383 LLVMTypeRef DestTy, LLVMBool IsSigned,
4384 const char *Name) {
4385 return wrap(
4386 P: unwrap(P: B)->CreateIntCast(V: unwrap(P: Val), DestTy: unwrap(P: DestTy), isSigned: IsSigned, Name));
4387}
4388
4389LLVMValueRef LLVMBuildIntCast(LLVMBuilderRef B, LLVMValueRef Val,
4390 LLVMTypeRef DestTy, const char *Name) {
4391 return wrap(P: unwrap(P: B)->CreateIntCast(V: unwrap(P: Val), DestTy: unwrap(P: DestTy),
4392 /*isSigned*/true, Name));
4393}
4394
4395LLVMValueRef LLVMBuildFPCast(LLVMBuilderRef B, LLVMValueRef Val,
4396 LLVMTypeRef DestTy, const char *Name) {
4397 return wrap(P: unwrap(P: B)->CreateFPCast(V: unwrap(P: Val), DestTy: unwrap(P: DestTy), Name));
4398}
4399
4400LLVMOpcode LLVMGetCastOpcode(LLVMValueRef Src, LLVMBool SrcIsSigned,
4401 LLVMTypeRef DestTy, LLVMBool DestIsSigned) {
4402 return map_to_llvmopcode(opcode: CastInst::getCastOpcode(
4403 Val: unwrap(P: Src), SrcIsSigned, Ty: unwrap(P: DestTy), DstIsSigned: DestIsSigned));
4404}
4405
4406/*--.. Comparisons .........................................................--*/
4407
4408LLVMValueRef LLVMBuildICmp(LLVMBuilderRef B, LLVMIntPredicate Op,
4409 LLVMValueRef LHS, LLVMValueRef RHS,
4410 const char *Name) {
4411 return wrap(P: unwrap(P: B)->CreateICmp(P: static_cast<ICmpInst::Predicate>(Op),
4412 LHS: unwrap(P: LHS), RHS: unwrap(P: RHS), Name));
4413}
4414
4415LLVMValueRef LLVMBuildFCmp(LLVMBuilderRef B, LLVMRealPredicate Op,
4416 LLVMValueRef LHS, LLVMValueRef RHS,
4417 const char *Name) {
4418 return wrap(P: unwrap(P: B)->CreateFCmp(P: static_cast<FCmpInst::Predicate>(Op),
4419 LHS: unwrap(P: LHS), RHS: unwrap(P: RHS), Name));
4420}
4421
4422/*--.. Miscellaneous instructions ..........................................--*/
4423
4424LLVMValueRef LLVMBuildPhi(LLVMBuilderRef B, LLVMTypeRef Ty, const char *Name) {
4425 return wrap(P: unwrap(P: B)->CreatePHI(Ty: unwrap(P: Ty), NumReservedValues: 0, Name));
4426}
4427
4428LLVMValueRef LLVMBuildCall2(LLVMBuilderRef B, LLVMTypeRef Ty, LLVMValueRef Fn,
4429 LLVMValueRef *Args, unsigned NumArgs,
4430 const char *Name) {
4431 FunctionType *FTy = unwrap<FunctionType>(P: Ty);
4432 return wrap(P: unwrap(P: B)->CreateCall(FTy, Callee: unwrap(P: Fn),
4433 Args: ArrayRef(unwrap(Vals: Args), NumArgs), Name));
4434}
4435
4436LLVMValueRef
4437LLVMBuildCallWithOperandBundles(LLVMBuilderRef B, LLVMTypeRef Ty,
4438 LLVMValueRef Fn, LLVMValueRef *Args,
4439 unsigned NumArgs, LLVMOperandBundleRef *Bundles,
4440 unsigned NumBundles, const char *Name) {
4441 FunctionType *FTy = unwrap<FunctionType>(P: Ty);
4442 SmallVector<OperandBundleDef, 8> OBs;
4443 for (auto *Bundle : ArrayRef(Bundles, NumBundles)) {
4444 OperandBundleDef *OB = unwrap(P: Bundle);
4445 OBs.push_back(Elt: *OB);
4446 }
4447 return wrap(P: unwrap(P: B)->CreateCall(
4448 FTy, Callee: unwrap(P: Fn), Args: ArrayRef(unwrap(Vals: Args), NumArgs), OpBundles: OBs, Name));
4449}
4450
4451LLVMValueRef LLVMBuildSelect(LLVMBuilderRef B, LLVMValueRef If,
4452 LLVMValueRef Then, LLVMValueRef Else,
4453 const char *Name) {
4454 return wrap(P: unwrap(P: B)->CreateSelect(C: unwrap(P: If), True: unwrap(P: Then), False: unwrap(P: Else),
4455 Name));
4456}
4457
4458LLVMValueRef LLVMBuildVAArg(LLVMBuilderRef B, LLVMValueRef List,
4459 LLVMTypeRef Ty, const char *Name) {
4460 return wrap(P: unwrap(P: B)->CreateVAArg(List: unwrap(P: List), Ty: unwrap(P: Ty), Name));
4461}
4462
4463LLVMValueRef LLVMBuildExtractElement(LLVMBuilderRef B, LLVMValueRef VecVal,
4464 LLVMValueRef Index, const char *Name) {
4465 return wrap(P: unwrap(P: B)->CreateExtractElement(Vec: unwrap(P: VecVal), Idx: unwrap(P: Index),
4466 Name));
4467}
4468
4469LLVMValueRef LLVMBuildInsertElement(LLVMBuilderRef B, LLVMValueRef VecVal,
4470 LLVMValueRef EltVal, LLVMValueRef Index,
4471 const char *Name) {
4472 return wrap(P: unwrap(P: B)->CreateInsertElement(Vec: unwrap(P: VecVal), NewElt: unwrap(P: EltVal),
4473 Idx: unwrap(P: Index), Name));
4474}
4475
4476LLVMValueRef LLVMBuildShuffleVector(LLVMBuilderRef B, LLVMValueRef V1,
4477 LLVMValueRef V2, LLVMValueRef Mask,
4478 const char *Name) {
4479 return wrap(P: unwrap(P: B)->CreateShuffleVector(V1: unwrap(P: V1), V2: unwrap(P: V2),
4480 Mask: unwrap(P: Mask), Name));
4481}
4482
4483LLVMValueRef LLVMBuildExtractValue(LLVMBuilderRef B, LLVMValueRef AggVal,
4484 unsigned Index, const char *Name) {
4485 return wrap(P: unwrap(P: B)->CreateExtractValue(Agg: unwrap(P: AggVal), Idxs: Index, Name));
4486}
4487
4488LLVMValueRef LLVMBuildInsertValue(LLVMBuilderRef B, LLVMValueRef AggVal,
4489 LLVMValueRef EltVal, unsigned Index,
4490 const char *Name) {
4491 return wrap(P: unwrap(P: B)->CreateInsertValue(Agg: unwrap(P: AggVal), Val: unwrap(P: EltVal),
4492 Idxs: Index, Name));
4493}
4494
4495LLVMValueRef LLVMBuildFreeze(LLVMBuilderRef B, LLVMValueRef Val,
4496 const char *Name) {
4497 return wrap(P: unwrap(P: B)->CreateFreeze(V: unwrap(P: Val), Name));
4498}
4499
4500LLVMValueRef LLVMBuildIsNull(LLVMBuilderRef B, LLVMValueRef Val,
4501 const char *Name) {
4502 return wrap(P: unwrap(P: B)->CreateIsNull(Arg: unwrap(P: Val), Name));
4503}
4504
4505LLVMValueRef LLVMBuildIsNotNull(LLVMBuilderRef B, LLVMValueRef Val,
4506 const char *Name) {
4507 return wrap(P: unwrap(P: B)->CreateIsNotNull(Arg: unwrap(P: Val), Name));
4508}
4509
4510LLVMValueRef LLVMBuildPtrDiff2(LLVMBuilderRef B, LLVMTypeRef ElemTy,
4511 LLVMValueRef LHS, LLVMValueRef RHS,
4512 const char *Name) {
4513 IRBuilderBase *Builder = unwrap(P: B);
4514 Value *Diff =
4515 Builder->CreatePtrDiff(ElemTy: unwrap(P: ElemTy), LHS: unwrap(P: LHS), RHS: unwrap(P: RHS), Name);
4516 return wrap(P: Builder->CreateSExtOrTrunc(V: Diff, DestTy: Builder->getInt64Ty()));
4517}
4518
4519LLVMValueRef LLVMBuildAtomicRMW(LLVMBuilderRef B,LLVMAtomicRMWBinOp op,
4520 LLVMValueRef PTR, LLVMValueRef Val,
4521 LLVMAtomicOrdering ordering,
4522 LLVMBool singleThread) {
4523 AtomicRMWInst::BinOp intop = mapFromLLVMRMWBinOp(BinOp: op);
4524 return wrap(P: unwrap(P: B)->CreateAtomicRMW(
4525 Op: intop, Ptr: unwrap(P: PTR), Val: unwrap(P: Val), Align: MaybeAlign(),
4526 Ordering: mapFromLLVMOrdering(Ordering: ordering),
4527 SSID: singleThread ? SyncScope::SingleThread : SyncScope::System));
4528}
4529
4530LLVMValueRef LLVMBuildAtomicRMWSyncScope(LLVMBuilderRef B,
4531 LLVMAtomicRMWBinOp op,
4532 LLVMValueRef PTR, LLVMValueRef Val,
4533 LLVMAtomicOrdering ordering,
4534 unsigned SSID) {
4535 AtomicRMWInst::BinOp intop = mapFromLLVMRMWBinOp(BinOp: op);
4536 return wrap(P: unwrap(P: B)->CreateAtomicRMW(Op: intop, Ptr: unwrap(P: PTR), Val: unwrap(P: Val),
4537 Align: MaybeAlign(),
4538 Ordering: mapFromLLVMOrdering(Ordering: ordering), SSID));
4539}
4540
4541LLVMValueRef LLVMBuildAtomicCmpXchg(LLVMBuilderRef B, LLVMValueRef Ptr,
4542 LLVMValueRef Cmp, LLVMValueRef New,
4543 LLVMAtomicOrdering SuccessOrdering,
4544 LLVMAtomicOrdering FailureOrdering,
4545 LLVMBool singleThread) {
4546
4547 return wrap(P: unwrap(P: B)->CreateAtomicCmpXchg(
4548 Ptr: unwrap(P: Ptr), Cmp: unwrap(P: Cmp), New: unwrap(P: New), Align: MaybeAlign(),
4549 SuccessOrdering: mapFromLLVMOrdering(Ordering: SuccessOrdering),
4550 FailureOrdering: mapFromLLVMOrdering(Ordering: FailureOrdering),
4551 SSID: singleThread ? SyncScope::SingleThread : SyncScope::System));
4552}
4553
4554LLVMValueRef LLVMBuildAtomicCmpXchgSyncScope(LLVMBuilderRef B, LLVMValueRef Ptr,
4555 LLVMValueRef Cmp, LLVMValueRef New,
4556 LLVMAtomicOrdering SuccessOrdering,
4557 LLVMAtomicOrdering FailureOrdering,
4558 unsigned SSID) {
4559 return wrap(P: unwrap(P: B)->CreateAtomicCmpXchg(
4560 Ptr: unwrap(P: Ptr), Cmp: unwrap(P: Cmp), New: unwrap(P: New), Align: MaybeAlign(),
4561 SuccessOrdering: mapFromLLVMOrdering(Ordering: SuccessOrdering),
4562 FailureOrdering: mapFromLLVMOrdering(Ordering: FailureOrdering), SSID));
4563}
4564
4565unsigned LLVMGetNumMaskElements(LLVMValueRef SVInst) {
4566 Value *P = unwrap(P: SVInst);
4567 ShuffleVectorInst *I = cast<ShuffleVectorInst>(Val: P);
4568 return I->getShuffleMask().size();
4569}
4570
4571int LLVMGetMaskValue(LLVMValueRef SVInst, unsigned Elt) {
4572 Value *P = unwrap(P: SVInst);
4573 ShuffleVectorInst *I = cast<ShuffleVectorInst>(Val: P);
4574 return I->getMaskValue(Elt);
4575}
4576
4577int LLVMGetUndefMaskElem(void) { return PoisonMaskElem; }
4578
4579LLVMBool LLVMIsAtomic(LLVMValueRef Inst) {
4580 return unwrap<Instruction>(P: Inst)->isAtomic();
4581}
4582
4583LLVMBool LLVMIsAtomicSingleThread(LLVMValueRef AtomicInst) {
4584 // Backwards compatibility: return false for non-atomic instructions
4585 Instruction *I = unwrap<Instruction>(P: AtomicInst);
4586 if (!I->isAtomic())
4587 return 0;
4588
4589 return *getAtomicSyncScopeID(I) == SyncScope::SingleThread;
4590}
4591
4592void LLVMSetAtomicSingleThread(LLVMValueRef AtomicInst, LLVMBool NewValue) {
4593 // Backwards compatibility: ignore non-atomic instructions
4594 Instruction *I = unwrap<Instruction>(P: AtomicInst);
4595 if (!I->isAtomic())
4596 return;
4597
4598 SyncScope::ID SSID = NewValue ? SyncScope::SingleThread : SyncScope::System;
4599 setAtomicSyncScopeID(I, SSID);
4600}
4601
4602unsigned LLVMGetAtomicSyncScopeID(LLVMValueRef AtomicInst) {
4603 Instruction *I = unwrap<Instruction>(P: AtomicInst);
4604 assert(I->isAtomic() && "Expected an atomic instruction");
4605 return *getAtomicSyncScopeID(I);
4606}
4607
4608void LLVMSetAtomicSyncScopeID(LLVMValueRef AtomicInst, unsigned SSID) {
4609 Instruction *I = unwrap<Instruction>(P: AtomicInst);
4610 assert(I->isAtomic() && "Expected an atomic instruction");
4611 setAtomicSyncScopeID(I, SSID);
4612}
4613
4614LLVMAtomicOrdering LLVMGetCmpXchgSuccessOrdering(LLVMValueRef CmpXchgInst) {
4615 Value *P = unwrap(P: CmpXchgInst);
4616 return mapToLLVMOrdering(Ordering: cast<AtomicCmpXchgInst>(Val: P)->getSuccessOrdering());
4617}
4618
4619void LLVMSetCmpXchgSuccessOrdering(LLVMValueRef CmpXchgInst,
4620 LLVMAtomicOrdering Ordering) {
4621 Value *P = unwrap(P: CmpXchgInst);
4622 AtomicOrdering O = mapFromLLVMOrdering(Ordering);
4623
4624 return cast<AtomicCmpXchgInst>(Val: P)->setSuccessOrdering(O);
4625}
4626
4627LLVMAtomicOrdering LLVMGetCmpXchgFailureOrdering(LLVMValueRef CmpXchgInst) {
4628 Value *P = unwrap(P: CmpXchgInst);
4629 return mapToLLVMOrdering(Ordering: cast<AtomicCmpXchgInst>(Val: P)->getFailureOrdering());
4630}
4631
4632void LLVMSetCmpXchgFailureOrdering(LLVMValueRef CmpXchgInst,
4633 LLVMAtomicOrdering Ordering) {
4634 Value *P = unwrap(P: CmpXchgInst);
4635 AtomicOrdering O = mapFromLLVMOrdering(Ordering);
4636
4637 return cast<AtomicCmpXchgInst>(Val: P)->setFailureOrdering(O);
4638}
4639
4640/*===-- Module providers --------------------------------------------------===*/
4641
4642LLVMModuleProviderRef
4643LLVMCreateModuleProviderForExistingModule(LLVMModuleRef M) {
4644 return reinterpret_cast<LLVMModuleProviderRef>(M);
4645}
4646
4647void LLVMDisposeModuleProvider(LLVMModuleProviderRef MP) {
4648 delete unwrap(MP);
4649}
4650
4651
4652/*===-- Memory buffers ----------------------------------------------------===*/
4653
4654LLVMBool LLVMCreateMemoryBufferWithContentsOfFile(
4655 const char *Path,
4656 LLVMMemoryBufferRef *OutMemBuf,
4657 char **OutMessage) {
4658
4659 ErrorOr<std::unique_ptr<MemoryBuffer>> MBOrErr = MemoryBuffer::getFile(Filename: Path);
4660 if (std::error_code EC = MBOrErr.getError()) {
4661 *OutMessage = strdup(s: EC.message().c_str());
4662 return 1;
4663 }
4664 *OutMemBuf = wrap(P: MBOrErr.get().release());
4665 return 0;
4666}
4667
4668LLVMBool LLVMCreateMemoryBufferWithSTDIN(LLVMMemoryBufferRef *OutMemBuf,
4669 char **OutMessage) {
4670 ErrorOr<std::unique_ptr<MemoryBuffer>> MBOrErr = MemoryBuffer::getSTDIN();
4671 if (std::error_code EC = MBOrErr.getError()) {
4672 *OutMessage = strdup(s: EC.message().c_str());
4673 return 1;
4674 }
4675 *OutMemBuf = wrap(P: MBOrErr.get().release());
4676 return 0;
4677}
4678
4679LLVMMemoryBufferRef LLVMCreateMemoryBufferWithMemoryRange(
4680 const char *InputData,
4681 size_t InputDataLength,
4682 const char *BufferName,
4683 LLVMBool RequiresNullTerminator) {
4684
4685 return wrap(P: MemoryBuffer::getMemBuffer(InputData: StringRef(InputData, InputDataLength),
4686 BufferName: StringRef(BufferName),
4687 RequiresNullTerminator).release());
4688}
4689
4690LLVMMemoryBufferRef LLVMCreateMemoryBufferWithMemoryRangeCopy(
4691 const char *InputData,
4692 size_t InputDataLength,
4693 const char *BufferName) {
4694
4695 return wrap(
4696 P: MemoryBuffer::getMemBufferCopy(InputData: StringRef(InputData, InputDataLength),
4697 BufferName: StringRef(BufferName)).release());
4698}
4699
4700const char *LLVMGetBufferStart(LLVMMemoryBufferRef MemBuf) {
4701 return unwrap(P: MemBuf)->getBufferStart();
4702}
4703
4704size_t LLVMGetBufferSize(LLVMMemoryBufferRef MemBuf) {
4705 return unwrap(P: MemBuf)->getBufferSize();
4706}
4707
4708void LLVMDisposeMemoryBuffer(LLVMMemoryBufferRef MemBuf) {
4709 delete unwrap(P: MemBuf);
4710}
4711
4712/*===-- Pass Manager ------------------------------------------------------===*/
4713
4714LLVMPassManagerRef LLVMCreatePassManager() {
4715 return wrap(P: new legacy::PassManager());
4716}
4717
4718LLVMPassManagerRef LLVMCreateFunctionPassManagerForModule(LLVMModuleRef M) {
4719 return wrap(P: new legacy::FunctionPassManager(unwrap(P: M)));
4720}
4721
4722LLVMPassManagerRef LLVMCreateFunctionPassManager(LLVMModuleProviderRef P) {
4723 return LLVMCreateFunctionPassManagerForModule(
4724 M: reinterpret_cast<LLVMModuleRef>(P));
4725}
4726
4727LLVMBool LLVMRunPassManager(LLVMPassManagerRef PM, LLVMModuleRef M) {
4728 return unwrap<legacy::PassManager>(P: PM)->run(M&: *unwrap(P: M));
4729}
4730
4731LLVMBool LLVMInitializeFunctionPassManager(LLVMPassManagerRef FPM) {
4732 return unwrap<legacy::FunctionPassManager>(P: FPM)->doInitialization();
4733}
4734
4735LLVMBool LLVMRunFunctionPassManager(LLVMPassManagerRef FPM, LLVMValueRef F) {
4736 return unwrap<legacy::FunctionPassManager>(P: FPM)->run(F&: *unwrap<Function>(P: F));
4737}
4738
4739LLVMBool LLVMFinalizeFunctionPassManager(LLVMPassManagerRef FPM) {
4740 return unwrap<legacy::FunctionPassManager>(P: FPM)->doFinalization();
4741}
4742
4743void LLVMDisposePassManager(LLVMPassManagerRef PM) {
4744 delete unwrap(P: PM);
4745}
4746
4747/*===-- Threading ------------------------------------------------------===*/
4748
4749LLVMBool LLVMStartMultithreaded() {
4750 return LLVMIsMultithreaded();
4751}
4752
4753void LLVMStopMultithreaded() {
4754}
4755
4756LLVMBool LLVMIsMultithreaded() {
4757 return llvm_is_multithreaded();
4758}
4759