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