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