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