LLVM 19.0.0git
Core.cpp
Go to the documentation of this file.
1//===-- Core.cpp ----------------------------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file implements the common infrastructure (including the C bindings)
10// for libLLVMCore.a, which implements the LLVM intermediate representation.
11//
12//===----------------------------------------------------------------------===//
13
14#include "llvm-c/Core.h"
15#include "llvm/IR/Attributes.h"
16#include "llvm/IR/BasicBlock.h"
17#include "llvm/IR/Constants.h"
22#include "llvm/IR/GlobalAlias.h"
24#include "llvm/IR/IRBuilder.h"
25#include "llvm/IR/InlineAsm.h"
27#include "llvm/IR/LLVMContext.h"
29#include "llvm/IR/Module.h"
31#include "llvm/PassRegistry.h"
32#include "llvm/Support/Debug.h"
39#include <cassert>
40#include <cstdlib>
41#include <cstring>
42#include <system_error>
43
44using namespace llvm;
45
47
48#define DEBUG_TYPE "ir"
49
56}
57
60}
61
62/*===-- Version query -----------------------------------------------------===*/
63
64void LLVMGetVersion(unsigned *Major, unsigned *Minor, unsigned *Patch) {
65 if (Major)
66 *Major = LLVM_VERSION_MAJOR;
67 if (Minor)
68 *Minor = LLVM_VERSION_MINOR;
69 if (Patch)
70 *Patch = LLVM_VERSION_PATCH;
71}
72
73/*===-- Error handling ----------------------------------------------------===*/
74
75char *LLVMCreateMessage(const char *Message) {
76 return strdup(Message);
77}
78
79void LLVMDisposeMessage(char *Message) {
80 free(Message);
81}
82
83
84/*===-- Operations on contexts --------------------------------------------===*/
85
87 static LLVMContext GlobalContext;
88 return GlobalContext;
89}
90
92 return wrap(new LLVMContext());
93}
94
96
99 void *DiagnosticContext) {
100 unwrap(C)->setDiagnosticHandlerCallBack(
102 Handler),
103 DiagnosticContext);
104}
105
107 return LLVM_EXTENSION reinterpret_cast<LLVMDiagnosticHandler>(
108 unwrap(C)->getDiagnosticHandlerCallBack());
109}
110
112 return unwrap(C)->getDiagnosticContext();
113}
114
116 void *OpaqueHandle) {
117 auto YieldCallback =
118 LLVM_EXTENSION reinterpret_cast<LLVMContext::YieldCallbackTy>(Callback);
119 unwrap(C)->setYieldCallback(YieldCallback, OpaqueHandle);
120}
121
123 return unwrap(C)->shouldDiscardValueNames();
124}
125
127 unwrap(C)->setDiscardValueNames(Discard);
128}
129
131 delete unwrap(C);
132}
133
135 unsigned SLen) {
136 return unwrap(C)->getMDKindID(StringRef(Name, SLen));
137}
138
139unsigned LLVMGetMDKindID(const char *Name, unsigned SLen) {
141}
142
143unsigned LLVMGetEnumAttributeKindForName(const char *Name, size_t SLen) {
145}
146
148 return Attribute::AttrKind::EndAttrKinds;
149}
150
152 uint64_t Val) {
153 auto &Ctx = *unwrap(C);
154 auto AttrKind = (Attribute::AttrKind)KindID;
155 return wrap(Attribute::get(Ctx, AttrKind, Val));
156}
157
159 return unwrap(A).getKindAsEnum();
160}
161
163 auto Attr = unwrap(A);
164 if (Attr.isEnumAttribute())
165 return 0;
166 return Attr.getValueAsInt();
167}
168
170 LLVMTypeRef type_ref) {
171 auto &Ctx = *unwrap(C);
172 auto AttrKind = (Attribute::AttrKind)KindID;
173 return wrap(Attribute::get(Ctx, AttrKind, unwrap(type_ref)));
174}
175
177 auto Attr = unwrap(A);
178 return wrap(Attr.getValueAsType());
179}
180
182 const char *K, unsigned KLength,
183 const char *V, unsigned VLength) {
184 return wrap(Attribute::get(*unwrap(C), StringRef(K, KLength),
185 StringRef(V, VLength)));
186}
187
189 unsigned *Length) {
190 auto S = unwrap(A).getKindAsString();
191 *Length = S.size();
192 return S.data();
193}
194
196 unsigned *Length) {
197 auto S = unwrap(A).getValueAsString();
198 *Length = S.size();
199 return S.data();
200}
201
203 auto Attr = unwrap(A);
204 return Attr.isEnumAttribute() || Attr.isIntAttribute();
205}
206
208 return unwrap(A).isStringAttribute();
209}
210
212 return unwrap(A).isTypeAttribute();
213}
214
216 std::string MsgStorage;
217 raw_string_ostream Stream(MsgStorage);
219
220 unwrap(DI)->print(DP);
221 Stream.flush();
222
223 return LLVMCreateMessage(MsgStorage.c_str());
224}
225
227 LLVMDiagnosticSeverity severity;
228
229 switch(unwrap(DI)->getSeverity()) {
230 default:
231 severity = LLVMDSError;
232 break;
233 case DS_Warning:
234 severity = LLVMDSWarning;
235 break;
236 case DS_Remark:
237 severity = LLVMDSRemark;
238 break;
239 case DS_Note:
240 severity = LLVMDSNote;
241 break;
242 }
243
244 return severity;
245}
246
247/*===-- Operations on modules ---------------------------------------------===*/
248
250 return wrap(new Module(ModuleID, getGlobalContext()));
251}
252
255 return wrap(new Module(ModuleID, *unwrap(C)));
256}
257
259 delete unwrap(M);
260}
261
262const char *LLVMGetModuleIdentifier(LLVMModuleRef M, size_t *Len) {
263 auto &Str = unwrap(M)->getModuleIdentifier();
264 *Len = Str.length();
265 return Str.c_str();
266}
267
268void LLVMSetModuleIdentifier(LLVMModuleRef M, const char *Ident, size_t Len) {
269 unwrap(M)->setModuleIdentifier(StringRef(Ident, Len));
270}
271
272const char *LLVMGetSourceFileName(LLVMModuleRef M, size_t *Len) {
273 auto &Str = unwrap(M)->getSourceFileName();
274 *Len = Str.length();
275 return Str.c_str();
276}
277
278void LLVMSetSourceFileName(LLVMModuleRef M, const char *Name, size_t Len) {
279 unwrap(M)->setSourceFileName(StringRef(Name, Len));
280}
281
282/*--.. Data layout .........................................................--*/
284 return unwrap(M)->getDataLayoutStr().c_str();
285}
286
288 return LLVMGetDataLayoutStr(M);
289}
290
291void LLVMSetDataLayout(LLVMModuleRef M, const char *DataLayoutStr) {
292 unwrap(M)->setDataLayout(DataLayoutStr);
293}
294
295/*--.. Target triple .......................................................--*/
297 return unwrap(M)->getTargetTriple().c_str();
298}
299
300void LLVMSetTarget(LLVMModuleRef M, const char *Triple) {
301 unwrap(M)->setTargetTriple(Triple);
302}
303
304/*--.. Module flags ........................................................--*/
307 const char *Key;
308 size_t KeyLen;
310};
311
314 switch (Behavior) {
316 return Module::ModFlagBehavior::Error;
318 return Module::ModFlagBehavior::Warning;
320 return Module::ModFlagBehavior::Require;
322 return Module::ModFlagBehavior::Override;
324 return Module::ModFlagBehavior::Append;
326 return Module::ModFlagBehavior::AppendUnique;
327 }
328 llvm_unreachable("Unknown LLVMModuleFlagBehavior");
329}
330
333 switch (Behavior) {
334 case Module::ModFlagBehavior::Error:
336 case Module::ModFlagBehavior::Warning:
338 case Module::ModFlagBehavior::Require:
340 case Module::ModFlagBehavior::Override:
342 case Module::ModFlagBehavior::Append:
344 case Module::ModFlagBehavior::AppendUnique:
346 default:
347 llvm_unreachable("Unhandled Flag Behavior");
348 }
349}
350
353 unwrap(M)->getModuleFlagsMetadata(MFEs);
354
356 safe_malloc(MFEs.size() * sizeof(LLVMOpaqueModuleFlagEntry)));
357 for (unsigned i = 0; i < MFEs.size(); ++i) {
358 const auto &ModuleFlag = MFEs[i];
359 Result[i].Behavior = map_from_llvmModFlagBehavior(ModuleFlag.Behavior);
360 Result[i].Key = ModuleFlag.Key->getString().data();
361 Result[i].KeyLen = ModuleFlag.Key->getString().size();
362 Result[i].Metadata = wrap(ModuleFlag.Val);
363 }
364 *Len = MFEs.size();
365 return Result;
366}
367
369 free(Entries);
370}
371
374 unsigned Index) {
376 static_cast<LLVMOpaqueModuleFlagEntry>(Entries[Index]);
377 return MFE.Behavior;
378}
379
381 unsigned Index, size_t *Len) {
383 static_cast<LLVMOpaqueModuleFlagEntry>(Entries[Index]);
384 *Len = MFE.KeyLen;
385 return MFE.Key;
386}
387
389 unsigned Index) {
391 static_cast<LLVMOpaqueModuleFlagEntry>(Entries[Index]);
392 return MFE.Metadata;
393}
394
396 const char *Key, size_t KeyLen) {
397 return wrap(unwrap(M)->getModuleFlag({Key, KeyLen}));
398}
399
401 const char *Key, size_t KeyLen,
402 LLVMMetadataRef Val) {
403 unwrap(M)->addModuleFlag(map_to_llvmModFlagBehavior(Behavior),
404 {Key, KeyLen}, unwrap(Val));
405}
406
408 return unwrap(M)->IsNewDbgInfoFormat;
409}
410
412 unwrap(M)->setIsNewDbgInfoFormat(UseNewFormat);
413}
414
415/*--.. Printing modules ....................................................--*/
416
418 unwrap(M)->print(errs(), nullptr,
419 /*ShouldPreserveUseListOrder=*/false, /*IsForDebug=*/true);
420}
421
423 char **ErrorMessage) {
424 std::error_code EC;
425 raw_fd_ostream dest(Filename, EC, sys::fs::OF_TextWithCRLF);
426 if (EC) {
427 *ErrorMessage = strdup(EC.message().c_str());
428 return true;
429 }
430
431 unwrap(M)->print(dest, nullptr);
432
433 dest.close();
434
435 if (dest.has_error()) {
436 std::string E = "Error printing to file: " + dest.error().message();
437 *ErrorMessage = strdup(E.c_str());
438 return true;
439 }
440
441 return false;
442}
443
445 std::string buf;
446 raw_string_ostream os(buf);
447
448 unwrap(M)->print(os, nullptr);
449 os.flush();
450
451 return strdup(buf.c_str());
452}
453
454/*--.. Operations on inline assembler ......................................--*/
455void LLVMSetModuleInlineAsm2(LLVMModuleRef M, const char *Asm, size_t Len) {
456 unwrap(M)->setModuleInlineAsm(StringRef(Asm, Len));
457}
458
459void LLVMSetModuleInlineAsm(LLVMModuleRef M, const char *Asm) {
460 unwrap(M)->setModuleInlineAsm(StringRef(Asm));
461}
462
463void LLVMAppendModuleInlineAsm(LLVMModuleRef M, const char *Asm, size_t Len) {
464 unwrap(M)->appendModuleInlineAsm(StringRef(Asm, Len));
465}
466
467const char *LLVMGetModuleInlineAsm(LLVMModuleRef M, size_t *Len) {
468 auto &Str = unwrap(M)->getModuleInlineAsm();
469 *Len = Str.length();
470 return Str.c_str();
471}
472
473LLVMValueRef LLVMGetInlineAsm(LLVMTypeRef Ty, const char *AsmString,
474 size_t AsmStringSize, const char *Constraints,
475 size_t ConstraintsSize, LLVMBool HasSideEffects,
476 LLVMBool IsAlignStack,
477 LLVMInlineAsmDialect Dialect, LLVMBool CanThrow) {
479 switch (Dialect) {
482 break;
485 break;
486 }
487 return wrap(InlineAsm::get(unwrap<FunctionType>(Ty),
488 StringRef(AsmString, AsmStringSize),
489 StringRef(Constraints, ConstraintsSize),
490 HasSideEffects, IsAlignStack, AD, CanThrow));
491}
492
493const char *LLVMGetInlineAsmAsmString(LLVMValueRef InlineAsmVal, size_t *Len) {
494
495 Value *Val = unwrap<Value>(InlineAsmVal);
496 const std::string &AsmString = cast<InlineAsm>(Val)->getAsmString();
497
498 *Len = AsmString.length();
499 return AsmString.c_str();
500}
501
503 size_t *Len) {
504 Value *Val = unwrap<Value>(InlineAsmVal);
505 const std::string &ConstraintString =
506 cast<InlineAsm>(Val)->getConstraintString();
507
508 *Len = ConstraintString.length();
509 return ConstraintString.c_str();
510}
511
513
514 Value *Val = unwrap<Value>(InlineAsmVal);
515 InlineAsm::AsmDialect Dialect = cast<InlineAsm>(Val)->getDialect();
516
517 switch (Dialect) {
522 }
523
524 llvm_unreachable("Unrecognized inline assembly dialect");
526}
527
529 Value *Val = unwrap<Value>(InlineAsmVal);
530 return (LLVMTypeRef)cast<InlineAsm>(Val)->getFunctionType();
531}
532
534 Value *Val = unwrap<Value>(InlineAsmVal);
535 return cast<InlineAsm>(Val)->hasSideEffects();
536}
537
539 Value *Val = unwrap<Value>(InlineAsmVal);
540 return cast<InlineAsm>(Val)->isAlignStack();
541}
542
544 Value *Val = unwrap<Value>(InlineAsmVal);
545 return cast<InlineAsm>(Val)->canThrow();
546}
547
548/*--.. Operations on module contexts ......................................--*/
550 return wrap(&unwrap(M)->getContext());
551}
552
553
554/*===-- Operations on types -----------------------------------------------===*/
555
556/*--.. Operations on all types (mostly) ....................................--*/
557
559 switch (unwrap(Ty)->getTypeID()) {
560 case Type::VoidTyID:
561 return LLVMVoidTypeKind;
562 case Type::HalfTyID:
563 return LLVMHalfTypeKind;
564 case Type::BFloatTyID:
565 return LLVMBFloatTypeKind;
566 case Type::FloatTyID:
567 return LLVMFloatTypeKind;
568 case Type::DoubleTyID:
569 return LLVMDoubleTypeKind;
572 case Type::FP128TyID:
573 return LLVMFP128TypeKind;
576 case Type::LabelTyID:
577 return LLVMLabelTypeKind;
581 return LLVMIntegerTypeKind;
584 case Type::StructTyID:
585 return LLVMStructTypeKind;
586 case Type::ArrayTyID:
587 return LLVMArrayTypeKind;
589 return LLVMPointerTypeKind;
591 return LLVMVectorTypeKind;
593 return LLVMX86_MMXTypeKind;
595 return LLVMX86_AMXTypeKind;
596 case Type::TokenTyID:
597 return LLVMTokenTypeKind;
603 llvm_unreachable("Typed pointers are unsupported via the C API");
604 }
605 llvm_unreachable("Unhandled TypeID.");
606}
607
609{
610 return unwrap(Ty)->isSized();
611}
612
614 return wrap(&unwrap(Ty)->getContext());
615}
616
618 return unwrap(Ty)->print(errs(), /*IsForDebug=*/true);
619}
620
622 std::string buf;
623 raw_string_ostream os(buf);
624
625 if (unwrap(Ty))
626 unwrap(Ty)->print(os);
627 else
628 os << "Printing <null> Type";
629
630 os.flush();
631
632 return strdup(buf.c_str());
633}
634
635/*--.. Operations on integer types .........................................--*/
636
639}
642}
645}
648}
651}
654}
656 return wrap(IntegerType::get(*unwrap(C), NumBits));
657}
658
661}
664}
667}
670}
673}
676}
677LLVMTypeRef LLVMIntType(unsigned NumBits) {
679}
680
681unsigned LLVMGetIntTypeWidth(LLVMTypeRef IntegerTy) {
682 return unwrap<IntegerType>(IntegerTy)->getBitWidth();
683}
684
685/*--.. Operations on real types ............................................--*/
686
689}
692}
695}
698}
701}
704}
707}
710}
713}
714
717}
720}
723}
726}
729}
732}
735}
738}
741}
742
743/*--.. Operations on function types ........................................--*/
744
746 LLVMTypeRef *ParamTypes, unsigned ParamCount,
747 LLVMBool IsVarArg) {
748 ArrayRef<Type*> Tys(unwrap(ParamTypes), ParamCount);
749 return wrap(FunctionType::get(unwrap(ReturnType), Tys, IsVarArg != 0));
750}
751
753 return unwrap<FunctionType>(FunctionTy)->isVarArg();
754}
755
757 return wrap(unwrap<FunctionType>(FunctionTy)->getReturnType());
758}
759
760unsigned LLVMCountParamTypes(LLVMTypeRef FunctionTy) {
761 return unwrap<FunctionType>(FunctionTy)->getNumParams();
762}
763
765 FunctionType *Ty = unwrap<FunctionType>(FunctionTy);
766 for (Type *T : Ty->params())
767 *Dest++ = wrap(T);
768}
769
770/*--.. Operations on struct types ..........................................--*/
771
773 unsigned ElementCount, LLVMBool Packed) {
774 ArrayRef<Type*> Tys(unwrap(ElementTypes), ElementCount);
775 return wrap(StructType::get(*unwrap(C), Tys, Packed != 0));
776}
777
779 unsigned ElementCount, LLVMBool Packed) {
780 return LLVMStructTypeInContext(LLVMGetGlobalContext(), ElementTypes,
781 ElementCount, Packed);
782}
783
785{
786 return wrap(StructType::create(*unwrap(C), Name));
787}
788
790{
791 StructType *Type = unwrap<StructType>(Ty);
792 if (!Type->hasName())
793 return nullptr;
794 return Type->getName().data();
795}
796
797void LLVMStructSetBody(LLVMTypeRef StructTy, LLVMTypeRef *ElementTypes,
798 unsigned ElementCount, LLVMBool Packed) {
799 ArrayRef<Type*> Tys(unwrap(ElementTypes), ElementCount);
800 unwrap<StructType>(StructTy)->setBody(Tys, Packed != 0);
801}
802
804 return unwrap<StructType>(StructTy)->getNumElements();
805}
806
808 StructType *Ty = unwrap<StructType>(StructTy);
809 for (Type *T : Ty->elements())
810 *Dest++ = wrap(T);
811}
812
814 StructType *Ty = unwrap<StructType>(StructTy);
815 return wrap(Ty->getTypeAtIndex(i));
816}
817
819 return unwrap<StructType>(StructTy)->isPacked();
820}
821
823 return unwrap<StructType>(StructTy)->isOpaque();
824}
825
827 return unwrap<StructType>(StructTy)->isLiteral();
828}
829
831 return wrap(StructType::getTypeByName(unwrap(M)->getContext(), Name));
832}
833
836}
837
838/*--.. Operations on array, pointer, and vector types (sequence types) .....--*/
839
841 int i = 0;
842 for (auto *T : unwrap(Tp)->subtypes()) {
843 Arr[i] = wrap(T);
844 i++;
845 }
846}
847
849 return wrap(ArrayType::get(unwrap(ElementType), ElementCount));
850}
851
853 return wrap(ArrayType::get(unwrap(ElementType), ElementCount));
854}
855
857 return wrap(PointerType::get(unwrap(ElementType), AddressSpace));
858}
859
861 return true;
862}
863
865 return wrap(FixedVectorType::get(unwrap(ElementType), ElementCount));
866}
867
869 unsigned ElementCount) {
870 return wrap(ScalableVectorType::get(unwrap(ElementType), ElementCount));
871}
872
874 auto *Ty = unwrap(WrappedTy);
875 if (auto *ATy = dyn_cast<ArrayType>(Ty))
876 return wrap(ATy->getElementType());
877 return wrap(cast<VectorType>(Ty)->getElementType());
878}
879
881 return unwrap(Tp)->getNumContainedTypes();
882}
883
885 return unwrap<ArrayType>(ArrayTy)->getNumElements();
886}
887
889 return unwrap<ArrayType>(ArrayTy)->getNumElements();
890}
891
893 return unwrap<PointerType>(PointerTy)->getAddressSpace();
894}
895
896unsigned LLVMGetVectorSize(LLVMTypeRef VectorTy) {
897 return unwrap<VectorType>(VectorTy)->getElementCount().getKnownMinValue();
898}
899
900/*--.. Operations on other types ...........................................--*/
901
903 return wrap(PointerType::get(*unwrap(C), AddressSpace));
904}
905
907 return wrap(Type::getVoidTy(*unwrap(C)));
908}
910 return wrap(Type::getLabelTy(*unwrap(C)));
911}
913 return wrap(Type::getTokenTy(*unwrap(C)));
914}
916 return wrap(Type::getMetadataTy(*unwrap(C)));
917}
918
921}
924}
925
927 LLVMTypeRef *TypeParams,
928 unsigned TypeParamCount,
929 unsigned *IntParams,
930 unsigned IntParamCount) {
931 ArrayRef<Type *> TypeParamArray(unwrap(TypeParams), TypeParamCount);
932 ArrayRef<unsigned> IntParamArray(IntParams, IntParamCount);
933 return wrap(
934 TargetExtType::get(*unwrap(C), Name, TypeParamArray, IntParamArray));
935}
936
937/*===-- Operations on values ----------------------------------------------===*/
938
939/*--.. Operations on all values ............................................--*/
940
942 return wrap(unwrap(Val)->getType());
943}
944
946 switch(unwrap(Val)->getValueID()) {
947#define LLVM_C_API 1
948#define HANDLE_VALUE(Name) \
949 case Value::Name##Val: \
950 return LLVM##Name##ValueKind;
951#include "llvm/IR/Value.def"
952 default:
954 }
955}
956
957const char *LLVMGetValueName2(LLVMValueRef Val, size_t *Length) {
958 auto *V = unwrap(Val);
959 *Length = V->getName().size();
960 return V->getName().data();
961}
962
963void LLVMSetValueName2(LLVMValueRef Val, const char *Name, size_t NameLen) {
964 unwrap(Val)->setName(StringRef(Name, NameLen));
965}
966
968 return unwrap(Val)->getName().data();
969}
970
971void LLVMSetValueName(LLVMValueRef Val, const char *Name) {
972 unwrap(Val)->setName(Name);
973}
974
976 unwrap(Val)->print(errs(), /*IsForDebug=*/true);
977}
978
980 std::string buf;
981 raw_string_ostream os(buf);
982
983 if (unwrap(Val))
984 unwrap(Val)->print(os);
985 else
986 os << "Printing <null> Value";
987
988 os.flush();
989
990 return strdup(buf.c_str());
991}
992
994 std::string buf;
995 raw_string_ostream os(buf);
996
997 if (unwrap(Record))
998 unwrap(Record)->print(os);
999 else
1000 os << "Printing <null> DbgRecord";
1001
1002 os.flush();
1003
1004 return strdup(buf.c_str());
1005}
1006
1008 unwrap(OldVal)->replaceAllUsesWith(unwrap(NewVal));
1009}
1010
1012 return unwrap<Instruction>(Inst)->hasMetadata();
1013}
1014
1016 auto *I = unwrap<Instruction>(Inst);
1017 assert(I && "Expected instruction");
1018 if (auto *MD = I->getMetadata(KindID))
1019 return wrap(MetadataAsValue::get(I->getContext(), MD));
1020 return nullptr;
1021}
1022
1023// MetadataAsValue uses a canonical format which strips the actual MDNode for
1024// MDNode with just a single constant value, storing just a ConstantAsMetadata
1025// This undoes this canonicalization, reconstructing the MDNode.
1027 Metadata *MD = MAV->getMetadata();
1028 assert((isa<MDNode>(MD) || isa<ConstantAsMetadata>(MD)) &&
1029 "Expected a metadata node or a canonicalized constant");
1030
1031 if (MDNode *N = dyn_cast<MDNode>(MD))
1032 return N;
1033
1034 return MDNode::get(MAV->getContext(), MD);
1035}
1036
1037void LLVMSetMetadata(LLVMValueRef Inst, unsigned KindID, LLVMValueRef Val) {
1038 MDNode *N = Val ? extractMDNode(unwrap<MetadataAsValue>(Val)) : nullptr;
1039
1040 unwrap<Instruction>(Inst)->setMetadata(KindID, N);
1041}
1042
1044 unsigned Kind;
1046};
1047
1050llvm_getMetadata(size_t *NumEntries,
1051 llvm::function_ref<void(MetadataEntries &)> AccessMD) {
1053 AccessMD(MVEs);
1054
1056 static_cast<LLVMOpaqueValueMetadataEntry *>(
1058 for (unsigned i = 0; i < MVEs.size(); ++i) {
1059 const auto &ModuleFlag = MVEs[i];
1060 Result[i].Kind = ModuleFlag.first;
1061 Result[i].Metadata = wrap(ModuleFlag.second);
1062 }
1063 *NumEntries = MVEs.size();
1064 return Result;
1065}
1066
1069 size_t *NumEntries) {
1070 return llvm_getMetadata(NumEntries, [&Value](MetadataEntries &Entries) {
1071 Entries.clear();
1072 unwrap<Instruction>(Value)->getAllMetadata(Entries);
1073 });
1074}
1075
1076/*--.. Conversion functions ................................................--*/
1077
1078#define LLVM_DEFINE_VALUE_CAST(name) \
1079 LLVMValueRef LLVMIsA##name(LLVMValueRef Val) { \
1080 return wrap(static_cast<Value*>(dyn_cast_or_null<name>(unwrap(Val)))); \
1081 }
1082
1084
1086 if (auto *MD = dyn_cast_or_null<MetadataAsValue>(unwrap(Val)))
1087 if (isa<MDNode>(MD->getMetadata()) ||
1088 isa<ValueAsMetadata>(MD->getMetadata()))
1089 return Val;
1090 return nullptr;
1091}
1092
1094 if (auto *MD = dyn_cast_or_null<MetadataAsValue>(unwrap(Val)))
1095 if (isa<ValueAsMetadata>(MD->getMetadata()))
1096 return Val;
1097 return nullptr;
1098}
1099
1101 if (auto *MD = dyn_cast_or_null<MetadataAsValue>(unwrap(Val)))
1102 if (isa<MDString>(MD->getMetadata()))
1103 return Val;
1104 return nullptr;
1105}
1106
1107/*--.. Operations on Uses ..................................................--*/
1109 Value *V = unwrap(Val);
1110 Value::use_iterator I = V->use_begin();
1111 if (I == V->use_end())
1112 return nullptr;
1113 return wrap(&*I);
1114}
1115
1117 Use *Next = unwrap(U)->getNext();
1118 if (Next)
1119 return wrap(Next);
1120 return nullptr;
1121}
1122
1124 return wrap(unwrap(U)->getUser());
1125}
1126
1128 return wrap(unwrap(U)->get());
1129}
1130
1131/*--.. Operations on Users .................................................--*/
1132
1134 unsigned Index) {
1135 Metadata *Op = N->getOperand(Index);
1136 if (!Op)
1137 return nullptr;
1138 if (auto *C = dyn_cast<ConstantAsMetadata>(Op))
1139 return wrap(C->getValue());
1141}
1142
1144 Value *V = unwrap(Val);
1145 if (auto *MD = dyn_cast<MetadataAsValue>(V)) {
1146 if (auto *L = dyn_cast<ValueAsMetadata>(MD->getMetadata())) {
1147 assert(Index == 0 && "Function-local metadata can only have one operand");
1148 return wrap(L->getValue());
1149 }
1150 return getMDNodeOperandImpl(V->getContext(),
1151 cast<MDNode>(MD->getMetadata()), Index);
1152 }
1153
1154 return wrap(cast<User>(V)->getOperand(Index));
1155}
1156
1158 Value *V = unwrap(Val);
1159 return wrap(&cast<User>(V)->getOperandUse(Index));
1160}
1161
1163 unwrap<User>(Val)->setOperand(Index, unwrap(Op));
1164}
1165
1167 Value *V = unwrap(Val);
1168 if (isa<MetadataAsValue>(V))
1169 return LLVMGetMDNodeNumOperands(Val);
1170
1171 return cast<User>(V)->getNumOperands();
1172}
1173
1174/*--.. Operations on constants of any type .................................--*/
1175
1177 return wrap(Constant::getNullValue(unwrap(Ty)));
1178}
1179
1182}
1183
1185 return wrap(UndefValue::get(unwrap(Ty)));
1186}
1187
1189 return wrap(PoisonValue::get(unwrap(Ty)));
1190}
1191
1193 return isa<Constant>(unwrap(Ty));
1194}
1195
1197 if (Constant *C = dyn_cast<Constant>(unwrap(Val)))
1198 return C->isNullValue();
1199 return false;
1200}
1201
1203 return isa<UndefValue>(unwrap(Val));
1204}
1205
1207 return isa<PoisonValue>(unwrap(Val));
1208}
1209
1211 return wrap(ConstantPointerNull::get(unwrap<PointerType>(Ty)));
1212}
1213
1214/*--.. Operations on metadata nodes ........................................--*/
1215
1217 size_t SLen) {
1218 return wrap(MDString::get(*unwrap(C), StringRef(Str, SLen)));
1219}
1220
1222 size_t Count) {
1223 return wrap(MDNode::get(*unwrap(C), ArrayRef<Metadata*>(unwrap(MDs), Count)));
1224}
1225
1227 unsigned SLen) {
1230 Context, MDString::get(Context, StringRef(Str, SLen))));
1231}
1232
1233LLVMValueRef LLVMMDString(const char *Str, unsigned SLen) {
1234 return LLVMMDStringInContext(LLVMGetGlobalContext(), Str, SLen);
1235}
1236
1238 unsigned Count) {
1241 for (auto *OV : ArrayRef(Vals, Count)) {
1242 Value *V = unwrap(OV);
1243 Metadata *MD;
1244 if (!V)
1245 MD = nullptr;
1246 else if (auto *C = dyn_cast<Constant>(V))
1248 else if (auto *MDV = dyn_cast<MetadataAsValue>(V)) {
1249 MD = MDV->getMetadata();
1250 assert(!isa<LocalAsMetadata>(MD) && "Unexpected function-local metadata "
1251 "outside of direct argument to call");
1252 } else {
1253 // This is function-local metadata. Pretend to make an MDNode.
1254 assert(Count == 1 &&
1255 "Expected only one operand to function-local metadata");
1257 }
1258
1259 MDs.push_back(MD);
1260 }
1262}
1263
1264LLVMValueRef LLVMMDNode(LLVMValueRef *Vals, unsigned Count) {
1265 return LLVMMDNodeInContext(LLVMGetGlobalContext(), Vals, Count);
1266}
1267
1269 return wrap(MetadataAsValue::get(*unwrap(C), unwrap(MD)));
1270}
1271
1273 auto *V = unwrap(Val);
1274 if (auto *C = dyn_cast<Constant>(V))
1276 if (auto *MAV = dyn_cast<MetadataAsValue>(V))
1277 return wrap(MAV->getMetadata());
1278 return wrap(ValueAsMetadata::get(V));
1279}
1280
1281const char *LLVMGetMDString(LLVMValueRef V, unsigned *Length) {
1282 if (const auto *MD = dyn_cast<MetadataAsValue>(unwrap(V)))
1283 if (const MDString *S = dyn_cast<MDString>(MD->getMetadata())) {
1284 *Length = S->getString().size();
1285 return S->getString().data();
1286 }
1287 *Length = 0;
1288 return nullptr;
1289}
1290
1292 auto *MD = unwrap<MetadataAsValue>(V);
1293 if (isa<ValueAsMetadata>(MD->getMetadata()))
1294 return 1;
1295 return cast<MDNode>(MD->getMetadata())->getNumOperands();
1296}
1297
1299 Module *Mod = unwrap(M);
1301 if (I == Mod->named_metadata_end())
1302 return nullptr;
1303 return wrap(&*I);
1304}
1305
1307 Module *Mod = unwrap(M);
1309 if (I == Mod->named_metadata_begin())
1310 return nullptr;
1311 return wrap(&*--I);
1312}
1313
1315 NamedMDNode *NamedNode = unwrap(NMD);
1317 if (++I == NamedNode->getParent()->named_metadata_end())
1318 return nullptr;
1319 return wrap(&*I);
1320}
1321
1323 NamedMDNode *NamedNode = unwrap(NMD);
1325 if (I == NamedNode->getParent()->named_metadata_begin())
1326 return nullptr;
1327 return wrap(&*--I);
1328}
1329
1331 const char *Name, size_t NameLen) {
1332 return wrap(unwrap(M)->getNamedMetadata(StringRef(Name, NameLen)));
1333}
1334
1336 const char *Name, size_t NameLen) {
1337 return wrap(unwrap(M)->getOrInsertNamedMetadata({Name, NameLen}));
1338}
1339
1340const char *LLVMGetNamedMetadataName(LLVMNamedMDNodeRef NMD, size_t *NameLen) {
1341 NamedMDNode *NamedNode = unwrap(NMD);
1342 *NameLen = NamedNode->getName().size();
1343 return NamedNode->getName().data();
1344}
1345
1347 auto *MD = unwrap<MetadataAsValue>(V);
1348 if (auto *MDV = dyn_cast<ValueAsMetadata>(MD->getMetadata())) {
1349 *Dest = wrap(MDV->getValue());
1350 return;
1351 }
1352 const auto *N = cast<MDNode>(MD->getMetadata());
1353 const unsigned numOperands = N->getNumOperands();
1354 LLVMContext &Context = unwrap(V)->getContext();
1355 for (unsigned i = 0; i < numOperands; i++)
1356 Dest[i] = getMDNodeOperandImpl(Context, N, i);
1357}
1358
1360 LLVMMetadataRef Replacement) {
1361 auto *MD = cast<MetadataAsValue>(unwrap(V));
1362 auto *N = cast<MDNode>(MD->getMetadata());
1363 N->replaceOperandWith(Index, unwrap<Metadata>(Replacement));
1364}
1365
1367 if (NamedMDNode *N = unwrap(M)->getNamedMetadata(Name)) {
1368 return N->getNumOperands();
1369 }
1370 return 0;
1371}
1372
1374 LLVMValueRef *Dest) {
1375 NamedMDNode *N = unwrap(M)->getNamedMetadata(Name);
1376 if (!N)
1377 return;
1378 LLVMContext &Context = unwrap(M)->getContext();
1379 for (unsigned i=0;i<N->getNumOperands();i++)
1380 Dest[i] = wrap(MetadataAsValue::get(Context, N->getOperand(i)));
1381}
1382
1384 LLVMValueRef Val) {
1385 NamedMDNode *N = unwrap(M)->getOrInsertNamedMetadata(Name);
1386 if (!N)
1387 return;
1388 if (!Val)
1389 return;
1390 N->addOperand(extractMDNode(unwrap<MetadataAsValue>(Val)));
1391}
1392
1393const char *LLVMGetDebugLocDirectory(LLVMValueRef Val, unsigned *Length) {
1394 if (!Length) return nullptr;
1395 StringRef S;
1396 if (const auto *I = dyn_cast<Instruction>(unwrap(Val))) {
1397 if (const auto &DL = I->getDebugLoc()) {
1398 S = DL->getDirectory();
1399 }
1400 } else if (const auto *GV = dyn_cast<GlobalVariable>(unwrap(Val))) {
1402 GV->getDebugInfo(GVEs);
1403 if (GVEs.size())
1404 if (const DIGlobalVariable *DGV = GVEs[0]->getVariable())
1405 S = DGV->getDirectory();
1406 } else if (const auto *F = dyn_cast<Function>(unwrap(Val))) {
1407 if (const DISubprogram *DSP = F->getSubprogram())
1408 S = DSP->getDirectory();
1409 } else {
1410 assert(0 && "Expected Instruction, GlobalVariable or Function");
1411 return nullptr;
1412 }
1413 *Length = S.size();
1414 return S.data();
1415}
1416
1417const char *LLVMGetDebugLocFilename(LLVMValueRef Val, unsigned *Length) {
1418 if (!Length) return nullptr;
1419 StringRef S;
1420 if (const auto *I = dyn_cast<Instruction>(unwrap(Val))) {
1421 if (const auto &DL = I->getDebugLoc()) {
1422 S = DL->getFilename();
1423 }
1424 } else if (const auto *GV = dyn_cast<GlobalVariable>(unwrap(Val))) {
1426 GV->getDebugInfo(GVEs);
1427 if (GVEs.size())
1428 if (const DIGlobalVariable *DGV = GVEs[0]->getVariable())
1429 S = DGV->getFilename();
1430 } else if (const auto *F = dyn_cast<Function>(unwrap(Val))) {
1431 if (const DISubprogram *DSP = F->getSubprogram())
1432 S = DSP->getFilename();
1433 } else {
1434 assert(0 && "Expected Instruction, GlobalVariable or Function");
1435 return nullptr;
1436 }
1437 *Length = S.size();
1438 return S.data();
1439}
1440
1442 unsigned L = 0;
1443 if (const auto *I = dyn_cast<Instruction>(unwrap(Val))) {
1444 if (const auto &DL = I->getDebugLoc()) {
1445 L = DL->getLine();
1446 }
1447 } else if (const auto *GV = dyn_cast<GlobalVariable>(unwrap(Val))) {
1449 GV->getDebugInfo(GVEs);
1450 if (GVEs.size())
1451 if (const DIGlobalVariable *DGV = GVEs[0]->getVariable())
1452 L = DGV->getLine();
1453 } else if (const auto *F = dyn_cast<Function>(unwrap(Val))) {
1454 if (const DISubprogram *DSP = F->getSubprogram())
1455 L = DSP->getLine();
1456 } else {
1457 assert(0 && "Expected Instruction, GlobalVariable or Function");
1458 return -1;
1459 }
1460 return L;
1461}
1462
1464 unsigned C = 0;
1465 if (const auto *I = dyn_cast<Instruction>(unwrap(Val)))
1466 if (const auto &DL = I->getDebugLoc())
1467 C = DL->getColumn();
1468 return C;
1469}
1470
1471/*--.. Operations on scalar constants ......................................--*/
1472
1473LLVMValueRef LLVMConstInt(LLVMTypeRef IntTy, unsigned long long N,
1474 LLVMBool SignExtend) {
1475 return wrap(ConstantInt::get(unwrap<IntegerType>(IntTy), N, SignExtend != 0));
1476}
1477
1479 unsigned NumWords,
1480 const uint64_t Words[]) {
1481 IntegerType *Ty = unwrap<IntegerType>(IntTy);
1482 return wrap(ConstantInt::get(
1483 Ty->getContext(), APInt(Ty->getBitWidth(), ArrayRef(Words, NumWords))));
1484}
1485
1487 uint8_t Radix) {
1488 return wrap(ConstantInt::get(unwrap<IntegerType>(IntTy), StringRef(Str),
1489 Radix));
1490}
1491
1493 unsigned SLen, uint8_t Radix) {
1494 return wrap(ConstantInt::get(unwrap<IntegerType>(IntTy), StringRef(Str, SLen),
1495 Radix));
1496}
1497
1499 return wrap(ConstantFP::get(unwrap(RealTy), N));
1500}
1501
1503 return wrap(ConstantFP::get(unwrap(RealTy), StringRef(Text)));
1504}
1505
1507 unsigned SLen) {
1508 return wrap(ConstantFP::get(unwrap(RealTy), StringRef(Str, SLen)));
1509}
1510
1511unsigned long long LLVMConstIntGetZExtValue(LLVMValueRef ConstantVal) {
1512 return unwrap<ConstantInt>(ConstantVal)->getZExtValue();
1513}
1514
1516 return unwrap<ConstantInt>(ConstantVal)->getSExtValue();
1517}
1518
1519double LLVMConstRealGetDouble(LLVMValueRef ConstantVal, LLVMBool *LosesInfo) {
1520 ConstantFP *cFP = unwrap<ConstantFP>(ConstantVal) ;
1521 Type *Ty = cFP->getType();
1522
1523 if (Ty->isHalfTy() || Ty->isBFloatTy() || Ty->isFloatTy() ||
1524 Ty->isDoubleTy()) {
1525 *LosesInfo = false;
1526 return cFP->getValueAPF().convertToDouble();
1527 }
1528
1529 bool APFLosesInfo;
1530 APFloat APF = cFP->getValueAPF();
1531 APF.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven, &APFLosesInfo);
1532 *LosesInfo = APFLosesInfo;
1533 return APF.convertToDouble();
1534}
1535
1536/*--.. Operations on composite constants ...................................--*/
1537
1539 unsigned Length,
1540 LLVMBool DontNullTerminate) {
1541 /* Inverted the sense of AddNull because ', 0)' is a
1542 better mnemonic for null termination than ', 1)'. */
1544 DontNullTerminate == 0));
1545}
1546
1548 size_t Length,
1549 LLVMBool DontNullTerminate) {
1550 /* Inverted the sense of AddNull because ', 0)' is a
1551 better mnemonic for null termination than ', 1)'. */
1553 DontNullTerminate == 0));
1554}
1555
1556LLVMValueRef LLVMConstString(const char *Str, unsigned Length,
1557 LLVMBool DontNullTerminate) {
1559 DontNullTerminate);
1560}
1561
1563 return wrap(unwrap<Constant>(C)->getAggregateElement(Idx));
1564}
1565
1567 return wrap(unwrap<ConstantDataSequential>(C)->getElementAsConstant(idx));
1568}
1569
1571 return unwrap<ConstantDataSequential>(C)->isString();
1572}
1573
1574const char *LLVMGetAsString(LLVMValueRef C, size_t *Length) {
1575 StringRef Str = unwrap<ConstantDataSequential>(C)->getAsString();
1576 *Length = Str.size();
1577 return Str.data();
1578}
1579
1581 LLVMValueRef *ConstantVals, unsigned Length) {
1582 ArrayRef<Constant*> V(unwrap<Constant>(ConstantVals, Length), Length);
1583 return wrap(ConstantArray::get(ArrayType::get(unwrap(ElementTy), Length), V));
1584}
1585
1587 uint64_t Length) {
1588 ArrayRef<Constant *> V(unwrap<Constant>(ConstantVals, Length), Length);
1589 return wrap(ConstantArray::get(ArrayType::get(unwrap(ElementTy), Length), V));
1590}
1591
1593 LLVMValueRef *ConstantVals,
1594 unsigned Count, LLVMBool Packed) {
1595 Constant **Elements = unwrap<Constant>(ConstantVals, Count);
1596 return wrap(ConstantStruct::getAnon(*unwrap(C), ArrayRef(Elements, Count),
1597 Packed != 0));
1598}
1599
1600LLVMValueRef LLVMConstStruct(LLVMValueRef *ConstantVals, unsigned Count,
1601 LLVMBool Packed) {
1602 return LLVMConstStructInContext(LLVMGetGlobalContext(), ConstantVals, Count,
1603 Packed);
1604}
1605
1607 LLVMValueRef *ConstantVals,
1608 unsigned Count) {
1609 Constant **Elements = unwrap<Constant>(ConstantVals, Count);
1610 StructType *Ty = unwrap<StructType>(StructTy);
1611
1612 return wrap(ConstantStruct::get(Ty, ArrayRef(Elements, Count)));
1613}
1614
1615LLVMValueRef LLVMConstVector(LLVMValueRef *ScalarConstantVals, unsigned Size) {
1617 ArrayRef(unwrap<Constant>(ScalarConstantVals, Size), Size)));
1618}
1619
1620/*-- Opcode mapping */
1621
1623{
1624 switch (opcode) {
1625 default: llvm_unreachable("Unhandled Opcode.");
1626#define HANDLE_INST(num, opc, clas) case num: return LLVM##opc;
1627#include "llvm/IR/Instruction.def"
1628#undef HANDLE_INST
1629 }
1630}
1631
1633{
1634 switch (code) {
1635#define HANDLE_INST(num, opc, clas) case LLVM##opc: return num;
1636#include "llvm/IR/Instruction.def"
1637#undef HANDLE_INST
1638 }
1639 llvm_unreachable("Unhandled Opcode.");
1640}
1641
1642/*--.. Constant expressions ................................................--*/
1643
1645 return map_to_llvmopcode(unwrap<ConstantExpr>(ConstantVal)->getOpcode());
1646}
1647
1650}
1651
1653 return wrap(ConstantExpr::getSizeOf(unwrap(Ty)));
1654}
1655
1657 return wrap(ConstantExpr::getNeg(unwrap<Constant>(ConstantVal)));
1658}
1659
1661 return wrap(ConstantExpr::getNSWNeg(unwrap<Constant>(ConstantVal)));
1662}
1663
1665 return wrap(ConstantExpr::getNeg(unwrap<Constant>(ConstantVal)));
1666}
1667
1668
1670 return wrap(ConstantExpr::getNot(unwrap<Constant>(ConstantVal)));
1671}
1672
1674 return wrap(ConstantExpr::getAdd(unwrap<Constant>(LHSConstant),
1675 unwrap<Constant>(RHSConstant)));
1676}
1677
1679 LLVMValueRef RHSConstant) {
1680 return wrap(ConstantExpr::getNSWAdd(unwrap<Constant>(LHSConstant),
1681 unwrap<Constant>(RHSConstant)));
1682}
1683
1685 LLVMValueRef RHSConstant) {
1686 return wrap(ConstantExpr::getNUWAdd(unwrap<Constant>(LHSConstant),
1687 unwrap<Constant>(RHSConstant)));
1688}
1689
1691 return wrap(ConstantExpr::getSub(unwrap<Constant>(LHSConstant),
1692 unwrap<Constant>(RHSConstant)));
1693}
1694
1696 LLVMValueRef RHSConstant) {
1697 return wrap(ConstantExpr::getNSWSub(unwrap<Constant>(LHSConstant),
1698 unwrap<Constant>(RHSConstant)));
1699}
1700
1702 LLVMValueRef RHSConstant) {
1703 return wrap(ConstantExpr::getNUWSub(unwrap<Constant>(LHSConstant),
1704 unwrap<Constant>(RHSConstant)));
1705}
1706
1708 return wrap(ConstantExpr::getMul(unwrap<Constant>(LHSConstant),
1709 unwrap<Constant>(RHSConstant)));
1710}
1711
1713 LLVMValueRef RHSConstant) {
1714 return wrap(ConstantExpr::getNSWMul(unwrap<Constant>(LHSConstant),
1715 unwrap<Constant>(RHSConstant)));
1716}
1717
1719 LLVMValueRef RHSConstant) {
1720 return wrap(ConstantExpr::getNUWMul(unwrap<Constant>(LHSConstant),
1721 unwrap<Constant>(RHSConstant)));
1722}
1723
1725 return wrap(ConstantExpr::getXor(unwrap<Constant>(LHSConstant),
1726 unwrap<Constant>(RHSConstant)));
1727}
1728
1730 LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
1731 return wrap(ConstantExpr::getICmp(Predicate,
1732 unwrap<Constant>(LHSConstant),
1733 unwrap<Constant>(RHSConstant)));
1734}
1735
1737 LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
1738 return wrap(ConstantExpr::getFCmp(Predicate,
1739 unwrap<Constant>(LHSConstant),
1740 unwrap<Constant>(RHSConstant)));
1741}
1742
1744 return wrap(ConstantExpr::getShl(unwrap<Constant>(LHSConstant),
1745 unwrap<Constant>(RHSConstant)));
1746}
1747
1749 LLVMValueRef *ConstantIndices, unsigned NumIndices) {
1750 ArrayRef<Constant *> IdxList(unwrap<Constant>(ConstantIndices, NumIndices),
1751 NumIndices);
1752 Constant *Val = unwrap<Constant>(ConstantVal);
1753 return wrap(ConstantExpr::getGetElementPtr(unwrap(Ty), Val, IdxList));
1754}
1755
1757 LLVMValueRef *ConstantIndices,
1758 unsigned NumIndices) {
1759 ArrayRef<Constant *> IdxList(unwrap<Constant>(ConstantIndices, NumIndices),
1760 NumIndices);
1761 Constant *Val = unwrap<Constant>(ConstantVal);
1762 return wrap(ConstantExpr::getInBoundsGetElementPtr(unwrap(Ty), Val, IdxList));
1763}
1764
1766 return wrap(ConstantExpr::getTrunc(unwrap<Constant>(ConstantVal),
1767 unwrap(ToType)));
1768}
1769
1771 return wrap(ConstantExpr::getPtrToInt(unwrap<Constant>(ConstantVal),
1772 unwrap(ToType)));
1773}
1774
1776 return wrap(ConstantExpr::getIntToPtr(unwrap<Constant>(ConstantVal),
1777 unwrap(ToType)));
1778}
1779
1781 return wrap(ConstantExpr::getBitCast(unwrap<Constant>(ConstantVal),
1782 unwrap(ToType)));
1783}
1784
1786 LLVMTypeRef ToType) {
1787 return wrap(ConstantExpr::getAddrSpaceCast(unwrap<Constant>(ConstantVal),
1788 unwrap(ToType)));
1789}
1790
1792 LLVMTypeRef ToType) {
1793 return wrap(ConstantExpr::getTruncOrBitCast(unwrap<Constant>(ConstantVal),
1794 unwrap(ToType)));
1795}
1796
1798 LLVMTypeRef ToType) {
1799 return wrap(ConstantExpr::getPointerCast(unwrap<Constant>(ConstantVal),
1800 unwrap(ToType)));
1801}
1802
1804 LLVMValueRef IndexConstant) {
1805 return wrap(ConstantExpr::getExtractElement(unwrap<Constant>(VectorConstant),
1806 unwrap<Constant>(IndexConstant)));
1807}
1808
1810 LLVMValueRef ElementValueConstant,
1811 LLVMValueRef IndexConstant) {
1812 return wrap(ConstantExpr::getInsertElement(unwrap<Constant>(VectorConstant),
1813 unwrap<Constant>(ElementValueConstant),
1814 unwrap<Constant>(IndexConstant)));
1815}
1816
1818 LLVMValueRef VectorBConstant,
1819 LLVMValueRef MaskConstant) {
1820 SmallVector<int, 16> IntMask;
1821 ShuffleVectorInst::getShuffleMask(unwrap<Constant>(MaskConstant), IntMask);
1822 return wrap(ConstantExpr::getShuffleVector(unwrap<Constant>(VectorAConstant),
1823 unwrap<Constant>(VectorBConstant),
1824 IntMask));
1825}
1826
1828 const char *Constraints,
1829 LLVMBool HasSideEffects,
1830 LLVMBool IsAlignStack) {
1831 return wrap(InlineAsm::get(dyn_cast<FunctionType>(unwrap(Ty)), AsmString,
1832 Constraints, HasSideEffects, IsAlignStack));
1833}
1834
1836 return wrap(BlockAddress::get(unwrap<Function>(F), unwrap(BB)));
1837}
1838
1840 return wrap(unwrap<BlockAddress>(BlockAddr)->getFunction());
1841}
1842
1844 return wrap(unwrap<BlockAddress>(BlockAddr)->getBasicBlock());
1845}
1846
1847/*--.. Operations on global variables, functions, and aliases (globals) ....--*/
1848
1850 return wrap(unwrap<GlobalValue>(Global)->getParent());
1851}
1852
1854 return unwrap<GlobalValue>(Global)->isDeclaration();
1855}
1856
1858 switch (unwrap<GlobalValue>(Global)->getLinkage()) {
1860 return LLVMExternalLinkage;
1868 return LLVMWeakAnyLinkage;
1870 return LLVMWeakODRLinkage;
1872 return LLVMAppendingLinkage;
1874 return LLVMInternalLinkage;
1876 return LLVMPrivateLinkage;
1880 return LLVMCommonLinkage;
1881 }
1882
1883 llvm_unreachable("Invalid GlobalValue linkage!");
1884}
1885
1887 GlobalValue *GV = unwrap<GlobalValue>(Global);
1888
1889 switch (Linkage) {
1892 break;
1895 break;
1898 break;
1901 break;
1903 LLVM_DEBUG(
1904 errs() << "LLVMSetLinkage(): LLVMLinkOnceODRAutoHideLinkage is no "
1905 "longer supported.");
1906 break;
1907 case LLVMWeakAnyLinkage:
1909 break;
1910 case LLVMWeakODRLinkage:
1912 break;
1915 break;
1918 break;
1919 case LLVMPrivateLinkage:
1921 break;
1924 break;
1927 break;
1929 LLVM_DEBUG(
1930 errs()
1931 << "LLVMSetLinkage(): LLVMDLLImportLinkage is no longer supported.");
1932 break;
1934 LLVM_DEBUG(
1935 errs()
1936 << "LLVMSetLinkage(): LLVMDLLExportLinkage is no longer supported.");
1937 break;
1940 break;
1941 case LLVMGhostLinkage:
1942 LLVM_DEBUG(
1943 errs() << "LLVMSetLinkage(): LLVMGhostLinkage is no longer supported.");
1944 break;
1945 case LLVMCommonLinkage:
1947 break;
1948 }
1949}
1950
1952 // Using .data() is safe because of how GlobalObject::setSection is
1953 // implemented.
1954 return unwrap<GlobalValue>(Global)->getSection().data();
1955}
1956
1957void LLVMSetSection(LLVMValueRef Global, const char *Section) {
1958 unwrap<GlobalObject>(Global)->setSection(Section);
1959}
1960
1962 return static_cast<LLVMVisibility>(
1963 unwrap<GlobalValue>(Global)->getVisibility());
1964}
1965
1967 unwrap<GlobalValue>(Global)
1968 ->setVisibility(static_cast<GlobalValue::VisibilityTypes>(Viz));
1969}
1970
1972 return static_cast<LLVMDLLStorageClass>(
1973 unwrap<GlobalValue>(Global)->getDLLStorageClass());
1974}
1975
1977 unwrap<GlobalValue>(Global)->setDLLStorageClass(
1978 static_cast<GlobalValue::DLLStorageClassTypes>(Class));
1979}
1980
1982 switch (unwrap<GlobalValue>(Global)->getUnnamedAddr()) {
1983 case GlobalVariable::UnnamedAddr::None:
1984 return LLVMNoUnnamedAddr;
1985 case GlobalVariable::UnnamedAddr::Local:
1986 return LLVMLocalUnnamedAddr;
1987 case GlobalVariable::UnnamedAddr::Global:
1988 return LLVMGlobalUnnamedAddr;
1989 }
1990 llvm_unreachable("Unknown UnnamedAddr kind!");
1991}
1992
1994 GlobalValue *GV = unwrap<GlobalValue>(Global);
1995
1996 switch (UnnamedAddr) {
1997 case LLVMNoUnnamedAddr:
1998 return GV->setUnnamedAddr(GlobalVariable::UnnamedAddr::None);
2000 return GV->setUnnamedAddr(GlobalVariable::UnnamedAddr::Local);
2002 return GV->setUnnamedAddr(GlobalVariable::UnnamedAddr::Global);
2003 }
2004}
2005
2007 return unwrap<GlobalValue>(Global)->hasGlobalUnnamedAddr();
2008}
2009
2011 unwrap<GlobalValue>(Global)->setUnnamedAddr(
2012 HasUnnamedAddr ? GlobalValue::UnnamedAddr::Global
2013 : GlobalValue::UnnamedAddr::None);
2014}
2015
2017 return wrap(unwrap<GlobalValue>(Global)->getValueType());
2018}
2019
2020/*--.. Operations on global variables, load and store instructions .........--*/
2021
2023 Value *P = unwrap(V);
2024 if (GlobalObject *GV = dyn_cast<GlobalObject>(P))
2025 return GV->getAlign() ? GV->getAlign()->value() : 0;
2026 if (AllocaInst *AI = dyn_cast<AllocaInst>(P))
2027 return AI->getAlign().value();
2028 if (LoadInst *LI = dyn_cast<LoadInst>(P))
2029 return LI->getAlign().value();
2030 if (StoreInst *SI = dyn_cast<StoreInst>(P))
2031 return SI->getAlign().value();
2032 if (AtomicRMWInst *RMWI = dyn_cast<AtomicRMWInst>(P))
2033 return RMWI->getAlign().value();
2034 if (AtomicCmpXchgInst *CXI = dyn_cast<AtomicCmpXchgInst>(P))
2035 return CXI->getAlign().value();
2036
2038 "only GlobalValue, AllocaInst, LoadInst, StoreInst, AtomicRMWInst, "
2039 "and AtomicCmpXchgInst have alignment");
2040}
2041
2042void LLVMSetAlignment(LLVMValueRef V, unsigned Bytes) {
2043 Value *P = unwrap(V);
2044 if (GlobalObject *GV = dyn_cast<GlobalObject>(P))
2045 GV->setAlignment(MaybeAlign(Bytes));
2046 else if (AllocaInst *AI = dyn_cast<AllocaInst>(P))
2047 AI->setAlignment(Align(Bytes));
2048 else if (LoadInst *LI = dyn_cast<LoadInst>(P))
2049 LI->setAlignment(Align(Bytes));
2050 else if (StoreInst *SI = dyn_cast<StoreInst>(P))
2051 SI->setAlignment(Align(Bytes));
2052 else if (AtomicRMWInst *RMWI = dyn_cast<AtomicRMWInst>(P))
2053 RMWI->setAlignment(Align(Bytes));
2054 else if (AtomicCmpXchgInst *CXI = dyn_cast<AtomicCmpXchgInst>(P))
2055 CXI->setAlignment(Align(Bytes));
2056 else
2058 "only GlobalValue, AllocaInst, LoadInst, StoreInst, AtomicRMWInst, and "
2059 "and AtomicCmpXchgInst have alignment");
2060}
2061
2063 size_t *NumEntries) {
2064 return llvm_getMetadata(NumEntries, [&Value](MetadataEntries &Entries) {
2065 Entries.clear();
2066 if (Instruction *Instr = dyn_cast<Instruction>(unwrap(Value))) {
2067 Instr->getAllMetadata(Entries);
2068 } else {
2069 unwrap<GlobalObject>(Value)->getAllMetadata(Entries);
2070 }
2071 });
2072}
2073
2075 unsigned Index) {
2077 static_cast<LLVMOpaqueValueMetadataEntry>(Entries[Index]);
2078 return MVE.Kind;
2079}
2080
2083 unsigned Index) {
2085 static_cast<LLVMOpaqueValueMetadataEntry>(Entries[Index]);
2086 return MVE.Metadata;
2087}
2088
2090 free(Entries);
2091}
2092
2094 LLVMMetadataRef MD) {
2095 unwrap<GlobalObject>(Global)->setMetadata(Kind, unwrap<MDNode>(MD));
2096}
2097
2099 unwrap<GlobalObject>(Global)->eraseMetadata(Kind);
2100}
2101
2103 unwrap<GlobalObject>(Global)->clearMetadata();
2104}
2105
2106/*--.. Operations on global variables ......................................--*/
2107
2109 return wrap(new GlobalVariable(*unwrap(M), unwrap(Ty), false,
2111}
2112
2114 const char *Name,
2115 unsigned AddressSpace) {
2116 return wrap(new GlobalVariable(*unwrap(M), unwrap(Ty), false,
2118 nullptr, GlobalVariable::NotThreadLocal,
2119 AddressSpace));
2120}
2121
2123 return wrap(unwrap(M)->getNamedGlobal(Name));
2124}
2125
2127 Module *Mod = unwrap(M);
2129 if (I == Mod->global_end())
2130 return nullptr;
2131 return wrap(&*I);
2132}
2133
2135 Module *Mod = unwrap(M);
2137 if (I == Mod->global_begin())
2138 return nullptr;
2139 return wrap(&*--I);
2140}
2141
2143 GlobalVariable *GV = unwrap<GlobalVariable>(GlobalVar);
2145 if (++I == GV->getParent()->global_end())
2146 return nullptr;
2147 return wrap(&*I);
2148}
2149
2151 GlobalVariable *GV = unwrap<GlobalVariable>(GlobalVar);
2153 if (I == GV->getParent()->global_begin())
2154 return nullptr;
2155 return wrap(&*--I);
2156}
2157
2159 unwrap<GlobalVariable>(GlobalVar)->eraseFromParent();
2160}
2161
2163 GlobalVariable* GV = unwrap<GlobalVariable>(GlobalVar);
2164 if ( !GV->hasInitializer() )
2165 return nullptr;
2166 return wrap(GV->getInitializer());
2167}
2168
2169void LLVMSetInitializer(LLVMValueRef GlobalVar, LLVMValueRef ConstantVal) {
2170 unwrap<GlobalVariable>(GlobalVar)
2171 ->setInitializer(unwrap<Constant>(ConstantVal));
2172}
2173
2175 return unwrap<GlobalVariable>(GlobalVar)->isThreadLocal();
2176}
2177
2178void LLVMSetThreadLocal(LLVMValueRef GlobalVar, LLVMBool IsThreadLocal) {
2179 unwrap<GlobalVariable>(GlobalVar)->setThreadLocal(IsThreadLocal != 0);
2180}
2181
2183 return unwrap<GlobalVariable>(GlobalVar)->isConstant();
2184}
2185
2186void LLVMSetGlobalConstant(LLVMValueRef GlobalVar, LLVMBool IsConstant) {
2187 unwrap<GlobalVariable>(GlobalVar)->setConstant(IsConstant != 0);
2188}
2189
2191 switch (unwrap<GlobalVariable>(GlobalVar)->getThreadLocalMode()) {
2192 case GlobalVariable::NotThreadLocal:
2193 return LLVMNotThreadLocal;
2194 case GlobalVariable::GeneralDynamicTLSModel:
2196 case GlobalVariable::LocalDynamicTLSModel:
2198 case GlobalVariable::InitialExecTLSModel:
2200 case GlobalVariable::LocalExecTLSModel:
2201 return LLVMLocalExecTLSModel;
2202 }
2203
2204 llvm_unreachable("Invalid GlobalVariable thread local mode");
2205}
2206
2208 GlobalVariable *GV = unwrap<GlobalVariable>(GlobalVar);
2209
2210 switch (Mode) {
2211 case LLVMNotThreadLocal:
2212 GV->setThreadLocalMode(GlobalVariable::NotThreadLocal);
2213 break;
2215 GV->setThreadLocalMode(GlobalVariable::GeneralDynamicTLSModel);
2216 break;
2218 GV->setThreadLocalMode(GlobalVariable::LocalDynamicTLSModel);
2219 break;
2221 GV->setThreadLocalMode(GlobalVariable::InitialExecTLSModel);
2222 break;
2224 GV->setThreadLocalMode(GlobalVariable::LocalExecTLSModel);
2225 break;
2226 }
2227}
2228
2230 return unwrap<GlobalVariable>(GlobalVar)->isExternallyInitialized();
2231}
2232
2234 unwrap<GlobalVariable>(GlobalVar)->setExternallyInitialized(IsExtInit);
2235}
2236
2237/*--.. Operations on aliases ......................................--*/
2238
2240 unsigned AddrSpace, LLVMValueRef Aliasee,
2241 const char *Name) {
2242 return wrap(GlobalAlias::create(unwrap(ValueTy), AddrSpace,
2244 unwrap<Constant>(Aliasee), unwrap(M)));
2245}
2246
2248 const char *Name, size_t NameLen) {
2249 return wrap(unwrap(M)->getNamedAlias(StringRef(Name, NameLen)));
2250}
2251
2253 Module *Mod = unwrap(M);
2255 if (I == Mod->alias_end())
2256 return nullptr;
2257 return wrap(&*I);
2258}
2259
2261 Module *Mod = unwrap(M);
2263 if (I == Mod->alias_begin())
2264 return nullptr;
2265 return wrap(&*--I);
2266}
2267
2269 GlobalAlias *Alias = unwrap<GlobalAlias>(GA);
2271 if (++I == Alias->getParent()->alias_end())
2272 return nullptr;
2273 return wrap(&*I);
2274}
2275
2277 GlobalAlias *Alias = unwrap<GlobalAlias>(GA);
2279 if (I == Alias->getParent()->alias_begin())
2280 return nullptr;
2281 return wrap(&*--I);
2282}
2283
2285 return wrap(unwrap<GlobalAlias>(Alias)->getAliasee());
2286}
2287
2289 unwrap<GlobalAlias>(Alias)->setAliasee(unwrap<Constant>(Aliasee));
2290}
2291
2292/*--.. Operations on functions .............................................--*/
2293
2295 LLVMTypeRef FunctionTy) {
2296 return wrap(Function::Create(unwrap<FunctionType>(FunctionTy),
2298}
2299
2301 return wrap(unwrap(M)->getFunction(Name));
2302}
2303
2305 Module *Mod = unwrap(M);
2307 if (I == Mod->end())
2308 return nullptr;
2309 return wrap(&*I);
2310}
2311
2313 Module *Mod = unwrap(M);
2315 if (I == Mod->begin())
2316 return nullptr;
2317 return wrap(&*--I);
2318}
2319
2321 Function *Func = unwrap<Function>(Fn);
2322 Module::iterator I(Func);
2323 if (++I == Func->getParent()->end())
2324 return nullptr;
2325 return wrap(&*I);
2326}
2327
2329 Function *Func = unwrap<Function>(Fn);
2330 Module::iterator I(Func);
2331 if (I == Func->getParent()->begin())
2332 return nullptr;
2333 return wrap(&*--I);
2334}
2335
2337 unwrap<Function>(Fn)->eraseFromParent();
2338}
2339
2341 return unwrap<Function>(Fn)->hasPersonalityFn();
2342}
2343
2345 return wrap(unwrap<Function>(Fn)->getPersonalityFn());
2346}
2347
2349 unwrap<Function>(Fn)->setPersonalityFn(unwrap<Constant>(PersonalityFn));
2350}
2351
2353 if (Function *F = dyn_cast<Function>(unwrap(Fn)))
2354 return F->getIntrinsicID();
2355 return 0;
2356}
2357
2359 assert(ID < llvm::Intrinsic::num_intrinsics && "Intrinsic ID out of range");
2360 return llvm::Intrinsic::ID(ID);
2361}
2362
2364 unsigned ID,
2365 LLVMTypeRef *ParamTypes,
2366 size_t ParamCount) {
2367 ArrayRef<Type*> Tys(unwrap(ParamTypes), ParamCount);
2368 auto IID = llvm_map_to_intrinsic_id(ID);
2369 return wrap(llvm::Intrinsic::getDeclaration(unwrap(Mod), IID, Tys));
2370}
2371
2372const char *LLVMIntrinsicGetName(unsigned ID, size_t *NameLength) {
2373 auto IID = llvm_map_to_intrinsic_id(ID);
2374 auto Str = llvm::Intrinsic::getName(IID);
2375 *NameLength = Str.size();
2376 return Str.data();
2377}
2378
2380 LLVMTypeRef *ParamTypes, size_t ParamCount) {
2381 auto IID = llvm_map_to_intrinsic_id(ID);
2382 ArrayRef<Type*> Tys(unwrap(ParamTypes), ParamCount);
2383 return wrap(llvm::Intrinsic::getType(*unwrap(Ctx), IID, Tys));
2384}
2385
2387 LLVMTypeRef *ParamTypes,
2388 size_t ParamCount,
2389 size_t *NameLength) {
2390 auto IID = llvm_map_to_intrinsic_id(ID);
2391 ArrayRef<Type*> Tys(unwrap(ParamTypes), ParamCount);
2392 auto Str = llvm::Intrinsic::getNameNoUnnamedTypes(IID, Tys);
2393 *NameLength = Str.length();
2394 return strdup(Str.c_str());
2395}
2396
2398 LLVMTypeRef *ParamTypes,
2399 size_t ParamCount,
2400 size_t *NameLength) {
2401 auto IID = llvm_map_to_intrinsic_id(ID);
2402 ArrayRef<Type *> Tys(unwrap(ParamTypes), ParamCount);
2403 auto Str = llvm::Intrinsic::getName(IID, Tys, unwrap(Mod));
2404 *NameLength = Str.length();
2405 return strdup(Str.c_str());
2406}
2407
2408unsigned LLVMLookupIntrinsicID(const char *Name, size_t NameLen) {
2409 return Function::lookupIntrinsicID({Name, NameLen});
2410}
2411
2413 auto IID = llvm_map_to_intrinsic_id(ID);
2415}
2416
2418 return unwrap<Function>(Fn)->getCallingConv();
2419}
2420
2422 return unwrap<Function>(Fn)->setCallingConv(
2423 static_cast<CallingConv::ID>(CC));
2424}
2425
2426const char *LLVMGetGC(LLVMValueRef Fn) {
2427 Function *F = unwrap<Function>(Fn);
2428 return F->hasGC()? F->getGC().c_str() : nullptr;
2429}
2430
2431void LLVMSetGC(LLVMValueRef Fn, const char *GC) {
2432 Function *F = unwrap<Function>(Fn);
2433 if (GC)
2434 F->setGC(GC);
2435 else
2436 F->clearGC();
2437}
2438
2440 Function *F = unwrap<Function>(Fn);
2441 return wrap(F->getPrefixData());
2442}
2443
2445 Function *F = unwrap<Function>(Fn);
2446 return F->hasPrefixData();
2447}
2448
2450 Function *F = unwrap<Function>(Fn);
2451 Constant *prefix = unwrap<Constant>(prefixData);
2452 F->setPrefixData(prefix);
2453}
2454
2456 Function *F = unwrap<Function>(Fn);
2457 return wrap(F->getPrologueData());
2458}
2459
2461 Function *F = unwrap<Function>(Fn);
2462 return F->hasPrologueData();
2463}
2464
2466 Function *F = unwrap<Function>(Fn);
2467 Constant *prologue = unwrap<Constant>(prologueData);
2468 F->setPrologueData(prologue);
2469}
2470
2473 unwrap<Function>(F)->addAttributeAtIndex(Idx, unwrap(A));
2474}
2475
2477 auto AS = unwrap<Function>(F)->getAttributes().getAttributes(Idx);
2478 return AS.getNumAttributes();
2479}
2480
2482 LLVMAttributeRef *Attrs) {
2483 auto AS = unwrap<Function>(F)->getAttributes().getAttributes(Idx);
2484 for (auto A : AS)
2485 *Attrs++ = wrap(A);
2486}
2487
2490 unsigned KindID) {
2491 return wrap(unwrap<Function>(F)->getAttributeAtIndex(
2492 Idx, (Attribute::AttrKind)KindID));
2493}
2494
2497 const char *K, unsigned KLen) {
2498 return wrap(
2499 unwrap<Function>(F)->getAttributeAtIndex(Idx, StringRef(K, KLen)));
2500}
2501
2503 unsigned KindID) {
2504 unwrap<Function>(F)->removeAttributeAtIndex(Idx, (Attribute::AttrKind)KindID);
2505}
2506
2508 const char *K, unsigned KLen) {
2509 unwrap<Function>(F)->removeAttributeAtIndex(Idx, StringRef(K, KLen));
2510}
2511
2513 const char *V) {
2514 Function *Func = unwrap<Function>(Fn);
2515 Attribute Attr = Attribute::get(Func->getContext(), A, V);
2516 Func->addFnAttr(Attr);
2517}
2518
2519/*--.. Operations on parameters ............................................--*/
2520
2522 // This function is strictly redundant to
2523 // LLVMCountParamTypes(LLVMGlobalGetValueType(FnRef))
2524 return unwrap<Function>(FnRef)->arg_size();
2525}
2526
2527void LLVMGetParams(LLVMValueRef FnRef, LLVMValueRef *ParamRefs) {
2528 Function *Fn = unwrap<Function>(FnRef);
2529 for (Argument &A : Fn->args())
2530 *ParamRefs++ = wrap(&A);
2531}
2532
2534 Function *Fn = unwrap<Function>(FnRef);
2535 return wrap(&Fn->arg_begin()[index]);
2536}
2537
2539 return wrap(unwrap<Argument>(V)->getParent());
2540}
2541
2543 Function *Func = unwrap<Function>(Fn);
2544 Function::arg_iterator I = Func->arg_begin();
2545 if (I == Func->arg_end())
2546 return nullptr;
2547 return wrap(&*I);
2548}
2549
2551 Function *Func = unwrap<Function>(Fn);
2552 Function::arg_iterator I = Func->arg_end();
2553 if (I == Func->arg_begin())
2554 return nullptr;
2555 return wrap(&*--I);
2556}
2557
2559 Argument *A = unwrap<Argument>(Arg);
2560 Function *Fn = A->getParent();
2561 if (A->getArgNo() + 1 >= Fn->arg_size())
2562 return nullptr;
2563 return wrap(&Fn->arg_begin()[A->getArgNo() + 1]);
2564}
2565
2567 Argument *A = unwrap<Argument>(Arg);
2568 if (A->getArgNo() == 0)
2569 return nullptr;
2570 return wrap(&A->getParent()->arg_begin()[A->getArgNo() - 1]);
2571}
2572
2573void LLVMSetParamAlignment(LLVMValueRef Arg, unsigned align) {
2574 Argument *A = unwrap<Argument>(Arg);
2575 A->addAttr(Attribute::getWithAlignment(A->getContext(), Align(align)));
2576}
2577
2578/*--.. Operations on ifuncs ................................................--*/
2579
2581 const char *Name, size_t NameLen,
2582 LLVMTypeRef Ty, unsigned AddrSpace,
2584 return wrap(GlobalIFunc::create(unwrap(Ty), AddrSpace,
2586 StringRef(Name, NameLen),
2587 unwrap<Constant>(Resolver), unwrap(M)));
2588}
2589
2591 const char *Name, size_t NameLen) {
2592 return wrap(unwrap(M)->getNamedIFunc(StringRef(Name, NameLen)));
2593}
2594
2596 Module *Mod = unwrap(M);
2598 if (I == Mod->ifunc_end())
2599 return nullptr;
2600 return wrap(&*I);
2601}
2602
2604 Module *Mod = unwrap(M);
2606 if (I == Mod->ifunc_begin())
2607 return nullptr;
2608 return wrap(&*--I);
2609}
2610
2612 GlobalIFunc *GIF = unwrap<GlobalIFunc>(IFunc);
2614 if (++I == GIF->getParent()->ifunc_end())
2615 return nullptr;
2616 return wrap(&*I);
2617}
2618
2620 GlobalIFunc *GIF = unwrap<GlobalIFunc>(IFunc);
2622 if (I == GIF->getParent()->ifunc_begin())
2623 return nullptr;
2624 return wrap(&*--I);
2625}
2626
2628 return wrap(unwrap<GlobalIFunc>(IFunc)->getResolver());
2629}
2630
2632 unwrap<GlobalIFunc>(IFunc)->setResolver(unwrap<Constant>(Resolver));
2633}
2634
2636 unwrap<GlobalIFunc>(IFunc)->eraseFromParent();
2637}
2638
2640 unwrap<GlobalIFunc>(IFunc)->removeFromParent();
2641}
2642
2643/*--.. Operations on operand bundles........................................--*/
2644
2646 LLVMValueRef *Args,
2647 unsigned NumArgs) {
2648 return wrap(new OperandBundleDef(std::string(Tag, TagLen),
2649 ArrayRef(unwrap(Args), NumArgs)));
2650}
2651
2653 delete unwrap(Bundle);
2654}
2655
2656const char *LLVMGetOperandBundleTag(LLVMOperandBundleRef Bundle, size_t *Len) {
2657 StringRef Str = unwrap(Bundle)->getTag();
2658 *Len = Str.size();
2659 return Str.data();
2660}
2661
2663 return unwrap(Bundle)->inputs().size();
2664}
2665
2667 unsigned Index) {
2668 return wrap(unwrap(Bundle)->inputs()[Index]);
2669}
2670
2671/*--.. Operations on basic blocks ..........................................--*/
2672
2674 return wrap(static_cast<Value*>(unwrap(BB)));
2675}
2676
2678 return isa<BasicBlock>(unwrap(Val));
2679}
2680
2682 return wrap(unwrap<BasicBlock>(Val));
2683}
2684
2686 return unwrap(BB)->getName().data();
2687}
2688
2690 return wrap(unwrap(BB)->getParent());
2691}
2692
2694 return wrap(unwrap(BB)->getTerminator());
2695}
2696
2698 return unwrap<Function>(FnRef)->size();
2699}
2700
2702 Function *Fn = unwrap<Function>(FnRef);
2703 for (BasicBlock &BB : *Fn)
2704 *BasicBlocksRefs++ = wrap(&BB);
2705}
2706
2708 return wrap(&unwrap<Function>(Fn)->getEntryBlock());
2709}
2710
2712 Function *Func = unwrap<Function>(Fn);
2713 Function::iterator I = Func->begin();
2714 if (I == Func->end())
2715 return nullptr;
2716 return wrap(&*I);
2717}
2718
2720 Function *Func = unwrap<Function>(Fn);
2721 Function::iterator I = Func->end();
2722 if (I == Func->begin())
2723 return nullptr;
2724 return wrap(&*--I);
2725}
2726
2728 BasicBlock *Block = unwrap(BB);
2730 if (++I == Block->getParent()->end())
2731 return nullptr;
2732 return wrap(&*I);
2733}
2734
2736 BasicBlock *Block = unwrap(BB);
2738 if (I == Block->getParent()->begin())
2739 return nullptr;
2740 return wrap(&*--I);
2741}
2742
2744 const char *Name) {
2746}
2747
2749 LLVMBasicBlockRef BB) {
2750 BasicBlock *ToInsert = unwrap(BB);
2751 BasicBlock *CurBB = unwrap(Builder)->GetInsertBlock();
2752 assert(CurBB && "current insertion point is invalid!");
2753 CurBB->getParent()->insert(std::next(CurBB->getIterator()), ToInsert);
2754}
2755
2757 LLVMBasicBlockRef BB) {
2758 unwrap<Function>(Fn)->insert(unwrap<Function>(Fn)->end(), unwrap(BB));
2759}
2760
2762 LLVMValueRef FnRef,
2763 const char *Name) {
2764 return wrap(BasicBlock::Create(*unwrap(C), Name, unwrap<Function>(FnRef)));
2765}
2766
2769}
2770
2772 LLVMBasicBlockRef BBRef,
2773 const char *Name) {
2774 BasicBlock *BB = unwrap(BBRef);
2775 return wrap(BasicBlock::Create(*unwrap(C), Name, BB->getParent(), BB));
2776}
2777
2779 const char *Name) {
2781}
2782
2784 unwrap(BBRef)->eraseFromParent();
2785}
2786
2788 unwrap(BBRef)->removeFromParent();
2789}
2790
2792 unwrap(BB)->moveBefore(unwrap(MovePos));
2793}
2794
2796 unwrap(BB)->moveAfter(unwrap(MovePos));
2797}
2798
2799/*--.. Operations on instructions ..........................................--*/
2800
2802 return wrap(unwrap<Instruction>(Inst)->getParent());
2803}
2804
2806 BasicBlock *Block = unwrap(BB);
2807 BasicBlock::iterator I = Block->begin();
2808 if (I == Block->end())
2809 return nullptr;
2810 return wrap(&*I);
2811}
2812
2814 BasicBlock *Block = unwrap(BB);
2815 BasicBlock::iterator I = Block->end();
2816 if (I == Block->begin())
2817 return nullptr;
2818 return wrap(&*--I);
2819}
2820
2822 Instruction *Instr = unwrap<Instruction>(Inst);
2823 BasicBlock::iterator I(Instr);
2824 if (++I == Instr->getParent()->end())
2825 return nullptr;
2826 return wrap(&*I);
2827}
2828
2830 Instruction *Instr = unwrap<Instruction>(Inst);
2831 BasicBlock::iterator I(Instr);
2832 if (I == Instr->getParent()->begin())
2833 return nullptr;
2834 return wrap(&*--I);
2835}
2836
2838 unwrap<Instruction>(Inst)->removeFromParent();
2839}
2840
2842 unwrap<Instruction>(Inst)->eraseFromParent();
2843}
2844
2846 unwrap<Instruction>(Inst)->deleteValue();
2847}
2848
2850 if (ICmpInst *I = dyn_cast<ICmpInst>(unwrap(Inst)))
2851 return (LLVMIntPredicate)I->getPredicate();
2852 if (ConstantExpr *CE = dyn_cast<ConstantExpr>(unwrap(Inst)))
2853 if (CE->getOpcode() == Instruction::ICmp)
2854 return (LLVMIntPredicate)CE->getPredicate();
2855 return (LLVMIntPredicate)0;
2856}
2857
2859 if (FCmpInst *I = dyn_cast<FCmpInst>(unwrap(Inst)))
2860 return (LLVMRealPredicate)I->getPredicate();
2861 if (ConstantExpr *CE = dyn_cast<ConstantExpr>(unwrap(Inst)))
2862 if (CE->getOpcode() == Instruction::FCmp)
2863 return (LLVMRealPredicate)CE->getPredicate();
2864 return (LLVMRealPredicate)0;
2865}
2866
2868 if (Instruction *C = dyn_cast<Instruction>(unwrap(Inst)))
2869 return map_to_llvmopcode(C->getOpcode());
2870 return (LLVMOpcode)0;
2871}
2872
2874 if (Instruction *C = dyn_cast<Instruction>(unwrap(Inst)))
2875 return wrap(C->clone());
2876 return nullptr;
2877}
2878
2880 Instruction *I = dyn_cast<Instruction>(unwrap(Inst));
2881 return (I && I->isTerminator()) ? wrap(I) : nullptr;
2882}
2883
2885 if (FuncletPadInst *FPI = dyn_cast<FuncletPadInst>(unwrap(Instr))) {
2886 return FPI->arg_size();
2887 }
2888 return unwrap<CallBase>(Instr)->arg_size();
2889}
2890
2891/*--.. Call and invoke instructions ........................................--*/
2892
2894 return unwrap<CallBase>(Instr)->getCallingConv();
2895}
2896
2898 return unwrap<CallBase>(Instr)->setCallingConv(
2899 static_cast<CallingConv::ID>(CC));
2900}
2901
2903 unsigned align) {
2904 auto *Call = unwrap<CallBase>(Instr);
2905 Attribute AlignAttr =
2906 Attribute::getWithAlignment(Call->getContext(), Align(align));
2907 Call->addAttributeAtIndex(Idx, AlignAttr);
2908}
2909
2912 unwrap<CallBase>(C)->addAttributeAtIndex(Idx, unwrap(A));
2913}
2914
2917 auto *Call = unwrap<CallBase>(C);
2918 auto AS = Call->getAttributes().getAttributes(Idx);
2919 return AS.getNumAttributes();
2920}
2921
2923 LLVMAttributeRef *Attrs) {
2924 auto *Call = unwrap<CallBase>(C);
2925 auto AS = Call->getAttributes().getAttributes(Idx);
2926 for (auto A : AS)
2927 *Attrs++ = wrap(A);
2928}
2929
2932 unsigned KindID) {
2933 return wrap(unwrap<CallBase>(C)->getAttributeAtIndex(
2934 Idx, (Attribute::AttrKind)KindID));
2935}
2936
2939 const char *K, unsigned KLen) {
2940 return wrap(
2941 unwrap<CallBase>(C)->getAttributeAtIndex(Idx, StringRef(K, KLen)));
2942}
2943
2945 unsigned KindID) {
2946 unwrap<CallBase>(C)->removeAttributeAtIndex(Idx, (Attribute::AttrKind)KindID);
2947}
2948
2950 const char *K, unsigned KLen) {
2951 unwrap<CallBase>(C)->removeAttributeAtIndex(Idx, StringRef(K, KLen));
2952}
2953
2955 return wrap(unwrap<CallBase>(Instr)->getCalledOperand());
2956}
2957
2959 return wrap(unwrap<CallBase>(Instr)->getFunctionType());
2960}
2961
2963 return unwrap<CallBase>(C)->getNumOperandBundles();
2964}
2965
2967 unsigned Index) {
2968 return wrap(
2969 new OperandBundleDef(unwrap<CallBase>(C)->getOperandBundleAt(Index)));
2970}
2971
2972/*--.. Operations on call instructions (only) ..............................--*/
2973
2975 return unwrap<CallInst>(Call)->isTailCall();
2976}
2977
2978void LLVMSetTailCall(LLVMValueRef Call, LLVMBool isTailCall) {
2979 unwrap<CallInst>(Call)->setTailCall(isTailCall);
2980}
2981
2983 return (LLVMTailCallKind)unwrap<CallInst>(Call)->getTailCallKind();
2984}
2985
2987 unwrap<CallInst>(Call)->setTailCallKind((CallInst::TailCallKind)kind);
2988}
2989
2990/*--.. Operations on invoke instructions (only) ............................--*/
2991
2993 return wrap(unwrap<InvokeInst>(Invoke)->getNormalDest());
2994}
2995
2997 if (CleanupReturnInst *CRI = dyn_cast<CleanupReturnInst>(unwrap(Invoke))) {
2998 return wrap(CRI->getUnwindDest());
2999 } else if (CatchSwitchInst *CSI = dyn_cast<CatchSwitchInst>(unwrap(Invoke))) {
3000 return wrap(CSI->getUnwindDest());
3001 }
3002 return wrap(unwrap<InvokeInst>(Invoke)->getUnwindDest());
3003}
3004
3006 unwrap<InvokeInst>(Invoke)->setNormalDest(unwrap(B));
3007}
3008
3010 if (CleanupReturnInst *CRI = dyn_cast<CleanupReturnInst>(unwrap(Invoke))) {
3011 return CRI->setUnwindDest(unwrap(B));
3012 } else if (CatchSwitchInst *CSI = dyn_cast<CatchSwitchInst>(unwrap(Invoke))) {
3013 return CSI->setUnwindDest(unwrap(B));
3014 }
3015 unwrap<InvokeInst>(Invoke)->setUnwindDest(unwrap(B));
3016}
3017
3018/*--.. Operations on terminators ...........................................--*/
3019
3021 return unwrap<Instruction>(Term)->getNumSuccessors();
3022}
3023
3025 return wrap(unwrap<Instruction>(Term)->getSuccessor(i));
3026}
3027
3029 return unwrap<Instruction>(Term)->setSuccessor(i, unwrap(block));
3030}
3031
3032/*--.. Operations on branch instructions (only) ............................--*/
3033
3035 return unwrap<BranchInst>(Branch)->isConditional();
3036}
3037
3039 return wrap(unwrap<BranchInst>(Branch)->getCondition());
3040}
3041
3043 return unwrap<BranchInst>(Branch)->setCondition(unwrap(Cond));
3044}
3045
3046/*--.. Operations on switch instructions (only) ............................--*/
3047
3049 return wrap(unwrap<SwitchInst>(Switch)->getDefaultDest());
3050}
3051
3052/*--.. Operations on alloca instructions (only) ............................--*/
3053
3055 return wrap(unwrap<AllocaInst>(Alloca)->getAllocatedType());
3056}
3057
3058/*--.. Operations on gep instructions (only) ...............................--*/
3059
3061 return unwrap<GEPOperator>(GEP)->isInBounds();
3062}
3063
3065 return unwrap<GetElementPtrInst>(GEP)->setIsInBounds(InBounds);
3066}
3067
3069 return wrap(unwrap<GEPOperator>(GEP)->getSourceElementType());
3070}
3071
3072/*--.. Operations on phi nodes .............................................--*/
3073
3074void LLVMAddIncoming(LLVMValueRef PhiNode, LLVMValueRef *IncomingValues,
3075 LLVMBasicBlockRef *IncomingBlocks, unsigned Count) {
3076 PHINode *PhiVal = unwrap<PHINode>(PhiNode);
3077 for (unsigned I = 0; I != Count; ++I)
3078 PhiVal->addIncoming(unwrap(IncomingValues[I]), unwrap(IncomingBlocks[I]));
3079}
3080
3082 return unwrap<PHINode>(PhiNode)->getNumIncomingValues();
3083}
3084
3086 return wrap(unwrap<PHINode>(PhiNode)->getIncomingValue(Index));
3087}
3088
3090 return wrap(unwrap<PHINode>(PhiNode)->getIncomingBlock(Index));
3091}
3092
3093/*--.. Operations on extractvalue and insertvalue nodes ....................--*/
3094
3096 auto *I = unwrap(Inst);
3097 if (auto *GEP = dyn_cast<GEPOperator>(I))
3098 return GEP->getNumIndices();
3099 if (auto *EV = dyn_cast<ExtractValueInst>(I))
3100 return EV->getNumIndices();
3101 if (auto *IV = dyn_cast<InsertValueInst>(I))
3102 return IV->getNumIndices();
3104 "LLVMGetNumIndices applies only to extractvalue and insertvalue!");
3105}
3106
3107const unsigned *LLVMGetIndices(LLVMValueRef Inst) {
3108 auto *I = unwrap(Inst);
3109 if (auto *EV = dyn_cast<ExtractValueInst>(I))
3110 return EV->getIndices().data();
3111 if (auto *IV = dyn_cast<InsertValueInst>(I))
3112 return IV->getIndices().data();
3114 "LLVMGetIndices applies only to extractvalue and insertvalue!");
3115}
3116
3117
3118/*===-- Instruction builders ----------------------------------------------===*/
3119
3121 return wrap(new IRBuilder<>(*unwrap(C)));
3122}
3123
3126}
3127
3129 LLVMValueRef Instr) {
3130 BasicBlock *BB = unwrap(Block);
3131 auto I = Instr ? unwrap<Instruction>(Instr)->getIterator() : BB->end();
3132 unwrap(Builder)->SetInsertPoint(BB, I);
3133}
3134
3136 Instruction *I = unwrap<Instruction>(Instr);
3137 unwrap(Builder)->SetInsertPoint(I->getParent(), I->getIterator());
3138}
3139
3141 BasicBlock *BB = unwrap(Block);
3142 unwrap(Builder)->SetInsertPoint(BB);
3143}
3144
3146 return wrap(unwrap(Builder)->GetInsertBlock());
3147}
3148
3150 unwrap(Builder)->ClearInsertionPoint();
3151}
3152
3154 unwrap(Builder)->Insert(unwrap<Instruction>(Instr));
3155}
3156
3158 const char *Name) {
3159 unwrap(Builder)->Insert(unwrap<Instruction>(Instr), Name);
3160}
3161
3163 delete unwrap(Builder);
3164}
3165
3166/*--.. Metadata builders ...................................................--*/
3167
3169 return wrap(unwrap(Builder)->getCurrentDebugLocation().getAsMDNode());
3170}
3171
3173 if (Loc)
3174 unwrap(Builder)->SetCurrentDebugLocation(DebugLoc(unwrap<MDNode>(Loc)));
3175 else
3176 unwrap(Builder)->SetCurrentDebugLocation(DebugLoc());
3177}
3178
3180 MDNode *Loc =
3181 L ? cast<MDNode>(unwrap<MetadataAsValue>(L)->getMetadata()) : nullptr;
3182 unwrap(Builder)->SetCurrentDebugLocation(DebugLoc(Loc));
3183}
3184
3186 LLVMContext &Context = unwrap(Builder)->getContext();
3188 Context, unwrap(Builder)->getCurrentDebugLocation().getAsMDNode()));
3189}
3190
3192 unwrap(Builder)->SetInstDebugLocation(unwrap<Instruction>(Inst));
3193}
3194
3196 unwrap(Builder)->AddMetadataToInst(unwrap<Instruction>(Inst));
3197}
3198
3200 LLVMMetadataRef FPMathTag) {
3201
3202 unwrap(Builder)->setDefaultFPMathTag(FPMathTag
3203 ? unwrap<MDNode>(FPMathTag)
3204 : nullptr);
3205}
3206
3208 return wrap(unwrap(Builder)->getDefaultFPMathTag());
3209}
3210
3211/*--.. Instruction builders ................................................--*/
3212
3214 return wrap(unwrap(B)->CreateRetVoid());
3215}
3216
3218 return wrap(unwrap(B)->CreateRet(unwrap(V)));
3219}
3220
3222 unsigned N) {
3223 return wrap(unwrap(B)->CreateAggregateRet(unwrap(RetVals), N));
3224}
3225
3227 return wrap(unwrap(B)->CreateBr(unwrap(Dest)));
3228}
3229
3232 return wrap(unwrap(B)->CreateCondBr(unwrap(If), unwrap(Then), unwrap(Else)));
3233}
3234
3236 LLVMBasicBlockRef Else, unsigned NumCases) {
3237 return wrap(unwrap(B)->CreateSwitch(unwrap(V), unwrap(Else), NumCases));
3238}
3239
3241 unsigned NumDests) {
3242 return wrap(unwrap(B)->CreateIndirectBr(unwrap(Addr), NumDests));
3243}
3244
3246 LLVMValueRef *Args, unsigned NumArgs,
3248 const char *Name) {
3249 return wrap(unwrap(B)->CreateInvoke(unwrap<FunctionType>(Ty), unwrap(Fn),
3250 unwrap(Then), unwrap(Catch),
3251 ArrayRef(unwrap(Args), NumArgs), Name));
3252}
3253
3256 unsigned NumArgs, LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch,
3257 LLVMOperandBundleRef *Bundles, unsigned NumBundles, const char *Name) {
3259 for (auto *Bundle : ArrayRef(Bundles, NumBundles)) {
3260 OperandBundleDef *OB = unwrap(Bundle);
3261 OBs.push_back(*OB);
3262 }
3263 return wrap(unwrap(B)->CreateInvoke(
3264 unwrap<FunctionType>(Ty), unwrap(Fn), unwrap(Then), unwrap(Catch),
3265 ArrayRef(unwrap(Args), NumArgs), OBs, Name));
3266}
3267
3269 LLVMValueRef PersFn, unsigned NumClauses,
3270 const char *Name) {
3271 // The personality used to live on the landingpad instruction, but now it
3272 // lives on the parent function. For compatibility, take the provided
3273 // personality and put it on the parent function.
3274 if (PersFn)
3275 unwrap(B)->GetInsertBlock()->getParent()->setPersonalityFn(
3276 unwrap<Function>(PersFn));
3277 return wrap(unwrap(B)->CreateLandingPad(unwrap(Ty), NumClauses, Name));
3278}
3279
3281 LLVMValueRef *Args, unsigned NumArgs,
3282 const char *Name) {
3283 return wrap(unwrap(B)->CreateCatchPad(unwrap(ParentPad),
3284 ArrayRef(unwrap(Args), NumArgs), Name));
3285}
3286
3288 LLVMValueRef *Args, unsigned NumArgs,
3289 const char *Name) {
3290 if (ParentPad == nullptr) {
3291 Type *Ty = Type::getTokenTy(unwrap(B)->getContext());
3292 ParentPad = wrap(Constant::getNullValue(Ty));
3293 }
3294 return wrap(unwrap(B)->CreateCleanupPad(
3295 unwrap(ParentPad), ArrayRef(unwrap(Args), NumArgs), Name));
3296}
3297
3299 return wrap(unwrap(B)->CreateResume(unwrap(Exn)));
3300}
3301
3303 LLVMBasicBlockRef UnwindBB,
3304 unsigned NumHandlers, const char *Name) {
3305 if (ParentPad == nullptr) {
3306 Type *Ty = Type::getTokenTy(unwrap(B)->getContext());
3307 ParentPad = wrap(Constant::getNullValue(Ty));
3308 }
3309 return wrap(unwrap(B)->CreateCatchSwitch(unwrap(ParentPad), unwrap(UnwindBB),
3310 NumHandlers, Name));
3311}
3312
3314 LLVMBasicBlockRef BB) {
3315 return wrap(unwrap(B)->CreateCatchRet(unwrap<CatchPadInst>(CatchPad),
3316 unwrap(BB)));
3317}
3318
3320 LLVMBasicBlockRef BB) {
3321 return wrap(unwrap(B)->CreateCleanupRet(unwrap<CleanupPadInst>(CatchPad),
3322 unwrap(BB)));
3323}
3324
3326 return wrap(unwrap(B)->CreateUnreachable());
3327}
3328
3330 LLVMBasicBlockRef Dest) {
3331 unwrap<SwitchInst>(Switch)->addCase(unwrap<ConstantInt>(OnVal), unwrap(Dest));
3332}
3333
3335 unwrap<IndirectBrInst>(IndirectBr)->addDestination(unwrap(Dest));
3336}
3337
3338unsigned LLVMGetNumClauses(LLVMValueRef LandingPad) {
3339 return unwrap<LandingPadInst>(LandingPad)->getNumClauses();
3340}
3341
3343 return wrap(unwrap<LandingPadInst>(LandingPad)->getClause(Idx));
3344}
3345
3347 unwrap<LandingPadInst>(LandingPad)->addClause(unwrap<Constant>(ClauseVal));
3348}
3349
3351 return unwrap<LandingPadInst>(LandingPad)->isCleanup();
3352}
3353
3354void LLVMSetCleanup(LLVMValueRef LandingPad, LLVMBool Val) {
3355 unwrap<LandingPadInst>(LandingPad)->setCleanup(Val);
3356}
3357
3359 unwrap<CatchSwitchInst>(CatchSwitch)->addHandler(unwrap(Dest));
3360}
3361
3362unsigned LLVMGetNumHandlers(LLVMValueRef CatchSwitch) {
3363 return unwrap<CatchSwitchInst>(CatchSwitch)->getNumHandlers();
3364}
3365
3366void LLVMGetHandlers(LLVMValueRef CatchSwitch, LLVMBasicBlockRef *Handlers) {
3367 CatchSwitchInst *CSI = unwrap<CatchSwitchInst>(CatchSwitch);
3368 for (const BasicBlock *H : CSI->handlers())
3369 *Handlers++ = wrap(H);
3370}
3371
3373 return wrap(unwrap<CatchPadInst>(CatchPad)->getCatchSwitch());
3374}
3375
3377 unwrap<CatchPadInst>(CatchPad)
3378 ->setCatchSwitch(unwrap<CatchSwitchInst>(CatchSwitch));
3379}
3380
3381/*--.. Funclets ...........................................................--*/
3382
3384 return wrap(unwrap<FuncletPadInst>(Funclet)->getArgOperand(i));
3385}
3386
3388 unwrap<FuncletPadInst>(Funclet)->setArgOperand(i, unwrap(value));
3389}
3390
3391/*--.. Arithmetic ..........................................................--*/
3392
3394 FastMathFlags NewFMF;
3395 NewFMF.setAllowReassoc((FMF & LLVMFastMathAllowReassoc) != 0);
3396 NewFMF.setNoNaNs((FMF & LLVMFastMathNoNaNs) != 0);
3397 NewFMF.setNoInfs((FMF & LLVMFastMathNoInfs) != 0);
3398 NewFMF.setNoSignedZeros((FMF & LLVMFastMathNoSignedZeros) != 0);
3400 NewFMF.setAllowContract((FMF & LLVMFastMathAllowContract) != 0);
3401 NewFMF.setApproxFunc((FMF & LLVMFastMathApproxFunc) != 0);
3402
3403 return NewFMF;
3404}
3405
3408 if (FMF.allowReassoc())
3409 NewFMF |= LLVMFastMathAllowReassoc;
3410 if (FMF.noNaNs())
3411 NewFMF |= LLVMFastMathNoNaNs;
3412 if (FMF.noInfs())
3413 NewFMF |= LLVMFastMathNoInfs;
3414 if (FMF.noSignedZeros())
3415 NewFMF |= LLVMFastMathNoSignedZeros;
3416 if (FMF.allowReciprocal())
3418 if (FMF.allowContract())
3419 NewFMF |= LLVMFastMathAllowContract;
3420 if (FMF.approxFunc())
3421 NewFMF |= LLVMFastMathApproxFunc;
3422
3423 return NewFMF;
3424}
3425
3427 const char *Name) {
3428 return wrap(unwrap(B)->CreateAdd(unwrap(LHS), unwrap(RHS), Name));
3429}
3430
3432 const char *Name) {
3433 return wrap(unwrap(B)->CreateNSWAdd(unwrap(LHS), unwrap(RHS), Name));
3434}
3435
3437 const char *Name) {
3438 return wrap(unwrap(B)->CreateNUWAdd(unwrap(LHS), unwrap(RHS), Name));
3439}
3440
3442 const char *Name) {
3443 return wrap(unwrap(B)->CreateFAdd(unwrap(LHS), unwrap(RHS), Name));
3444}
3445
3447 const char *Name) {
3448 return wrap(unwrap(B)->CreateSub(unwrap(LHS), unwrap(RHS), Name));
3449}
3450
3452 const char *Name) {
3453 return wrap(unwrap(B)->CreateNSWSub(unwrap(LHS), unwrap(RHS), Name));
3454}
3455
3457 const char *Name) {
3458 return wrap(unwrap(B)->CreateNUWSub(unwrap(LHS), unwrap(RHS), Name));
3459}
3460
3462 const char *Name) {
3463 return wrap(unwrap(B)->CreateFSub(unwrap(LHS), unwrap(RHS), Name));
3464}
3465
3467 const char *Name) {
3468 return wrap(unwrap(B)->CreateMul(unwrap(LHS), unwrap(RHS), Name));
3469}
3470
3472 const char *Name) {
3473 return wrap(unwrap(B)->CreateNSWMul(unwrap(LHS), unwrap(RHS), Name));
3474}
3475
3477 const char *Name) {
3478 return wrap(unwrap(B)->CreateNUWMul(unwrap(LHS), unwrap(RHS), Name));
3479}
3480
3482 const char *Name) {
3483 return wrap(unwrap(B)->CreateFMul(unwrap(LHS), unwrap(RHS), Name));
3484}
3485
3487 const char *Name) {
3488 return wrap(unwrap(B)->CreateUDiv(unwrap(LHS), unwrap(RHS), Name));
3489}
3490
3492 LLVMValueRef RHS, const char *Name) {
3493 return wrap(unwrap(B)->CreateExactUDiv(unwrap(LHS), unwrap(RHS), Name));
3494}
3495
3497 const char *Name) {
3498 return wrap(unwrap(B)->CreateSDiv(unwrap(LHS), unwrap(RHS), Name));
3499}
3500
3502 LLVMValueRef RHS, const char *Name) {
3503 return wrap(unwrap(B)->CreateExactSDiv(unwrap(LHS), unwrap(RHS), Name));
3504}
3505
3507 const char *Name) {
3508 return wrap(unwrap(B)->CreateFDiv(unwrap(LHS), unwrap(RHS), Name));
3509}
3510
3512 const char *Name) {
3513 return wrap(unwrap(B)->CreateURem(unwrap(LHS), unwrap(RHS), Name));
3514}
3515
3517 const char *Name) {
3518 return wrap(unwrap(B)->CreateSRem(unwrap(LHS), unwrap(RHS), Name));
3519}
3520
3522 const char *Name) {
3523 return wrap(unwrap(B)->CreateFRem(unwrap(LHS), unwrap(RHS), Name));
3524}
3525
3527 const char *Name) {
3528 return wrap(unwrap(B)->CreateShl(unwrap(LHS), unwrap(RHS), Name));
3529}
3530
3532 const char *Name) {
3533 return wrap(unwrap(B)->CreateLShr(unwrap(LHS), unwrap(RHS), Name));
3534}
3535
3537 const char *Name) {
3538 return wrap(unwrap(B)->CreateAShr(unwrap(LHS), unwrap(RHS), Name));
3539}
3540
3542 const char *Name) {
3543 return wrap(unwrap(B)->CreateAnd(unwrap(LHS), unwrap(RHS), Name));
3544}
3545
3547 const char *Name) {
3548 return wrap(unwrap(B)->CreateOr(unwrap(LHS), unwrap(RHS), Name));
3549}
3550
3552 const char *Name) {
3553 return wrap(unwrap(B)->CreateXor(unwrap(LHS), unwrap(RHS), Name));
3554}
3555
3557 LLVMValueRef LHS, LLVMValueRef RHS,
3558 const char *Name) {
3560 unwrap(RHS), Name));
3561}
3562
3564 return wrap(unwrap(B)->CreateNeg(unwrap(V), Name));
3565}
3566
3568 const char *Name) {
3569 return wrap(unwrap(B)->CreateNSWNeg(unwrap(V), Name));
3570}
3571
3573 const char *Name) {
3574 Value *Neg = unwrap(B)->CreateNeg(unwrap(V), Name);
3575 if (auto *I = dyn_cast<BinaryOperator>(Neg))
3576 I->setHasNoUnsignedWrap();
3577 return wrap(Neg);
3578}
3579
3581 return wrap(unwrap(B)->CreateFNeg(unwrap(V), Name));
3582}
3583
3585 return wrap(unwrap(B)->CreateNot(unwrap(V), Name));
3586}
3587
3589 Value *P = unwrap<Value>(ArithInst);
3590 return cast<Instruction>(P)->hasNoUnsignedWrap();
3591}
3592
3593void LLVMSetNUW(LLVMValueRef ArithInst, LLVMBool HasNUW) {
3594 Value *P = unwrap<Value>(ArithInst);
3595 cast<Instruction>(P)->setHasNoUnsignedWrap(HasNUW);
3596}
3597
3599 Value *P = unwrap<Value>(ArithInst);
3600 return cast<Instruction>(P)->hasNoSignedWrap();
3601}
3602
3603void LLVMSetNSW(LLVMValueRef ArithInst, LLVMBool HasNSW) {
3604 Value *P = unwrap<Value>(ArithInst);
3605 cast<Instruction>(P)->setHasNoSignedWrap(HasNSW);
3606}
3607
3609 Value *P = unwrap<Value>(DivOrShrInst);
3610 return cast<Instruction>(P)->isExact();
3611}
3612
3613void LLVMSetExact(LLVMValueRef DivOrShrInst, LLVMBool IsExact) {
3614 Value *P = unwrap<Value>(DivOrShrInst);
3615 cast<Instruction>(P)->setIsExact(IsExact);
3616}
3617
3619 Value *P = unwrap<Value>(NonNegInst);
3620 return cast<Instruction>(P)->hasNonNeg();
3621}
3622
3623void LLVMSetNNeg(LLVMValueRef NonNegInst, LLVMBool IsNonNeg) {
3624 Value *P = unwrap<Value>(NonNegInst);
3625 cast<Instruction>(P)->setNonNeg(IsNonNeg);
3626}
3627
3629 Value *P = unwrap<Value>(FPMathInst);
3630 FastMathFlags FMF = cast<Instruction>(P)->getFastMathFlags();
3631 return mapToLLVMFastMathFlags(FMF);
3632}
3633
3635 Value *P = unwrap<Value>(FPMathInst);
3636 cast<Instruction>(P)->setFastMathFlags(mapFromLLVMFastMathFlags(FMF));
3637}
3638
3640 Value *Val = unwrap<Value>(V);
3641 return isa<FPMathOperator>(Val);
3642}
3643
3645 Value *P = unwrap<Value>(Inst);
3646 return cast<PossiblyDisjointInst>(P)->isDisjoint();
3647}
3648
3650 Value *P = unwrap<Value>(Inst);
3651 cast<PossiblyDisjointInst>(P)->setIsDisjoint(IsDisjoint);
3652}
3653
3654/*--.. Memory ..............................................................--*/
3655
3657 const char *Name) {
3658 Type* ITy = Type::getInt32Ty(unwrap(B)->GetInsertBlock()->getContext());
3659 Constant* AllocSize = ConstantExpr::getSizeOf(unwrap(Ty));
3660 AllocSize = ConstantExpr::getTruncOrBitCast(AllocSize, ITy);
3661 return wrap(unwrap(B)->CreateMalloc(ITy, unwrap(Ty), AllocSize, nullptr,
3662 nullptr, Name));
3663}
3664
3666 LLVMValueRef Val, const char *Name) {
3667 Type* ITy = Type::getInt32Ty(unwrap(B)->GetInsertBlock()->getContext());
3668 Constant* AllocSize = ConstantExpr::getSizeOf(unwrap(Ty));
3669 AllocSize = ConstantExpr::getTruncOrBitCast(AllocSize, ITy);
3670 return wrap(unwrap(B)->CreateMalloc(ITy, unwrap(Ty), AllocSize, unwrap(Val),
3671 nullptr, Name));
3672}
3673
3675 LLVMValueRef Val, LLVMValueRef Len,
3676 unsigned Align) {
3677 return wrap(unwrap(B)->CreateMemSet(unwrap(Ptr), unwrap(Val), unwrap(Len),
3678 MaybeAlign(Align)));
3679}
3680
3682 LLVMValueRef Dst, unsigned DstAlign,
3683 LLVMValueRef Src, unsigned SrcAlign,
3685 return wrap(unwrap(B)->CreateMemCpy(unwrap(Dst), MaybeAlign(DstAlign),
3686 unwrap(Src), MaybeAlign(SrcAlign),
3687 unwrap(Size)));
3688}
3689
3691 LLVMValueRef Dst, unsigned DstAlign,
3692 LLVMValueRef Src, unsigned SrcAlign,
3694 return wrap(unwrap(B)->CreateMemMove(unwrap(Dst), MaybeAlign(DstAlign),
3695 unwrap(Src), MaybeAlign(SrcAlign),
3696 unwrap(Size)));
3697}
3698
3700 const char *Name) {
3701 return wrap(unwrap(B)->CreateAlloca(unwrap(Ty), nullptr, Name));
3702}
3703
3705 LLVMValueRef Val, const char *Name) {
3706 return wrap(unwrap(B)->CreateAlloca(unwrap(Ty), unwrap(Val), Name));
3707}
3708
3710 return wrap(unwrap(B)->CreateFree(unwrap(PointerVal)));
3711}
3712
3714 LLVMValueRef PointerVal, const char *Name) {
3715 return wrap(unwrap(B)->CreateLoad(unwrap(Ty), unwrap(PointerVal), Name));
3716}
3717
3719 LLVMValueRef PointerVal) {
3720 return wrap(unwrap(B)->CreateStore(unwrap(Val), unwrap(PointerVal)));
3721}
3722
3724 switch (Ordering) {
3725 case LLVMAtomicOrderingNotAtomic: return AtomicOrdering::NotAtomic;
3726 case LLVMAtomicOrderingUnordered: return AtomicOrdering::Unordered;
3727 case LLVMAtomicOrderingMonotonic: return AtomicOrdering::Monotonic;
3728 case LLVMAtomicOrderingAcquire: return AtomicOrdering::Acquire;
3729 case LLVMAtomicOrderingRelease: return AtomicOrdering::Release;
3731 return AtomicOrdering::AcquireRelease;
3733 return AtomicOrdering::SequentiallyConsistent;
3734 }
3735
3736 llvm_unreachable("Invalid LLVMAtomicOrdering value!");
3737}
3738
3740 switch (Ordering) {
3741 case AtomicOrdering::NotAtomic: return LLVMAtomicOrderingNotAtomic;
3742 case AtomicOrdering::Unordered: return LLVMAtomicOrderingUnordered;
3743 case AtomicOrdering::Monotonic: return LLVMAtomicOrderingMonotonic;
3744 case AtomicOrdering::Acquire: return LLVMAtomicOrderingAcquire;
3745 case AtomicOrdering::Release: return LLVMAtomicOrderingRelease;
3746 case AtomicOrdering::AcquireRelease:
3748 case AtomicOrdering::SequentiallyConsistent:
3750 }
3751
3752 llvm_unreachable("Invalid AtomicOrdering value!");
3753}
3754