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"
18#include "llvm/IR/Constants.h"
23#include "llvm/IR/GlobalAlias.h"
25#include "llvm/IR/IRBuilder.h"
26#include "llvm/IR/InlineAsm.h"
28#include "llvm/IR/LLVMContext.h"
30#include "llvm/IR/Module.h"
32#include "llvm/PassRegistry.h"
33#include "llvm/Support/Debug.h"
41#include <cassert>
42#include <cstdlib>
43#include <cstring>
44#include <system_error>
45
46using namespace llvm;
47
49
51 return reinterpret_cast<BasicBlock **>(BBs);
52}
53
54#define DEBUG_TYPE "ir"
55
62}
63
66}
67
68/*===-- Version query -----------------------------------------------------===*/
69
70void LLVMGetVersion(unsigned *Major, unsigned *Minor, unsigned *Patch) {
71 if (Major)
72 *Major = LLVM_VERSION_MAJOR;
73 if (Minor)
74 *Minor = LLVM_VERSION_MINOR;
75 if (Patch)
76 *Patch = LLVM_VERSION_PATCH;
77}
78
79/*===-- Error handling ----------------------------------------------------===*/
80
81char *LLVMCreateMessage(const char *Message) {
82 return strdup(Message);
83}
84
85void LLVMDisposeMessage(char *Message) {
86 free(Message);
87}
88
89
90/*===-- Operations on contexts --------------------------------------------===*/
91
93 static LLVMContext GlobalContext;
94 return GlobalContext;
95}
96
98 return wrap(new LLVMContext());
99}
100
102
104 LLVMDiagnosticHandler Handler,
105 void *DiagnosticContext) {
106 unwrap(C)->setDiagnosticHandlerCallBack(
108 Handler),
109 DiagnosticContext);
110}
111
113 return LLVM_EXTENSION reinterpret_cast<LLVMDiagnosticHandler>(
114 unwrap(C)->getDiagnosticHandlerCallBack());
115}
116
118 return unwrap(C)->getDiagnosticContext();
119}
120
122 void *OpaqueHandle) {
123 auto YieldCallback =
124 LLVM_EXTENSION reinterpret_cast<LLVMContext::YieldCallbackTy>(Callback);
125 unwrap(C)->setYieldCallback(YieldCallback, OpaqueHandle);
126}
127
129 return unwrap(C)->shouldDiscardValueNames();
130}
131
133 unwrap(C)->setDiscardValueNames(Discard);
134}
135
137 delete unwrap(C);
138}
139
141 unsigned SLen) {
142 return unwrap(C)->getMDKindID(StringRef(Name, SLen));
143}
144
145unsigned LLVMGetMDKindID(const char *Name, unsigned SLen) {
147}
148
149unsigned LLVMGetEnumAttributeKindForName(const char *Name, size_t SLen) {
151}
152
154 return Attribute::AttrKind::EndAttrKinds;
155}
156
158 uint64_t Val) {
159 auto &Ctx = *unwrap(C);
160 auto AttrKind = (Attribute::AttrKind)KindID;
161 return wrap(Attribute::get(Ctx, AttrKind, Val));
162}
163
165 return unwrap(A).getKindAsEnum();
166}
167
169 auto Attr = unwrap(A);
170 if (Attr.isEnumAttribute())
171 return 0;
172 return Attr.getValueAsInt();
173}
174
176 LLVMTypeRef type_ref) {
177 auto &Ctx = *unwrap(C);
178 auto AttrKind = (Attribute::AttrKind)KindID;
179 return wrap(Attribute::get(Ctx, AttrKind, unwrap(type_ref)));
180}
181
183 auto Attr = unwrap(A);
184 return wrap(Attr.getValueAsType());
185}
186
188 unsigned KindID,
189 unsigned NumBits,
190 const uint64_t LowerWords[],
191 const uint64_t UpperWords[]) {
192 auto &Ctx = *unwrap(C);
193 auto AttrKind = (Attribute::AttrKind)KindID;
194 unsigned NumWords = divideCeil(NumBits, 64);
195 return wrap(Attribute::get(
196 Ctx, AttrKind,
197 ConstantRange(APInt(NumBits, ArrayRef(LowerWords, NumWords)),
198 APInt(NumBits, ArrayRef(UpperWords, NumWords)))));
199}
200
202 const char *K, unsigned KLength,
203 const char *V, unsigned VLength) {
204 return wrap(Attribute::get(*unwrap(C), StringRef(K, KLength),
205 StringRef(V, VLength)));
206}
207
209 unsigned *Length) {
210 auto S = unwrap(A).getKindAsString();
211 *Length = S.size();
212 return S.data();
213}
214
216 unsigned *Length) {
217 auto S = unwrap(A).getValueAsString();
218 *Length = S.size();
219 return S.data();
220}
221
223 auto Attr = unwrap(A);
224 return Attr.isEnumAttribute() || Attr.isIntAttribute();
225}
226
228 return unwrap(A).isStringAttribute();
229}
230
232 return unwrap(A).isTypeAttribute();
233}
234
236 std::string MsgStorage;
237 raw_string_ostream Stream(MsgStorage);
239
240 unwrap(DI)->print(DP);
241 Stream.flush();
242
243 return LLVMCreateMessage(MsgStorage.c_str());
244}
245
247 LLVMDiagnosticSeverity severity;
248
249 switch(unwrap(DI)->getSeverity()) {
250 default:
251 severity = LLVMDSError;
252 break;
253 case DS_Warning:
254 severity = LLVMDSWarning;
255 break;
256 case DS_Remark:
257 severity = LLVMDSRemark;
258 break;
259 case DS_Note:
260 severity = LLVMDSNote;
261 break;
262 }
263
264 return severity;
265}
266
267/*===-- Operations on modules ---------------------------------------------===*/
268
270 return wrap(new Module(ModuleID, getGlobalContext()));
271}
272
275 return wrap(new Module(ModuleID, *unwrap(C)));
276}
277
279 delete unwrap(M);
280}
281
282const char *LLVMGetModuleIdentifier(LLVMModuleRef M, size_t *Len) {
283 auto &Str = unwrap(M)->getModuleIdentifier();
284 *Len = Str.length();
285 return Str.c_str();
286}
287
288void LLVMSetModuleIdentifier(LLVMModuleRef M, const char *Ident, size_t Len) {
289 unwrap(M)->setModuleIdentifier(StringRef(Ident, Len));
290}
291
292const char *LLVMGetSourceFileName(LLVMModuleRef M, size_t *Len) {
293 auto &Str = unwrap(M)->getSourceFileName();
294 *Len = Str.length();
295 return Str.c_str();
296}
297
298void LLVMSetSourceFileName(LLVMModuleRef M, const char *Name, size_t Len) {
299 unwrap(M)->setSourceFileName(StringRef(Name, Len));
300}
301
302/*--.. Data layout .........................................................--*/
304 return unwrap(M)->getDataLayoutStr().c_str();
305}
306
308 return LLVMGetDataLayoutStr(M);
309}
310
311void LLVMSetDataLayout(LLVMModuleRef M, const char *DataLayoutStr) {
312 unwrap(M)->setDataLayout(DataLayoutStr);
313}
314
315/*--.. Target triple .......................................................--*/
317 return unwrap(M)->getTargetTriple().c_str();
318}
319
320void LLVMSetTarget(LLVMModuleRef M, const char *Triple) {
321 unwrap(M)->setTargetTriple(Triple);
322}
323
324/*--.. Module flags ........................................................--*/
327 const char *Key;
328 size_t KeyLen;
330};
331
334 switch (Behavior) {
336 return Module::ModFlagBehavior::Error;
338 return Module::ModFlagBehavior::Warning;
340 return Module::ModFlagBehavior::Require;
342 return Module::ModFlagBehavior::Override;
344 return Module::ModFlagBehavior::Append;
346 return Module::ModFlagBehavior::AppendUnique;
347 }
348 llvm_unreachable("Unknown LLVMModuleFlagBehavior");
349}
350
353 switch (Behavior) {
354 case Module::ModFlagBehavior::Error:
356 case Module::ModFlagBehavior::Warning:
358 case Module::ModFlagBehavior::Require:
360 case Module::ModFlagBehavior::Override:
362 case Module::ModFlagBehavior::Append:
364 case Module::ModFlagBehavior::AppendUnique:
366 default:
367 llvm_unreachable("Unhandled Flag Behavior");
368 }
369}
370
373 unwrap(M)->getModuleFlagsMetadata(MFEs);
374
376 safe_malloc(MFEs.size() * sizeof(LLVMOpaqueModuleFlagEntry)));
377 for (unsigned i = 0; i < MFEs.size(); ++i) {
378 const auto &ModuleFlag = MFEs[i];
379 Result[i].Behavior = map_from_llvmModFlagBehavior(ModuleFlag.Behavior);
380 Result[i].Key = ModuleFlag.Key->getString().data();
381 Result[i].KeyLen = ModuleFlag.Key->getString().size();
382 Result[i].Metadata = wrap(ModuleFlag.Val);
383 }
384 *Len = MFEs.size();
385 return Result;
386}
387
389 free(Entries);
390}
391
394 unsigned Index) {
396 static_cast<LLVMOpaqueModuleFlagEntry>(Entries[Index]);
397 return MFE.Behavior;
398}
399
401 unsigned Index, size_t *Len) {
403 static_cast<LLVMOpaqueModuleFlagEntry>(Entries[Index]);
404 *Len = MFE.KeyLen;
405 return MFE.Key;
406}
407
409 unsigned Index) {
411 static_cast<LLVMOpaqueModuleFlagEntry>(Entries[Index]);
412 return MFE.Metadata;
413}
414
416 const char *Key, size_t KeyLen) {
417 return wrap(unwrap(M)->getModuleFlag({Key, KeyLen}));
418}
419
421 const char *Key, size_t KeyLen,
422 LLVMMetadataRef Val) {
423 unwrap(M)->addModuleFlag(map_to_llvmModFlagBehavior(Behavior),
424 {Key, KeyLen}, unwrap(Val));
425}
426
428 return unwrap(M)->IsNewDbgInfoFormat;
429}
430
432 unwrap(M)->setIsNewDbgInfoFormat(UseNewFormat);
433}
434
435/*--.. Printing modules ....................................................--*/
436
438 unwrap(M)->print(errs(), nullptr,
439 /*ShouldPreserveUseListOrder=*/false, /*IsForDebug=*/true);
440}
441
443 char **ErrorMessage) {
444 std::error_code EC;
445 raw_fd_ostream dest(Filename, EC, sys::fs::OF_TextWithCRLF);
446 if (EC) {
447 *ErrorMessage = strdup(EC.message().c_str());
448 return true;
449 }
450
451 unwrap(M)->print(dest, nullptr);
452
453 dest.close();
454
455 if (dest.has_error()) {
456 std::string E = "Error printing to file: " + dest.error().message();
457 *ErrorMessage = strdup(E.c_str());
458 return true;
459 }
460
461 return false;
462}
463
465 std::string buf;
466 raw_string_ostream os(buf);
467
468 unwrap(M)->print(os, nullptr);
469 os.flush();
470
471 return strdup(buf.c_str());
472}
473
474/*--.. Operations on inline assembler ......................................--*/
475void LLVMSetModuleInlineAsm2(LLVMModuleRef M, const char *Asm, size_t Len) {
476 unwrap(M)->setModuleInlineAsm(StringRef(Asm, Len));
477}
478
479void LLVMSetModuleInlineAsm(LLVMModuleRef M, const char *Asm) {
480 unwrap(M)->setModuleInlineAsm(StringRef(Asm));
481}
482
483void LLVMAppendModuleInlineAsm(LLVMModuleRef M, const char *Asm, size_t Len) {
484 unwrap(M)->appendModuleInlineAsm(StringRef(Asm, Len));
485}
486
487const char *LLVMGetModuleInlineAsm(LLVMModuleRef M, size_t *Len) {
488 auto &Str = unwrap(M)->getModuleInlineAsm();
489 *Len = Str.length();
490 return Str.c_str();
491}
492
493LLVMValueRef LLVMGetInlineAsm(LLVMTypeRef Ty, const char *AsmString,
494 size_t AsmStringSize, const char *Constraints,
495 size_t ConstraintsSize, LLVMBool HasSideEffects,
496 LLVMBool IsAlignStack,
497 LLVMInlineAsmDialect Dialect, LLVMBool CanThrow) {
499 switch (Dialect) {
502 break;
505 break;
506 }
507 return wrap(InlineAsm::get(unwrap<FunctionType>(Ty),
508 StringRef(AsmString, AsmStringSize),
509 StringRef(Constraints, ConstraintsSize),
510 HasSideEffects, IsAlignStack, AD, CanThrow));
511}
512
513const char *LLVMGetInlineAsmAsmString(LLVMValueRef InlineAsmVal, size_t *Len) {
514
515 Value *Val = unwrap<Value>(InlineAsmVal);
516 const std::string &AsmString = cast<InlineAsm>(Val)->getAsmString();
517
518 *Len = AsmString.length();
519 return AsmString.c_str();
520}
521
523 size_t *Len) {
524 Value *Val = unwrap<Value>(InlineAsmVal);
525 const std::string &ConstraintString =
526 cast<InlineAsm>(Val)->getConstraintString();
527
528 *Len = ConstraintString.length();
529 return ConstraintString.c_str();
530}
531
533
534 Value *Val = unwrap<Value>(InlineAsmVal);
535 InlineAsm::AsmDialect Dialect = cast<InlineAsm>(Val)->getDialect();
536
537 switch (Dialect) {
542 }
543
544 llvm_unreachable("Unrecognized inline assembly dialect");
546}
547
549 Value *Val = unwrap<Value>(InlineAsmVal);
550 return (LLVMTypeRef)cast<InlineAsm>(Val)->getFunctionType();
551}
552
554 Value *Val = unwrap<Value>(InlineAsmVal);
555 return cast<InlineAsm>(Val)->hasSideEffects();
556}
557
559 Value *Val = unwrap<Value>(InlineAsmVal);
560 return cast<InlineAsm>(Val)->isAlignStack();
561}
562
564 Value *Val = unwrap<Value>(InlineAsmVal);
565 return cast<InlineAsm>(Val)->canThrow();
566}
567
568/*--.. Operations on module contexts ......................................--*/
570 return wrap(&unwrap(M)->getContext());
571}
572
573
574/*===-- Operations on types -----------------------------------------------===*/
575
576/*--.. Operations on all types (mostly) ....................................--*/
577
579 switch (unwrap(Ty)->getTypeID()) {
580 case Type::VoidTyID:
581 return LLVMVoidTypeKind;
582 case Type::HalfTyID:
583 return LLVMHalfTypeKind;
584 case Type::BFloatTyID:
585 return LLVMBFloatTypeKind;
586 case Type::FloatTyID:
587 return LLVMFloatTypeKind;
588 case Type::DoubleTyID:
589 return LLVMDoubleTypeKind;
592 case Type::FP128TyID:
593 return LLVMFP128TypeKind;
596 case Type::LabelTyID:
597 return LLVMLabelTypeKind;
601 return LLVMIntegerTypeKind;
604 case Type::StructTyID:
605 return LLVMStructTypeKind;
606 case Type::ArrayTyID:
607 return LLVMArrayTypeKind;
609 return LLVMPointerTypeKind;
611 return LLVMVectorTypeKind;
613 return LLVMX86_MMXTypeKind;
615 return LLVMX86_AMXTypeKind;
616 case Type::TokenTyID:
617 return LLVMTokenTypeKind;
623 llvm_unreachable("Typed pointers are unsupported via the C API");
624 }
625 llvm_unreachable("Unhandled TypeID.");
626}
627
629{
630 return unwrap(Ty)->isSized();
631}
632
634 return wrap(&unwrap(Ty)->getContext());
635}
636
638 return unwrap(Ty)->print(errs(), /*IsForDebug=*/true);
639}
640
642 std::string buf;
643 raw_string_ostream os(buf);
644
645 if (unwrap(Ty))
646 unwrap(Ty)->print(os);
647 else
648 os << "Printing <null> Type";
649
650 os.flush();
651
652 return strdup(buf.c_str());
653}
654
655/*--.. Operations on integer types .........................................--*/
656
659}
662}
665}
668}
671}
674}
676 return wrap(IntegerType::get(*unwrap(C), NumBits));
677}
678
681}
684}
687}
690}
693}
696}
697LLVMTypeRef LLVMIntType(unsigned NumBits) {
699}
700
701unsigned LLVMGetIntTypeWidth(LLVMTypeRef IntegerTy) {
702 return unwrap<IntegerType>(IntegerTy)->getBitWidth();
703}
704
705/*--.. Operations on real types ............................................--*/
706
709}
712}
715}
718}
721}
724}
727}
730}
733}
734
737}
740}
743}
746}
749}
752}
755}
758}
761}
762
763/*--.. Operations on function types ........................................--*/
764
766 LLVMTypeRef *ParamTypes, unsigned ParamCount,
767 LLVMBool IsVarArg) {
768 ArrayRef<Type*> Tys(unwrap(ParamTypes), ParamCount);
769 return wrap(FunctionType::get(unwrap(ReturnType), Tys, IsVarArg != 0));
770}
771
773 return unwrap<FunctionType>(FunctionTy)->isVarArg();
774}
775
777 return wrap(unwrap<FunctionType>(FunctionTy)->getReturnType());
778}
779
780unsigned LLVMCountParamTypes(LLVMTypeRef FunctionTy) {
781 return unwrap<FunctionType>(FunctionTy)->getNumParams();
782}
783
785 FunctionType *Ty = unwrap<FunctionType>(FunctionTy);
786 for (Type *T : Ty->params())
787 *Dest++ = wrap(T);
788}
789
790/*--.. Operations on struct types ..........................................--*/
791
793 unsigned ElementCount, LLVMBool Packed) {
794 ArrayRef<Type*> Tys(unwrap(ElementTypes), ElementCount);
795 return wrap(StructType::get(*unwrap(C), Tys, Packed != 0));
796}
797
799 unsigned ElementCount, LLVMBool Packed) {
800 return LLVMStructTypeInContext(LLVMGetGlobalContext(), ElementTypes,
801 ElementCount, Packed);
802}
803
805{
806 return wrap(StructType::create(*unwrap(C), Name));
807}
808
810{
811 StructType *Type = unwrap<StructType>(Ty);
812 if (!Type->hasName())
813 return nullptr;
814 return Type->getName().data();
815}
816
817void LLVMStructSetBody(LLVMTypeRef StructTy, LLVMTypeRef *ElementTypes,
818 unsigned ElementCount, LLVMBool Packed) {
819 ArrayRef<Type*> Tys(unwrap(ElementTypes), ElementCount);
820 unwrap<StructType>(StructTy)->setBody(Tys, Packed != 0);
821}
822
824 return unwrap<StructType>(StructTy)->getNumElements();
825}
826
828 StructType *Ty = unwrap<StructType>(StructTy);
829 for (Type *T : Ty->elements())
830 *Dest++ = wrap(T);
831}
832
834 StructType *Ty = unwrap<StructType>(StructTy);
835 return wrap(Ty->getTypeAtIndex(i));
836}
837
839 return unwrap<StructType>(StructTy)->isPacked();
840}
841
843 return unwrap<StructType>(StructTy)->isOpaque();
844}
845
847 return unwrap<StructType>(StructTy)->isLiteral();
848}
849
851 return wrap(StructType::getTypeByName(unwrap(M)->getContext(), Name));
852}
853
856}
857
858/*--.. Operations on array, pointer, and vector types (sequence types) .....--*/
859
861 int i = 0;
862 for (auto *T : unwrap(Tp)->subtypes()) {
863 Arr[i] = wrap(T);
864 i++;
865 }
866}
867
869 return wrap(ArrayType::get(unwrap(ElementType), ElementCount));
870}
871
873 return wrap(ArrayType::get(unwrap(ElementType), ElementCount));
874}
875
877 return wrap(PointerType::get(unwrap(ElementType), AddressSpace));
878}
879
881 return true;
882}
883
885 return wrap(FixedVectorType::get(unwrap(ElementType), ElementCount));
886}
887
889 unsigned ElementCount) {
890 return wrap(ScalableVectorType::get(unwrap(ElementType), ElementCount));
891}
892
894 auto *Ty = unwrap(WrappedTy);
895 if (auto *ATy = dyn_cast<ArrayType>(Ty))
896 return wrap(ATy->getElementType());
897 return wrap(cast<VectorType>(Ty)->getElementType());
898}
899
901 return unwrap(Tp)->getNumContainedTypes();
902}
903
905 return unwrap<ArrayType>(ArrayTy)->getNumElements();
906}
907
909 return unwrap<ArrayType>(ArrayTy)->getNumElements();
910}
911
913 return unwrap<PointerType>(PointerTy)->getAddressSpace();
914}
915
916unsigned LLVMGetVectorSize(LLVMTypeRef VectorTy) {
917 return unwrap<VectorType>(VectorTy)->getElementCount().getKnownMinValue();
918}
919
920/*--.. Operations on other types ...........................................--*/
921
923 return wrap(PointerType::get(*unwrap(C), AddressSpace));
924}
925
927 return wrap(Type::getVoidTy(*unwrap(C)));
928}
930 return wrap(Type::getLabelTy(*unwrap(C)));
931}
933 return wrap(Type::getTokenTy(*unwrap(C)));
934}
936 return wrap(Type::getMetadataTy(*unwrap(C)));
937}
938
941}
944}
945
947 LLVMTypeRef *TypeParams,
948 unsigned TypeParamCount,
949 unsigned *IntParams,
950 unsigned IntParamCount) {
951 ArrayRef<Type *> TypeParamArray(unwrap(TypeParams), TypeParamCount);
952 ArrayRef<unsigned> IntParamArray(IntParams, IntParamCount);
953 return wrap(
954 TargetExtType::get(*unwrap(C), Name, TypeParamArray, IntParamArray));
955}
956
957const char *LLVMGetTargetExtTypeName(LLVMTypeRef TargetExtTy) {
958 TargetExtType *Type = unwrap<TargetExtType>(TargetExtTy);
959 return Type->getName().data();
960}
961
963 TargetExtType *Type = unwrap<TargetExtType>(TargetExtTy);
964 return Type->getNumTypeParameters();
965}
966
968 unsigned Idx) {
969 TargetExtType *Type = unwrap<TargetExtType>(TargetExtTy);
970 return wrap(Type->getTypeParameter(Idx));
971}
972
974 TargetExtType *Type = unwrap<TargetExtType>(TargetExtTy);
975 return Type->getNumIntParameters();
976}
977
978unsigned LLVMGetTargetExtTypeIntParam(LLVMTypeRef TargetExtTy, unsigned Idx) {
979 TargetExtType *Type = unwrap<TargetExtType>(TargetExtTy);
980 return Type->getIntParameter(Idx);
981}
982
983/*===-- Operations on values ----------------------------------------------===*/
984
985/*--.. Operations on all values ............................................--*/
986
988 return wrap(unwrap(Val)->getType());
989}
990
992 switch(unwrap(Val)->getValueID()) {
993#define LLVM_C_API 1
994#define HANDLE_VALUE(Name) \
995 case Value::Name##Val: \
996 return LLVM##Name##ValueKind;
997#include "llvm/IR/Value.def"
998 default:
1000 }
1001}
1002
1003const char *LLVMGetValueName2(LLVMValueRef Val, size_t *Length) {
1004 auto *V = unwrap(Val);
1005 *Length = V->getName().size();
1006 return V->getName().data();
1007}
1008
1009void LLVMSetValueName2(LLVMValueRef Val, const char *Name, size_t NameLen) {
1010 unwrap(Val)->setName(StringRef(Name, NameLen));
1011}
1012
1014 return unwrap(Val)->getName().data();
1015}
1016
1017void LLVMSetValueName(LLVMValueRef Val, const char *Name) {
1018 unwrap(Val)->setName(Name);
1019}
1020
1022 unwrap(Val)->print(errs(), /*IsForDebug=*/true);
1023}
1024
1026 std::string buf;
1027 raw_string_ostream os(buf);
1028
1029 if (unwrap(Val))
1030 unwrap(Val)->print(os);
1031 else
1032 os << "Printing <null> Value";
1033
1034 os.flush();
1035
1036 return strdup(buf.c_str());
1037}
1038
1040 std::string buf;
1041 raw_string_ostream os(buf);
1042
1043 if (unwrap(Record))
1044 unwrap(Record)->print(os);
1045 else
1046 os << "Printing <null> DbgRecord";
1047
1048 os.flush();
1049
1050 return strdup(buf.c_str());
1051}
1052
1054 unwrap(OldVal)->replaceAllUsesWith(unwrap(NewVal));
1055}
1056
1058 return unwrap<Instruction>(Inst)->hasMetadata();
1059}
1060
1062 auto *I = unwrap<Instruction>(Inst);
1063 assert(I && "Expected instruction");
1064 if (auto *MD = I->getMetadata(KindID))
1065 return wrap(MetadataAsValue::get(I->getContext(), MD));
1066 return nullptr;
1067}
1068
1069// MetadataAsValue uses a canonical format which strips the actual MDNode for
1070// MDNode with just a single constant value, storing just a ConstantAsMetadata
1071// This undoes this canonicalization, reconstructing the MDNode.
1073 Metadata *MD = MAV->getMetadata();
1074 assert((isa<MDNode>(MD) || isa<ConstantAsMetadata>(MD)) &&
1075 "Expected a metadata node or a canonicalized constant");
1076
1077 if (MDNode *N = dyn_cast<MDNode>(MD))
1078 return N;
1079
1080 return MDNode::get(MAV->getContext(), MD);
1081}
1082
1083void LLVMSetMetadata(LLVMValueRef Inst, unsigned KindID, LLVMValueRef Val) {
1084 MDNode *N = Val ? extractMDNode(unwrap<MetadataAsValue>(Val)) : nullptr;
1085
1086 unwrap<Instruction>(Inst)->setMetadata(KindID, N);
1087}
1088
1090 unsigned Kind;
1092};
1093
1096llvm_getMetadata(size_t *NumEntries,
1097 llvm::function_ref<void(MetadataEntries &)> AccessMD) {
1099 AccessMD(MVEs);
1100
1102 static_cast<LLVMOpaqueValueMetadataEntry *>(
1104 for (unsigned i = 0; i < MVEs.size(); ++i) {
1105 const auto &ModuleFlag = MVEs[i];
1106 Result[i].Kind = ModuleFlag.first;
1107 Result[i].Metadata = wrap(ModuleFlag.second);
1108 }
1109 *NumEntries = MVEs.size();
1110 return Result;
1111}
1112
1115 size_t *NumEntries) {
1116 return llvm_getMetadata(NumEntries, [&Value](MetadataEntries &Entries) {
1117 Entries.clear();
1118 unwrap<Instruction>(Value)->getAllMetadata(Entries);
1119 });
1120}
1121
1122/*--.. Conversion functions ................................................--*/
1123
1124#define LLVM_DEFINE_VALUE_CAST(name) \
1125 LLVMValueRef LLVMIsA##name(LLVMValueRef Val) { \
1126 return wrap(static_cast<Value*>(dyn_cast_or_null<name>(unwrap(Val)))); \
1127 }
1128
1130
1132 if (auto *MD = dyn_cast_or_null<MetadataAsValue>(unwrap(Val)))
1133 if (isa<MDNode>(MD->getMetadata()) ||
1134 isa<ValueAsMetadata>(MD->getMetadata()))
1135 return Val;
1136 return nullptr;
1137}
1138
1140 if (auto *MD = dyn_cast_or_null<MetadataAsValue>(unwrap(Val)))
1141 if (isa<ValueAsMetadata>(MD->getMetadata()))
1142 return Val;
1143 return nullptr;
1144}
1145
1147 if (auto *MD = dyn_cast_or_null<MetadataAsValue>(unwrap(Val)))
1148 if (isa<MDString>(MD->getMetadata()))
1149 return Val;
1150 return nullptr;
1151}
1152
1153/*--.. Operations on Uses ..................................................--*/
1155 Value *V = unwrap(Val);
1156 Value::use_iterator I = V->use_begin();
1157 if (I == V->use_end())
1158 return nullptr;
1159 return wrap(&*I);
1160}
1161
1163 Use *Next = unwrap(U)->getNext();
1164 if (Next)
1165 return wrap(Next);
1166 return nullptr;
1167}
1168
1170 return wrap(unwrap(U)->getUser());
1171}
1172
1174 return wrap(unwrap(U)->get());
1175}
1176
1177/*--.. Operations on Users .................................................--*/
1178
1180 unsigned Index) {
1181 Metadata *Op = N->getOperand(Index);
1182 if (!Op)
1183 return nullptr;
1184 if (auto *C = dyn_cast<ConstantAsMetadata>(Op))
1185 return wrap(C->getValue());
1186 return wrap(MetadataAsValue::get(Context, Op));
1187}
1188
1190 Value *V = unwrap(Val);
1191 if (auto *MD = dyn_cast<MetadataAsValue>(V)) {
1192 if (auto *L = dyn_cast<ValueAsMetadata>(MD->getMetadata())) {
1193 assert(Index == 0 && "Function-local metadata can only have one operand");
1194 return wrap(L->getValue());
1195 }
1196 return getMDNodeOperandImpl(V->getContext(),
1197 cast<MDNode>(MD->getMetadata()), Index);
1198 }
1199
1200 return wrap(cast<User>(V)->getOperand(Index));
1201}
1202
1204 Value *V = unwrap(Val);
1205 return wrap(&cast<User>(V)->getOperandUse(Index));
1206}
1207
1209 unwrap<User>(Val)->setOperand(Index, unwrap(Op));
1210}
1211
1213 Value *V = unwrap(Val);
1214 if (isa<MetadataAsValue>(V))
1215 return LLVMGetMDNodeNumOperands(Val);
1216
1217 return cast<User>(V)->getNumOperands();
1218}
1219
1220/*--.. Operations on constants of any type .................................--*/
1221
1223 return wrap(Constant::getNullValue(unwrap(Ty)));
1224}
1225
1228}
1229
1231 return wrap(UndefValue::get(unwrap(Ty)));
1232}
1233
1235 return wrap(PoisonValue::get(unwrap(Ty)));
1236}
1237
1239 return isa<Constant>(unwrap(Ty));
1240}
1241
1243 if (Constant *C = dyn_cast<Constant>(unwrap(Val)))
1244 return C->isNullValue();
1245 return false;
1246}
1247
1249 return isa<UndefValue>(unwrap(Val));
1250}
1251
1253 return isa<PoisonValue>(unwrap(Val));
1254}
1255
1257 return wrap(ConstantPointerNull::get(unwrap<PointerType>(Ty)));
1258}
1259
1260/*--.. Operations on metadata nodes ........................................--*/
1261
1263 size_t SLen) {
1264 return wrap(MDString::get(*unwrap(C), StringRef(Str, SLen)));
1265}
1266
1268 size_t Count) {
1269 return wrap(MDNode::get(*unwrap(C), ArrayRef<Metadata*>(unwrap(MDs), Count)));
1270}
1271
1273 unsigned SLen) {
1274 LLVMContext &Context = *unwrap(C);
1276 Context, MDString::get(Context, StringRef(Str, SLen))));
1277}
1278
1279LLVMValueRef LLVMMDString(const char *Str, unsigned SLen) {
1280 return LLVMMDStringInContext(LLVMGetGlobalContext(), Str, SLen);
1281}
1282
1284 unsigned Count) {
1285 LLVMContext &Context = *unwrap(C);
1287 for (auto *OV : ArrayRef(Vals, Count)) {
1288 Value *V = unwrap(OV);
1289 Metadata *MD;
1290 if (!V)
1291 MD = nullptr;
1292 else if (auto *C = dyn_cast<Constant>(V))
1294 else if (auto *MDV = dyn_cast<MetadataAsValue>(V)) {
1295 MD = MDV->getMetadata();
1296 assert(!isa<LocalAsMetadata>(MD) && "Unexpected function-local metadata "
1297 "outside of direct argument to call");
1298 } else {
1299 // This is function-local metadata. Pretend to make an MDNode.
1300 assert(Count == 1 &&
1301 "Expected only one operand to function-local metadata");
1302 return wrap(MetadataAsValue::get(Context, LocalAsMetadata::get(V)));
1303 }
1304
1305 MDs.push_back(MD);
1306 }
1307 return wrap(MetadataAsValue::get(Context, MDNode::get(Context, MDs)));
1308}
1309
1310LLVMValueRef LLVMMDNode(LLVMValueRef *Vals, unsigned Count) {
1311 return LLVMMDNodeInContext(LLVMGetGlobalContext(), Vals, Count);
1312}
1313
1315 return wrap(MetadataAsValue::get(*unwrap(C), unwrap(MD)));
1316}
1317
1319 auto *V = unwrap(Val);
1320 if (auto *C = dyn_cast<Constant>(V))
1322 if (auto *MAV = dyn_cast<MetadataAsValue>(V))
1323 return wrap(MAV->getMetadata());
1324 return wrap(ValueAsMetadata::get(V));
1325}
1326
1327const char *LLVMGetMDString(LLVMValueRef V, unsigned *Length) {
1328 if (const auto *MD = dyn_cast<MetadataAsValue>(unwrap(V)))
1329 if (const MDString *S = dyn_cast<MDString>(MD->getMetadata())) {
1330 *Length = S->getString().size();
1331 return S->getString().data();
1332 }
1333 *Length = 0;
1334 return nullptr;
1335}
1336
1338 auto *MD = unwrap<MetadataAsValue>(V);
1339 if (isa<ValueAsMetadata>(MD->getMetadata()))
1340 return 1;
1341 return cast<MDNode>(MD->getMetadata())->getNumOperands();
1342}
1343
1345 Module *Mod = unwrap(M);
1347 if (I == Mod->named_metadata_end())
1348 return nullptr;
1349 return wrap(&*I);
1350}
1351
1353 Module *Mod = unwrap(M);
1355 if (I == Mod->named_metadata_begin())
1356 return nullptr;
1357 return wrap(&*--I);
1358}
1359
1361 NamedMDNode *NamedNode = unwrap(NMD);
1363 if (++I == NamedNode->getParent()->named_metadata_end())
1364 return nullptr;
1365 return wrap(&*I);
1366}
1367
1369 NamedMDNode *NamedNode = unwrap(NMD);
1371 if (I == NamedNode->getParent()->named_metadata_begin())
1372 return nullptr;
1373 return wrap(&*--I);
1374}
1375
1377 const char *Name, size_t NameLen) {
1378 return wrap(unwrap(M)->getNamedMetadata(StringRef(Name, NameLen)));
1379}
1380
1382 const char *Name, size_t NameLen) {
1383 return wrap(unwrap(M)->getOrInsertNamedMetadata({Name, NameLen}));
1384}
1385
1386const char *LLVMGetNamedMetadataName(LLVMNamedMDNodeRef NMD, size_t *NameLen) {
1387 NamedMDNode *NamedNode = unwrap(NMD);
1388 *NameLen = NamedNode->getName().size();
1389 return NamedNode->getName().data();
1390}
1391
1393 auto *MD = unwrap<MetadataAsValue>(V);
1394 if (auto *MDV = dyn_cast<ValueAsMetadata>(MD->getMetadata())) {
1395 *Dest = wrap(MDV->getValue());
1396 return;
1397 }
1398 const auto *N = cast<MDNode>(MD->getMetadata());
1399 const unsigned numOperands = N->getNumOperands();
1400 LLVMContext &Context = unwrap(V)->getContext();
1401 for (unsigned i = 0; i < numOperands; i++)
1402 Dest[i] = getMDNodeOperandImpl(Context, N, i);
1403}
1404
1406 LLVMMetadataRef Replacement) {
1407 auto *MD = cast<MetadataAsValue>(unwrap(V));
1408 auto *N = cast<MDNode>(MD->getMetadata());
1409 N->replaceOperandWith(Index, unwrap<Metadata>(Replacement));
1410}
1411
1413 if (NamedMDNode *N = unwrap(M)->getNamedMetadata(Name)) {
1414 return N->getNumOperands();
1415 }
1416 return 0;
1417}
1418
1420 LLVMValueRef *Dest) {
1421 NamedMDNode *N = unwrap(M)->getNamedMetadata(Name);
1422 if (!N)
1423 return;
1424 LLVMContext &Context = unwrap(M)->getContext();
1425 for (unsigned i=0;i<N->getNumOperands();i++)
1426 Dest[i] = wrap(MetadataAsValue::get(Context, N->getOperand(i)));
1427}
1428
1430 LLVMValueRef Val) {
1431 NamedMDNode *N = unwrap(M)->getOrInsertNamedMetadata(Name);
1432 if (!N)
1433 return;
1434 if (!Val)
1435 return;
1436 N->addOperand(extractMDNode(unwrap<MetadataAsValue>(Val)));
1437}
1438
1439const char *LLVMGetDebugLocDirectory(LLVMValueRef Val, unsigned *Length) {
1440 if (!Length) return nullptr;
1441 StringRef S;
1442 if (const auto *I = dyn_cast<Instruction>(unwrap(Val))) {
1443 if (const auto &DL = I->getDebugLoc()) {
1444 S = DL->getDirectory();
1445 }
1446 } else if (const auto *GV = dyn_cast<GlobalVariable>(unwrap(Val))) {
1448 GV->getDebugInfo(GVEs);
1449 if (GVEs.size())
1450 if (const DIGlobalVariable *DGV = GVEs[0]->getVariable())
1451 S = DGV->getDirectory();
1452 } else if (const auto *F = dyn_cast<Function>(unwrap(Val))) {
1453 if (const DISubprogram *DSP = F->getSubprogram())
1454 S = DSP->getDirectory();
1455 } else {
1456 assert(0 && "Expected Instruction, GlobalVariable or Function");
1457 return nullptr;
1458 }
1459 *Length = S.size();
1460 return S.data();
1461}
1462
1463const char *LLVMGetDebugLocFilename(LLVMValueRef Val, unsigned *Length) {
1464 if (!Length) return nullptr;
1465 StringRef S;
1466 if (const auto *I = dyn_cast<Instruction>(unwrap(Val))) {
1467 if (const auto &DL = I->getDebugLoc()) {
1468 S = DL->getFilename();
1469 }
1470 } else if (const auto *GV = dyn_cast<GlobalVariable>(unwrap(Val))) {
1472 GV->getDebugInfo(GVEs);
1473 if (GVEs.size())
1474 if (const DIGlobalVariable *DGV = GVEs[0]->getVariable())
1475 S = DGV->getFilename();
1476 } else if (const auto *F = dyn_cast<Function>(unwrap(Val))) {
1477 if (const DISubprogram *DSP = F->getSubprogram())
1478 S = DSP->getFilename();
1479 } else {
1480 assert(0 && "Expected Instruction, GlobalVariable or Function");
1481 return nullptr;
1482 }
1483 *Length = S.size();
1484 return S.data();
1485}
1486
1488 unsigned L = 0;
1489 if (const auto *I = dyn_cast<Instruction>(unwrap(Val))) {
1490 if (const auto &DL = I->getDebugLoc()) {
1491 L = DL->getLine();
1492 }
1493 } else if (const auto *GV = dyn_cast<GlobalVariable>(unwrap(Val))) {
1495 GV->getDebugInfo(GVEs);
1496 if (GVEs.size())
1497 if (const DIGlobalVariable *DGV = GVEs[0]->getVariable())
1498 L = DGV->getLine();
1499 } else if (const auto *F = dyn_cast<Function>(unwrap(Val))) {
1500 if (const DISubprogram *DSP = F->getSubprogram())
1501 L = DSP->getLine();
1502 } else {
1503 assert(0 && "Expected Instruction, GlobalVariable or Function");
1504 return -1;
1505 }
1506 return L;
1507}
1508
1510 unsigned C = 0;
1511 if (const auto *I = dyn_cast<Instruction>(unwrap(Val)))
1512 if (const auto &DL = I->getDebugLoc())
1513 C = DL->getColumn();
1514 return C;
1515}
1516
1517/*--.. Operations on scalar constants ......................................--*/
1518
1519LLVMValueRef LLVMConstInt(LLVMTypeRef IntTy, unsigned long long N,
1520 LLVMBool SignExtend) {
1521 return wrap(ConstantInt::get(unwrap<IntegerType>(IntTy), N, SignExtend != 0));
1522}
1523
1525 unsigned NumWords,
1526 const uint64_t Words[]) {
1527 IntegerType *Ty = unwrap<IntegerType>(IntTy);
1528 return wrap(ConstantInt::get(
1529 Ty->getContext(), APInt(Ty->getBitWidth(), ArrayRef(Words, NumWords))));
1530}
1531
1533 uint8_t Radix) {
1534 return wrap(ConstantInt::get(unwrap<IntegerType>(IntTy), StringRef(Str),
1535 Radix));
1536}
1537
1539 unsigned SLen, uint8_t Radix) {
1540 return wrap(ConstantInt::get(unwrap<IntegerType>(IntTy), StringRef(Str, SLen),
1541 Radix));
1542}
1543
1545 return wrap(ConstantFP::get(unwrap(RealTy), N));
1546}
1547
1549 return wrap(ConstantFP::get(unwrap(RealTy), StringRef(Text)));
1550}
1551
1553 unsigned SLen) {
1554 return wrap(ConstantFP::get(unwrap(RealTy), StringRef(Str, SLen)));
1555}
1556
1557unsigned long long LLVMConstIntGetZExtValue(LLVMValueRef ConstantVal) {
1558 return unwrap<ConstantInt>(ConstantVal)->getZExtValue();
1559}
1560
1562 return unwrap<ConstantInt>(ConstantVal)->getSExtValue();
1563}
1564
1565double LLVMConstRealGetDouble(LLVMValueRef ConstantVal, LLVMBool *LosesInfo) {
1566 ConstantFP *cFP = unwrap<ConstantFP>(ConstantVal) ;
1567 Type *Ty = cFP->getType();
1568
1569 if (Ty->isHalfTy() || Ty->isBFloatTy() || Ty->isFloatTy() ||
1570 Ty->isDoubleTy()) {
1571 *LosesInfo = false;
1572 return cFP->getValueAPF().convertToDouble();
1573 }
1574
1575 bool APFLosesInfo;
1576 APFloat APF = cFP->getValueAPF();
1577 APF.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven, &APFLosesInfo);
1578 *LosesInfo = APFLosesInfo;
1579 return APF.convertToDouble();
1580}
1581
1582/*--.. Operations on composite constants ...................................--*/
1583
1585 unsigned Length,
1586 LLVMBool DontNullTerminate) {
1587 /* Inverted the sense of AddNull because ', 0)' is a
1588 better mnemonic for null termination than ', 1)'. */
1590 DontNullTerminate == 0));
1591}
1592
1594 size_t Length,
1595 LLVMBool DontNullTerminate) {
1596 /* Inverted the sense of AddNull because ', 0)' is a
1597 better mnemonic for null termination than ', 1)'. */
1599 DontNullTerminate == 0));
1600}
1601
1602LLVMValueRef LLVMConstString(const char *Str, unsigned Length,
1603 LLVMBool DontNullTerminate) {
1605 DontNullTerminate);
1606}
1607
1609 return wrap(unwrap<Constant>(C)->getAggregateElement(Idx));
1610}
1611
1613 return wrap(unwrap<ConstantDataSequential>(C)->getElementAsConstant(idx));
1614}
1615
1617 return unwrap<ConstantDataSequential>(C)->isString();
1618}
1619
1620const char *LLVMGetAsString(LLVMValueRef C, size_t *Length) {
1621 StringRef Str = unwrap<ConstantDataSequential>(C)->getAsString();
1622 *Length = Str.size();
1623 return Str.data();
1624}
1625
1627 LLVMValueRef *ConstantVals, unsigned Length) {
1628 ArrayRef<Constant*> V(unwrap<Constant>(ConstantVals, Length), Length);
1629 return wrap(ConstantArray::get(ArrayType::get(unwrap(ElementTy), Length), V));
1630}
1631
1633 uint64_t Length) {
1634 ArrayRef<Constant *> V(unwrap<Constant>(ConstantVals, Length), Length);
1635 return wrap(ConstantArray::get(ArrayType::get(unwrap(ElementTy), Length), V));
1636}
1637
1639 LLVMValueRef *ConstantVals,
1640 unsigned Count, LLVMBool Packed) {
1641 Constant **Elements = unwrap<Constant>(ConstantVals, Count);
1642 return wrap(ConstantStruct::getAnon(*unwrap(C), ArrayRef(Elements, Count),
1643 Packed != 0));
1644}
1645
1646LLVMValueRef LLVMConstStruct(LLVMValueRef *ConstantVals, unsigned Count,
1647 LLVMBool Packed) {
1648 return LLVMConstStructInContext(LLVMGetGlobalContext(), ConstantVals, Count,
1649 Packed);
1650}
1651
1653 LLVMValueRef *ConstantVals,
1654 unsigned Count) {
1655 Constant **Elements = unwrap<Constant>(ConstantVals, Count);
1656 StructType *Ty = unwrap<StructType>(StructTy);
1657
1658 return wrap(ConstantStruct::get(Ty, ArrayRef(Elements, Count)));
1659}
1660
1661LLVMValueRef LLVMConstVector(LLVMValueRef *ScalarConstantVals, unsigned Size) {
1663 ArrayRef(unwrap<Constant>(ScalarConstantVals, Size), Size)));
1664}
1665
1666/*-- Opcode mapping */
1667
1669{
1670 switch (opcode) {
1671 default: llvm_unreachable("Unhandled Opcode.");
1672#define HANDLE_INST(num, opc, clas) case num: return LLVM##opc;
1673#include "llvm/IR/Instruction.def"
1674#undef HANDLE_INST
1675 }
1676}
1677
1679{
1680 switch (code) {
1681#define HANDLE_INST(num, opc, clas) case LLVM##opc: return num;
1682#include "llvm/IR/Instruction.def"
1683#undef HANDLE_INST
1684 }
1685 llvm_unreachable("Unhandled Opcode.");
1686}
1687
1688/*--.. Constant expressions ................................................--*/
1689
1691 return map_to_llvmopcode(unwrap<ConstantExpr>(ConstantVal)->getOpcode());
1692}
1693
1696}
1697
1699 return wrap(ConstantExpr::getSizeOf(unwrap(Ty)));
1700}
1701
1703 return wrap(ConstantExpr::getNeg(unwrap<Constant>(ConstantVal)));
1704}
1705
1707 return wrap(ConstantExpr::getNSWNeg(unwrap<Constant>(ConstantVal)));
1708}
1709
1711 return wrap(ConstantExpr::getNeg(unwrap<Constant>(ConstantVal)));
1712}
1713
1714
1716 return wrap(ConstantExpr::getNot(unwrap<Constant>(ConstantVal)));
1717}
1718
1720 return wrap(ConstantExpr::getAdd(unwrap<Constant>(LHSConstant),
1721 unwrap<Constant>(RHSConstant)));
1722}
1723
1725 LLVMValueRef RHSConstant) {
1726 return wrap(ConstantExpr::getNSWAdd(unwrap<Constant>(LHSConstant),
1727 unwrap<Constant>(RHSConstant)));
1728}
1729
1731 LLVMValueRef RHSConstant) {
1732 return wrap(ConstantExpr::getNUWAdd(unwrap<Constant>(LHSConstant),
1733 unwrap<Constant>(RHSConstant)));
1734}
1735
1737 return wrap(ConstantExpr::getSub(unwrap<Constant>(LHSConstant),
1738 unwrap<Constant>(RHSConstant)));
1739}
1740
1742 LLVMValueRef RHSConstant) {
1743 return wrap(ConstantExpr::getNSWSub(unwrap<Constant>(LHSConstant),
1744 unwrap<Constant>(RHSConstant)));
1745}
1746
1748 LLVMValueRef RHSConstant) {
1749 return wrap(ConstantExpr::getNUWSub(unwrap<Constant>(LHSConstant),
1750 unwrap<Constant>(RHSConstant)));
1751}
1752
1754 return wrap(ConstantExpr::getMul(unwrap<Constant>(LHSConstant),
1755 unwrap<Constant>(RHSConstant)));
1756}
1757
1759 LLVMValueRef RHSConstant) {
1760 return wrap(ConstantExpr::getNSWMul(unwrap<Constant>(LHSConstant),
1761 unwrap<Constant>(RHSConstant)));
1762}
1763
1765 LLVMValueRef RHSConstant) {
1766 return wrap(ConstantExpr::getNUWMul(unwrap<Constant>(LHSConstant),
1767 unwrap<Constant>(RHSConstant)));
1768}
1769
1771 return wrap(ConstantExpr::getXor(unwrap<Constant>(LHSConstant),
1772 unwrap<Constant>(RHSConstant)));
1773}
1774
1776 LLVMValueRef *ConstantIndices, unsigned NumIndices) {
1777 ArrayRef<Constant *> IdxList(unwrap<Constant>(ConstantIndices, NumIndices),
1778 NumIndices);
1779 Constant *Val = unwrap<Constant>(ConstantVal);
1780 return wrap(ConstantExpr::getGetElementPtr(unwrap(Ty), Val, IdxList));
1781}
1782
1784 LLVMValueRef *ConstantIndices,
1785 unsigned NumIndices) {
1786 ArrayRef<Constant *> IdxList(unwrap<Constant>(ConstantIndices, NumIndices),
1787 NumIndices);
1788 Constant *Val = unwrap<Constant>(ConstantVal);
1789 return wrap(ConstantExpr::getInBoundsGetElementPtr(unwrap(Ty), Val, IdxList));
1790}
1791
1793 return wrap(ConstantExpr::getTrunc(unwrap<Constant>(ConstantVal),
1794 unwrap(ToType)));
1795}
1796
1798 return wrap(ConstantExpr::getPtrToInt(unwrap<Constant>(ConstantVal),
1799 unwrap(ToType)));
1800}
1801
1803 return wrap(ConstantExpr::getIntToPtr(unwrap<Constant>(ConstantVal),
1804 unwrap(ToType)));
1805}
1806
1808 return wrap(ConstantExpr::getBitCast(unwrap<Constant>(ConstantVal),
1809 unwrap(ToType)));
1810}
1811
1813 LLVMTypeRef ToType) {
1814 return wrap(ConstantExpr::getAddrSpaceCast(unwrap<Constant>(ConstantVal),
1815 unwrap(ToType)));
1816}
1817
1819 LLVMTypeRef ToType) {
1820 return wrap(ConstantExpr::getTruncOrBitCast(unwrap<Constant>(ConstantVal),
1821 unwrap(ToType)));
1822}
1823
1825 LLVMTypeRef ToType) {
1826 return wrap(ConstantExpr::getPointerCast(unwrap<Constant>(ConstantVal),
1827 unwrap(ToType)));
1828}
1829
1831 LLVMValueRef IndexConstant) {
1832 return wrap(ConstantExpr::getExtractElement(unwrap<Constant>(VectorConstant),
1833 unwrap<Constant>(IndexConstant)));
1834}
1835
1837 LLVMValueRef ElementValueConstant,
1838 LLVMValueRef IndexConstant) {
1839 return wrap(ConstantExpr::getInsertElement(unwrap<Constant>(VectorConstant),
1840 unwrap<Constant>(ElementValueConstant),
1841 unwrap<Constant>(IndexConstant)));
1842}
1843
1845 LLVMValueRef VectorBConstant,
1846 LLVMValueRef MaskConstant) {
1847 SmallVector<int, 16> IntMask;
1848 ShuffleVectorInst::getShuffleMask(unwrap<Constant>(MaskConstant), IntMask);
1849 return wrap(ConstantExpr::getShuffleVector(unwrap<Constant>(VectorAConstant),
1850 unwrap<Constant>(VectorBConstant),
1851 IntMask));
1852}
1853
1855 const char *Constraints,
1856 LLVMBool HasSideEffects,
1857 LLVMBool IsAlignStack) {
1858 return wrap(InlineAsm::get(dyn_cast<FunctionType>(unwrap(Ty)), AsmString,
1859 Constraints, HasSideEffects, IsAlignStack));
1860}
1861
1863 return wrap(BlockAddress::get(unwrap<Function>(F), unwrap(BB)));
1864}
1865
1867 return wrap(unwrap<BlockAddress>(BlockAddr)->getFunction());
1868}
1869
1871 return wrap(unwrap<BlockAddress>(BlockAddr)->getBasicBlock());
1872}
1873
1874/*--.. Operations on global variables, functions, and aliases (globals) ....--*/
1875
1877 return wrap(unwrap<GlobalValue>(Global)->getParent());
1878}
1879
1881 return unwrap<GlobalValue>(Global)->isDeclaration();
1882}
1883
1885 switch (unwrap<GlobalValue>(Global)->getLinkage()) {
1887 return LLVMExternalLinkage;
1895 return LLVMWeakAnyLinkage;
1897 return LLVMWeakODRLinkage;
1899 return LLVMAppendingLinkage;
1901 return LLVMInternalLinkage;
1903 return LLVMPrivateLinkage;
1907 return LLVMCommonLinkage;
1908 }
1909
1910 llvm_unreachable("Invalid GlobalValue linkage!");
1911}
1912
1914 GlobalValue *GV = unwrap<GlobalValue>(Global);
1915
1916 switch (Linkage) {
1919 break;
1922 break;
1925 break;
1928 break;
1930 LLVM_DEBUG(
1931 errs() << "LLVMSetLinkage(): LLVMLinkOnceODRAutoHideLinkage is no "
1932 "longer supported.");
1933 break;
1934 case LLVMWeakAnyLinkage:
1936 break;
1937 case LLVMWeakODRLinkage:
1939 break;
1942 break;
1945 break;
1946 case LLVMPrivateLinkage:
1948 break;
1951 break;
1954 break;
1956 LLVM_DEBUG(
1957 errs()
1958 << "LLVMSetLinkage(): LLVMDLLImportLinkage is no longer supported.");
1959 break;
1961 LLVM_DEBUG(
1962 errs()
1963 << "LLVMSetLinkage(): LLVMDLLExportLinkage is no longer supported.");
1964 break;
1967 break;
1968 case LLVMGhostLinkage:
1969 LLVM_DEBUG(
1970 errs() << "LLVMSetLinkage(): LLVMGhostLinkage is no longer supported.");
1971 break;
1972 case LLVMCommonLinkage:
1974 break;
1975 }
1976}
1977
1979 // Using .data() is safe because of how GlobalObject::setSection is
1980 // implemented.
1981 return unwrap<GlobalValue>(Global)->getSection().data();
1982}
1983
1984void LLVMSetSection(LLVMValueRef Global, const char *Section) {
1985 unwrap<GlobalObject>(Global)->setSection(Section);
1986}
1987
1989 return static_cast<LLVMVisibility>(
1990 unwrap<GlobalValue>(Global)->getVisibility());
1991}
1992
1994 unwrap<GlobalValue>(Global)
1995 ->setVisibility(static_cast<GlobalValue::VisibilityTypes>(Viz));
1996}
1997
1999 return static_cast<LLVMDLLStorageClass>(
2000 unwrap<GlobalValue>(Global)->getDLLStorageClass());
2001}
2002
2004 unwrap<GlobalValue>(Global)->setDLLStorageClass(
2005 static_cast<GlobalValue::DLLStorageClassTypes>(Class));
2006}
2007
2009 switch (unwrap<GlobalValue>(Global)->getUnnamedAddr()) {
2010 case GlobalVariable::UnnamedAddr::None:
2011 return LLVMNoUnnamedAddr;
2012 case GlobalVariable::UnnamedAddr::Local:
2013 return LLVMLocalUnnamedAddr;
2014 case GlobalVariable::UnnamedAddr::Global:
2015 return LLVMGlobalUnnamedAddr;
2016 }
2017 llvm_unreachable("Unknown UnnamedAddr kind!");
2018}
2019
2021 GlobalValue *GV = unwrap<GlobalValue>(Global);
2022
2023 switch (UnnamedAddr) {
2024 case LLVMNoUnnamedAddr:
2025 return GV->setUnnamedAddr(GlobalVariable::UnnamedAddr::None);
2027 return GV->setUnnamedAddr(GlobalVariable::UnnamedAddr::Local);
2029 return GV->setUnnamedAddr(GlobalVariable::UnnamedAddr::Global);
2030 }
2031}
2032
2034 return unwrap<GlobalValue>(Global)->hasGlobalUnnamedAddr();
2035}
2036
2038 unwrap<GlobalValue>(Global)->setUnnamedAddr(
2039 HasUnnamedAddr ? GlobalValue::UnnamedAddr::Global
2040 : GlobalValue::UnnamedAddr::None);
2041}
2042
2044 return wrap(unwrap<GlobalValue>(Global)->getValueType());
2045}
2046
2047/*--.. Operations on global variables, load and store instructions .........--*/
2048
2050 Value *P = unwrap(V);
2051 if (GlobalObject *GV = dyn_cast<GlobalObject>(P))
2052 return GV->getAlign() ? GV->getAlign()->value() : 0;
2053 if (AllocaInst *AI = dyn_cast<AllocaInst>(P))
2054 return AI->getAlign().value();
2055 if (LoadInst *LI = dyn_cast<LoadInst>(P))
2056 return LI->getAlign().value();
2057 if (StoreInst *SI = dyn_cast<StoreInst>(P))
2058 return SI->getAlign().value();
2059 if (AtomicRMWInst *RMWI = dyn_cast<AtomicRMWInst>(P))
2060 return RMWI->getAlign().value();
2061 if (AtomicCmpXchgInst *CXI = dyn_cast<AtomicCmpXchgInst>(P))
2062 return CXI->getAlign().value();
2063
2065 "only GlobalValue, AllocaInst, LoadInst, StoreInst, AtomicRMWInst, "
2066 "and AtomicCmpXchgInst have alignment");
2067}
2068
2069void LLVMSetAlignment(LLVMValueRef V, unsigned Bytes) {
2070 Value *P = unwrap(V);
2071 if (GlobalObject *GV = dyn_cast<GlobalObject>(P))
2072 GV->setAlignment(MaybeAlign(Bytes));
2073 else if (AllocaInst *AI = dyn_cast<AllocaInst>(P))
2074 AI->setAlignment(Align(Bytes));
2075 else if (LoadInst *LI = dyn_cast<LoadInst>(P))
2076 LI->setAlignment(Align(Bytes));
2077 else if (StoreInst *SI = dyn_cast<StoreInst>(P))
2078 SI->setAlignment(Align(Bytes));
2079 else if (AtomicRMWInst *RMWI = dyn_cast<AtomicRMWInst>(P))
2080 RMWI->setAlignment(Align(Bytes));
2081 else if (AtomicCmpXchgInst *CXI = dyn_cast<AtomicCmpXchgInst>(P))
2082 CXI->setAlignment(Align(Bytes));
2083 else
2085 "only GlobalValue, AllocaInst, LoadInst, StoreInst, AtomicRMWInst, and "
2086 "and AtomicCmpXchgInst have alignment");
2087}
2088
2090 size_t *NumEntries) {
2091 return llvm_getMetadata(NumEntries, [&Value](MetadataEntries &Entries) {
2092 Entries.clear();
2093 if (Instruction *Instr = dyn_cast<Instruction>(unwrap(Value))) {
2094 Instr->getAllMetadata(Entries);
2095 } else {
2096 unwrap<GlobalObject>(Value)->getAllMetadata(Entries);
2097 }
2098 });
2099}
2100
2102 unsigned Index) {
2104 static_cast<LLVMOpaqueValueMetadataEntry>(Entries[Index]);
2105 return MVE.Kind;
2106}
2107
2110 unsigned Index) {
2112 static_cast<LLVMOpaqueValueMetadataEntry>(Entries[Index]);
2113 return MVE.Metadata;
2114}
2115
2117 free(Entries);
2118}
2119
2121 LLVMMetadataRef MD) {
2122 unwrap<GlobalObject>(Global)->setMetadata(Kind, unwrap<MDNode>(MD));
2123}
2124
2126 unwrap<GlobalObject>(Global)->eraseMetadata(Kind);
2127}
2128
2130 unwrap<GlobalObject>(Global)->clearMetadata();
2131}
2132
2133/*--.. Operations on global variables ......................................--*/
2134
2136 return wrap(new GlobalVariable(*unwrap(M), unwrap(Ty), false,
2138}
2139
2141 const char *Name,
2142 unsigned AddressSpace) {
2143 return wrap(new GlobalVariable(*unwrap(M), unwrap(Ty), false,
2145 nullptr, GlobalVariable::NotThreadLocal,
2146 AddressSpace));
2147}
2148
2150 return wrap(unwrap(M)->getNamedGlobal(Name));
2151}
2152
2154 Module *Mod = unwrap(M);
2156 if (I == Mod->global_end())
2157 return nullptr;
2158 return wrap(&*I);
2159}
2160
2162 Module *Mod = unwrap(M);
2164 if (I == Mod->global_begin())
2165 return nullptr;
2166 return wrap(&*--I);
2167}
2168
2170 GlobalVariable *GV = unwrap<GlobalVariable>(GlobalVar);
2172 if (++I == GV->getParent()->global_end())
2173 return nullptr;
2174 return wrap(&*I);
2175}
2176
2178 GlobalVariable *GV = unwrap<GlobalVariable>(GlobalVar);
2180 if (I == GV->getParent()->global_begin())
2181 return nullptr;
2182 return wrap(&*--I);
2183}
2184
2186 unwrap<GlobalVariable>(GlobalVar)->eraseFromParent();
2187}
2188
2190 GlobalVariable* GV = unwrap<GlobalVariable>(GlobalVar);
2191 if ( !GV->hasInitializer() )
2192 return nullptr;
2193 return wrap(GV->getInitializer());
2194}
2195
2196void LLVMSetInitializer(LLVMValueRef GlobalVar, LLVMValueRef ConstantVal) {
2197 unwrap<GlobalVariable>(GlobalVar)
2198 ->setInitializer(unwrap<Constant>(ConstantVal));
2199}
2200
2202 return unwrap<GlobalVariable>(GlobalVar)->isThreadLocal();
2203}
2204
2205void LLVMSetThreadLocal(LLVMValueRef GlobalVar, LLVMBool IsThreadLocal) {
2206 unwrap<GlobalVariable>(GlobalVar)->setThreadLocal(IsThreadLocal != 0);
2207}
2208
2210 return unwrap<GlobalVariable>(GlobalVar)->isConstant();
2211}
2212
2213void LLVMSetGlobalConstant(LLVMValueRef GlobalVar, LLVMBool IsConstant) {
2214 unwrap<GlobalVariable>(GlobalVar)->setConstant(IsConstant != 0);
2215}
2216
2218 switch (unwrap<GlobalVariable>(GlobalVar)->getThreadLocalMode()) {
2219 case GlobalVariable::NotThreadLocal:
2220 return LLVMNotThreadLocal;
2221 case GlobalVariable::GeneralDynamicTLSModel:
2223 case GlobalVariable::LocalDynamicTLSModel:
2225 case GlobalVariable::InitialExecTLSModel:
2227 case GlobalVariable::LocalExecTLSModel:
2228 return LLVMLocalExecTLSModel;
2229 }
2230
2231 llvm_unreachable("Invalid GlobalVariable thread local mode");
2232}
2233
2235 GlobalVariable *GV = unwrap<GlobalVariable>(GlobalVar);
2236
2237 switch (Mode) {
2238 case LLVMNotThreadLocal:
2239 GV->setThreadLocalMode(GlobalVariable::NotThreadLocal);
2240 break;
2242 GV->setThreadLocalMode(GlobalVariable::GeneralDynamicTLSModel);
2243 break;
2245 GV->setThreadLocalMode(GlobalVariable::LocalDynamicTLSModel);
2246 break;
2248 GV->setThreadLocalMode(GlobalVariable::InitialExecTLSModel);
2249 break;
2251 GV->setThreadLocalMode(GlobalVariable::LocalExecTLSModel);
2252 break;
2253 }
2254}
2255
2257 return unwrap<GlobalVariable>(GlobalVar)->isExternallyInitialized();
2258}
2259
2261 unwrap<GlobalVariable>(GlobalVar)->setExternallyInitialized(IsExtInit);
2262}
2263
2264/*--.. Operations on aliases ......................................--*/
2265
2267 unsigned AddrSpace, LLVMValueRef Aliasee,
2268 const char *Name) {
2269 return wrap(GlobalAlias::create(unwrap(ValueTy), AddrSpace,
2271 unwrap<Constant>(Aliasee), unwrap(M)));
2272}
2273
2275 const char *Name, size_t NameLen) {
2276 return wrap(unwrap(M)->getNamedAlias(StringRef(Name, NameLen)));
2277}
2278
2280 Module *Mod = unwrap(M);
2282 if (I == Mod->alias_end())
2283 return nullptr;
2284 return wrap(&*I);
2285}
2286
2288 Module *Mod = unwrap(M);
2290 if (I == Mod->alias_begin())
2291 return nullptr;
2292 return wrap(&*--I);
2293}
2294
2296 GlobalAlias *Alias = unwrap<GlobalAlias>(GA);
2298 if (++I == Alias->getParent()->alias_end())
2299 return nullptr;
2300 return wrap(&*I);
2301}
2302
2304 GlobalAlias *Alias = unwrap<GlobalAlias>(GA);
2306 if (I == Alias->getParent()->alias_begin())
2307 return nullptr;
2308 return wrap(&*--I);
2309}
2310
2312 return wrap(unwrap<GlobalAlias>(Alias)->getAliasee());
2313}
2314
2316 unwrap<GlobalAlias>(Alias)->setAliasee(unwrap<Constant>(Aliasee));
2317}
2318
2319/*--.. Operations on functions .............................................--*/
2320
2322 LLVMTypeRef FunctionTy) {
2323 return wrap(Function::Create(unwrap<FunctionType>(FunctionTy),
2325}
2326
2328 return wrap(unwrap(M)->getFunction(Name));
2329}
2330
2332 Module *Mod = unwrap(M);
2334 if (I == Mod->end())
2335 return nullptr;
2336 return wrap(&*I);
2337}
2338
2340 Module *Mod = unwrap(M);
2342 if (I == Mod->begin())
2343 return nullptr;
2344 return wrap(&*--I);
2345}
2346
2348 Function *Func = unwrap<Function>(Fn);
2349 Module::iterator I(Func);
2350 if (++I == Func->getParent()->end())
2351 return nullptr;
2352 return wrap(&*I);
2353}
2354
2356 Function *Func = unwrap<Function>(Fn);
2357 Module::iterator I(Func);
2358 if (I == Func->getParent()->begin())
2359 return nullptr;
2360 return wrap(&*--I);
2361}
2362
2364 unwrap<Function>(Fn)->eraseFromParent();
2365}
2366
2368 return unwrap<Function>(Fn)->hasPersonalityFn();
2369}
2370
2372 return wrap(unwrap<Function>(Fn)->getPersonalityFn());
2373}
2374
2376 unwrap<Function>(Fn)->setPersonalityFn(unwrap<Constant>(PersonalityFn));
2377}
2378
2380 if (Function *F = dyn_cast<Function>(unwrap(Fn)))
2381 return F->getIntrinsicID();
2382 return 0;
2383}
2384
2386 assert(ID < llvm::Intrinsic::num_intrinsics && "Intrinsic ID out of range");
2387 return llvm::Intrinsic::ID(ID);
2388}
2389
2391 unsigned ID,
2392 LLVMTypeRef *ParamTypes,
2393 size_t ParamCount) {
2394 ArrayRef<Type*> Tys(unwrap(ParamTypes), ParamCount);
2395 auto IID = llvm_map_to_intrinsic_id(ID);
2396 return wrap(llvm::Intrinsic::getDeclaration(unwrap(Mod), IID, Tys));
2397}
2398
2399const char *LLVMIntrinsicGetName(unsigned ID, size_t *NameLength) {
2400 auto IID = llvm_map_to_intrinsic_id(ID);
2401 auto Str = llvm::Intrinsic::getName(IID);
2402 *NameLength = Str.size();
2403 return Str.data();
2404}
2405
2407 LLVMTypeRef *ParamTypes, size_t ParamCount) {
2408 auto IID = llvm_map_to_intrinsic_id(ID);
2409 ArrayRef<Type*> Tys(unwrap(ParamTypes), ParamCount);
2410 return wrap(llvm::Intrinsic::getType(*unwrap(Ctx), IID, Tys));
2411}
2412
2414 LLVMTypeRef *ParamTypes,
2415 size_t ParamCount,
2416 size_t *NameLength) {
2417 auto IID = llvm_map_to_intrinsic_id(ID);
2418 ArrayRef<Type*> Tys(unwrap(ParamTypes), ParamCount);
2419 auto Str = llvm::Intrinsic::getNameNoUnnamedTypes(IID, Tys);
2420 *NameLength = Str.length();
2421 return strdup(Str.c_str());
2422}
2423
2425 LLVMTypeRef *ParamTypes,
2426 size_t ParamCount,
2427 size_t *NameLength) {
2428 auto IID = llvm_map_to_intrinsic_id(ID);
2429 ArrayRef<Type *> Tys(unwrap(ParamTypes), ParamCount);
2430 auto Str = llvm::Intrinsic::getName(IID, Tys, unwrap(Mod));
2431 *NameLength = Str.length();
2432 return strdup(Str.c_str());
2433}
2434
2435unsigned LLVMLookupIntrinsicID(const char *Name, size_t NameLen) {
2436 return Function::lookupIntrinsicID({Name, NameLen});
2437}
2438
2440 auto IID = llvm_map_to_intrinsic_id(ID);
2442}
2443
2445 return unwrap<Function>(Fn)->getCallingConv();
2446}
2447
2449 return unwrap<Function>(Fn)->setCallingConv(
2450 static_cast<CallingConv::ID>(CC));
2451}
2452
2453const char *LLVMGetGC(LLVMValueRef Fn) {
2454 Function *F = unwrap<Function>(Fn);
2455 return F->hasGC()? F->getGC().c_str() : nullptr;
2456}
2457
2458void LLVMSetGC(LLVMValueRef Fn, const char *GC) {
2459 Function *F = unwrap<Function>(Fn);
2460 if (GC)
2461 F->setGC(GC);
2462 else
2463 F->clearGC();
2464}
2465
2467 Function *F = unwrap<Function>(Fn);
2468 return wrap(F->getPrefixData());
2469}
2470
2472 Function *F = unwrap<Function>(Fn);
2473 return F->hasPrefixData();
2474}
2475
2477 Function *F = unwrap<Function>(Fn);
2478 Constant *prefix = unwrap<Constant>(prefixData);
2479 F->setPrefixData(prefix);
2480}
2481
2483 Function *F = unwrap<Function>(Fn);
2484 return wrap(F->getPrologueData());
2485}
2486
2488 Function *F = unwrap<Function>(Fn);
2489 return F->hasPrologueData();
2490}
2491
2493 Function *F = unwrap<Function>(Fn);
2494 Constant *prologue = unwrap<Constant>(prologueData);
2495 F->setPrologueData(prologue);
2496}
2497
2500 unwrap<Function>(F)->addAttributeAtIndex(Idx, unwrap(A));
2501}
2502
2504 auto AS = unwrap<Function>(F)->getAttributes().getAttributes(Idx);
2505 return AS.getNumAttributes();
2506}
2507
2509 LLVMAttributeRef *Attrs) {
2510 auto AS = unwrap<Function>(F)->getAttributes().getAttributes(Idx);
2511 for (auto A : AS)
2512 *Attrs++ = wrap(A);
2513}
2514
2517 unsigned KindID) {
2518 return wrap(unwrap<Function>(F)->getAttributeAtIndex(
2519 Idx, (Attribute::AttrKind)KindID));
2520}
2521
2524 const char *K, unsigned KLen) {
2525 return wrap(
2526 unwrap<Function>(F)->getAttributeAtIndex(Idx, StringRef(K, KLen)));
2527}
2528
2530 unsigned KindID) {
2531 unwrap<Function>(F)->removeAttributeAtIndex(Idx, (Attribute::AttrKind)KindID);
2532}
2533
2535 const char *K, unsigned KLen) {
2536 unwrap<Function>(F)->removeAttributeAtIndex(Idx, StringRef(K, KLen));
2537}
2538
2540 const char *V) {
2541 Function *Func = unwrap<Function>(Fn);
2542 Attribute Attr = Attribute::get(Func->getContext(), A, V);
2543 Func->addFnAttr(Attr);
2544}
2545
2546/*--.. Operations on parameters ............................................--*/
2547
2549 // This function is strictly redundant to
2550 // LLVMCountParamTypes(LLVMGlobalGetValueType(FnRef))
2551 return unwrap<Function>(FnRef)->arg_size();
2552}
2553
2554void LLVMGetParams(LLVMValueRef FnRef, LLVMValueRef *ParamRefs) {
2555 Function *Fn = unwrap<Function>(FnRef);
2556 for (Argument &A : Fn->args())
2557 *ParamRefs++ = wrap(&A);
2558}
2559
2561 Function *Fn = unwrap<Function>(FnRef);
2562 return wrap(&Fn->arg_begin()[index]);
2563}
2564
2566 return wrap(unwrap<Argument>(V)->getParent());
2567}
2568
2570 Function *Func = unwrap<Function>(Fn);
2571 Function::arg_iterator I = Func->arg_begin();
2572 if (I == Func->arg_end())
2573 return nullptr;
2574 return wrap(&*I);
2575}
2576
2578 Function *Func = unwrap<Function>(Fn);
2579 Function::arg_iterator I = Func->arg_end();
2580 if (I == Func->arg_begin())
2581 return nullptr;
2582 return wrap(&*--I);
2583}
2584
2586 Argument *A = unwrap<Argument>(Arg);
2587 Function *Fn = A->getParent();
2588 if (A->getArgNo() + 1 >= Fn->arg_size())
2589 return nullptr;
2590 return wrap(&Fn->arg_begin()[A->getArgNo() + 1]);
2591}
2592
2594 Argument *A = unwrap<Argument>(Arg);
2595 if (A->getArgNo() == 0)
2596 return nullptr;
2597 return wrap(&A->getParent()->arg_begin()[A->getArgNo() - 1]);
2598}
2599
2600void LLVMSetParamAlignment(LLVMValueRef Arg, unsigned align) {
2601 Argument *A = unwrap<Argument>(Arg);
2602 A->addAttr(Attribute::getWithAlignment(A->getContext(), Align(align)));
2603}
2604
2605/*--.. Operations on ifuncs ................................................--*/
2606
2608 const char *Name, size_t NameLen,
2609 LLVMTypeRef Ty, unsigned AddrSpace,
2611 return wrap(GlobalIFunc::create(unwrap(Ty), AddrSpace,
2613 StringRef(Name, NameLen),
2614 unwrap<Constant>(Resolver), unwrap(M)));
2615}
2616
2618 const char *Name, size_t NameLen) {
2619 return wrap(unwrap(M)->getNamedIFunc(StringRef(Name, NameLen)));
2620}
2621
2623 Module *Mod = unwrap(M);
2625 if (I == Mod->ifunc_end())
2626 return nullptr;
2627 return wrap(&*I);
2628}
2629
2631 Module *Mod = unwrap(M);
2633 if (I == Mod->ifunc_begin())
2634 return nullptr;
2635 return wrap(&*--I);
2636}
2637
2639 GlobalIFunc *GIF = unwrap<GlobalIFunc>(IFunc);
2641 if (++I == GIF->getParent()->ifunc_end())
2642 return nullptr;
2643 return wrap(&*I);
2644}
2645
2647 GlobalIFunc *GIF = unwrap<GlobalIFunc>(IFunc);
2649 if (I == GIF->getParent()->ifunc_begin())
2650 return nullptr;
2651 return wrap(&*--I);
2652}
2653
2655 return wrap(unwrap<GlobalIFunc>(IFunc)->getResolver());
2656}
2657
2659 unwrap<GlobalIFunc>(IFunc)->setResolver(unwrap<Constant>(Resolver));
2660}
2661
2663 unwrap<GlobalIFunc>(IFunc)->eraseFromParent();
2664}
2665
2667 unwrap<GlobalIFunc>(IFunc)->removeFromParent();
2668}
2669
2670/*--.. Operations on operand bundles........................................--*/
2671
2673 LLVMValueRef *Args,
2674 unsigned NumArgs) {
2675 return wrap(new OperandBundleDef(std::string(Tag, TagLen),
2676 ArrayRef(unwrap(Args), NumArgs)));
2677}
2678
2680 delete unwrap(Bundle);
2681}
2682
2683const char *LLVMGetOperandBundleTag(LLVMOperandBundleRef Bundle, size_t *Len) {
2684 StringRef Str = unwrap(Bundle)->getTag();
2685 *Len = Str.size();
2686 return Str.data();
2687}
2688
2690 return unwrap(Bundle)->inputs().size();
2691}
2692
2694 unsigned Index) {
2695 return wrap(unwrap(Bundle)->inputs()[Index]);
2696}
2697
2698/*--.. Operations on basic blocks ..........................................--*/
2699
2701 return wrap(static_cast<Value*>(unwrap(BB)));
2702}
2703
2705 return isa<BasicBlock>(unwrap(Val));
2706}
2707
2709 return wrap(unwrap<BasicBlock>(Val));
2710}
2711
2713 return unwrap(BB)->getName().data();
2714}
2715
2717 return wrap(unwrap(BB)->getParent());
2718}
2719
2721 return wrap(unwrap(BB)->getTerminator());
2722}
2723
2725 return unwrap<Function>(FnRef)->size();
2726}
2727
2729 Function *Fn = unwrap<Function>(FnRef);
2730 for (BasicBlock &BB : *Fn)
2731 *BasicBlocksRefs++ = wrap(&BB);
2732}
2733
2735 return wrap(&unwrap<Function>(Fn)->getEntryBlock());
2736}
2737
2739 Function *Func = unwrap<Function>(Fn);
2740 Function::iterator I = Func->begin();
2741 if (I == Func->end())
2742 return nullptr;
2743 return wrap(&*I);
2744}
2745
2747 Function *Func = unwrap<Function>(Fn);
2748 Function::iterator I = Func->end();
2749 if (I == Func->begin())
2750 return nullptr;
2751 return wrap(&*--I);
2752}
2753
2755 BasicBlock *Block = unwrap(BB);
2757 if (++I == Block->getParent()->end())
2758 return nullptr;
2759 return wrap(&*I);
2760}
2761
2763 BasicBlock *Block = unwrap(BB);
2765 if (I == Block->getParent()->begin())
2766 return nullptr;
2767 return wrap(&*--I);
2768}
2769
2771 const char *Name) {
2773}
2774
2776 LLVMBasicBlockRef BB) {
2777 BasicBlock *ToInsert = unwrap(BB);
2778 BasicBlock *CurBB = unwrap(Builder)->GetInsertBlock();
2779 assert(CurBB && "current insertion point is invalid!");
2780 CurBB->getParent()->insert(std::next(CurBB->getIterator()), ToInsert);
2781}
2782
2784 LLVMBasicBlockRef BB) {
2785 unwrap<Function>(Fn)->insert(unwrap<Function>(Fn)->end(), unwrap(BB));
2786}
2787
2789 LLVMValueRef FnRef,
2790 const char *Name) {
2791 return wrap(BasicBlock::Create(*unwrap(C), Name, unwrap<Function>(FnRef)));
2792}
2793
2796}
2797
2799 LLVMBasicBlockRef BBRef,
2800 const char *Name) {
2801 BasicBlock *BB = unwrap(BBRef);
2802 return wrap(BasicBlock::Create(*unwrap(C), Name, BB->getParent(), BB));
2803}
2804
2806 const char *Name) {
2808}
2809
2811 unwrap(BBRef)->eraseFromParent();
2812}
2813
2815 unwrap(BBRef)->removeFromParent();
2816}
2817
2819 unwrap(BB)->moveBefore(unwrap(MovePos));
2820}
2821
2823 unwrap(BB)->moveAfter(unwrap(MovePos));
2824}
2825
2826/*--.. Operations on instructions ..........................................--*/
2827
2829 return wrap(unwrap<Instruction>(Inst)->getParent());
2830}
2831
2833 BasicBlock *Block = unwrap(BB);
2834 BasicBlock::iterator I = Block->begin();
2835 if (I == Block->end())
2836 return nullptr;
2837 return wrap(&*I);
2838}
2839
2841 BasicBlock *Block = unwrap(BB);
2842 BasicBlock::iterator I = Block->end();
2843 if (I == Block->begin())
2844 return nullptr;
2845 return wrap(&*--I);
2846}
2847
2849 Instruction *Instr = unwrap<Instruction>(Inst);
2850 BasicBlock::iterator I(Instr);
2851 if (++I == Instr->getParent()->end())
2852 return nullptr;
2853 return wrap(&*I);
2854}
2855
2857 Instruction *Instr = unwrap<Instruction>(Inst);
2858 BasicBlock::iterator I(Instr);
2859 if (I == Instr->getParent()->begin())
2860 return nullptr;
2861 return wrap(&*--I);
2862}
2863
2865 unwrap<Instruction>(Inst)->removeFromParent();
2866}
2867
2869 unwrap<Instruction>(Inst)->eraseFromParent();
2870}
2871
2873 unwrap<Instruction>(Inst)->deleteValue();
2874}
2875
2877 if (ICmpInst *I = dyn_cast<ICmpInst>(unwrap(Inst)))
2878 return (LLVMIntPredicate)I->getPredicate();
2879 return (LLVMIntPredicate)0;
2880}
2881
2883 if (FCmpInst *I = dyn_cast<FCmpInst>(unwrap(Inst)))
2884 return (LLVMRealPredicate)I->getPredicate();
2885 return (LLVMRealPredicate)0;
2886}
2887
2889 if (Instruction *C = dyn_cast<Instruction>(unwrap(Inst)))
2890 return map_to_llvmopcode(C->getOpcode());
2891 return (LLVMOpcode)0;
2892}
2893
2895 if (Instruction *C = dyn_cast<Instruction>(unwrap(Inst)))
2896 return wrap(C->clone());
2897 return nullptr;
2898}
2899
2901 Instruction *I = dyn_cast<Instruction>(unwrap(Inst));
2902 return (I && I->isTerminator()) ? wrap(I) : nullptr;
2903}
2904
2906 if (FuncletPadInst *FPI = dyn_cast<FuncletPadInst>(unwrap(Instr))) {
2907 return FPI->arg_size();
2908 }
2909 return unwrap<CallBase>(Instr)->arg_size();
2910}
2911
2912/*--.. Call and invoke instructions ........................................--*/
2913
2915 return unwrap<CallBase>(Instr)->getCallingConv();
2916}
2917
2919 return unwrap<CallBase>(Instr)->setCallingConv(
2920 static_cast<CallingConv::ID>(CC));
2921}
2922
2924 unsigned align) {
2925 auto *Call = unwrap<CallBase>(Instr);
2926 Attribute AlignAttr =
2927 Attribute::getWithAlignment(Call->getContext(), Align(align));
2928 Call->addAttributeAtIndex(Idx, AlignAttr);
2929}
2930
2933 unwrap<CallBase>(C)->addAttributeAtIndex(Idx, unwrap(A));
2934}
2935
2938 auto *Call = unwrap<CallBase>(C);
2939 auto AS = Call->getAttributes().getAttributes(Idx);
2940 return AS.getNumAttributes();
2941}
2942
2944 LLVMAttributeRef *Attrs) {
2945 auto *Call = unwrap<CallBase>(C);
2946 auto AS = Call->getAttributes().getAttributes(Idx);
2947 for (auto A : AS)
2948 *Attrs++ = wrap(A);
2949}
2950
2953 unsigned KindID) {
2954 return wrap(unwrap<CallBase>(C)->getAttributeAtIndex(
2955 Idx, (Attribute::AttrKind)KindID));
2956}
2957
2960 const char *K, unsigned KLen) {
2961 return wrap(
2962 unwrap<CallBase>(C)->getAttributeAtIndex(Idx, StringRef(K, KLen)));
2963}
2964
2966 unsigned KindID) {
2967 unwrap<CallBase>(C)->removeAttributeAtIndex(Idx, (Attribute::AttrKind)KindID);
2968}
2969
2971 const char *K, unsigned KLen) {
2972 unwrap<CallBase>(C)->removeAttributeAtIndex(Idx, StringRef(K, KLen));
2973}
2974
2976 return wrap(unwrap<CallBase>(Instr)->getCalledOperand());
2977}
2978
2980 return wrap(unwrap<CallBase>(Instr)->getFunctionType());
2981}
2982
2984 return unwrap<CallBase>(C)->getNumOperandBundles();
2985}
2986
2988 unsigned Index) {
2989 return wrap(
2990 new OperandBundleDef(unwrap<CallBase>(C)->getOperandBundleAt(Index)));
2991}
2992
2993/*--.. Operations on call instructions (only) ..............................--*/
2994
2996 return unwrap<CallInst>(Call)->isTailCall();
2997}
2998
2999void LLVMSetTailCall(LLVMValueRef Call, LLVMBool isTailCall) {
3000 unwrap<CallInst>(Call)->setTailCall(isTailCall);
3001}
3002
3004 return (LLVMTailCallKind)unwrap<CallInst>(Call)->getTailCallKind();
3005}
3006
3008 unwrap<CallInst>(Call)->setTailCallKind((CallInst::TailCallKind)kind);
3009}
3010
3011/*--.. Operations on invoke instructions (only) ............................--*/
3012
3014 return wrap(unwrap<InvokeInst>(Invoke)->getNormalDest());
3015}
3016
3018 if (CleanupReturnInst *CRI = dyn_cast<CleanupReturnInst>(unwrap(Invoke))) {
3019 return wrap(CRI->getUnwindDest());
3020 } else if (CatchSwitchInst *CSI = dyn_cast<CatchSwitchInst>(unwrap(Invoke))) {
3021 return wrap(CSI->getUnwindDest());
3022 }
3023 return wrap(unwrap<InvokeInst>(Invoke)->getUnwindDest());
3024}
3025
3027 unwrap<InvokeInst>(Invoke)->setNormalDest(unwrap(B));
3028}
3029
3031 if (CleanupReturnInst *CRI = dyn_cast<CleanupReturnInst>(unwrap(Invoke))) {
3032 return CRI->setUnwindDest(unwrap(B));
3033 } else if (CatchSwitchInst *CSI = dyn_cast<CatchSwitchInst>(unwrap(Invoke))) {
3034 return CSI->setUnwindDest(unwrap(B));
3035 }
3036 unwrap<InvokeInst>(Invoke)->setUnwindDest(unwrap(B));
3037}
3038
3040 return wrap(unwrap<CallBrInst>(CallBr)->getDefaultDest());
3041}
3042
3044 return unwrap<CallBrInst>(CallBr)->getNumIndirectDests();
3045}
3046
3048 return wrap(unwrap<CallBrInst>(CallBr)->getIndirectDest(Idx));
3049}
3050
3051/*--.. Operations on terminators ...........................................--*/
3052
3054 return unwrap<Instruction>(Term)->getNumSuccessors();
3055}
3056
3058 return wrap(unwrap<Instruction>(Term)->getSuccessor(i));
3059}
3060
3062 return unwrap<Instruction>(Term)->setSuccessor(i, unwrap(block));
3063}
3064
3065/*--.. Operations on branch instructions (only) ............................--*/
3066
3068 return unwrap<BranchInst>(Branch)->isConditional();
3069}
3070
3072 return wrap(unwrap<BranchInst>(Branch)->getCondition());
3073}
3074
3076 return unwrap<BranchInst>(Branch)->setCondition(unwrap(Cond));
3077}
3078
3079/*--.. Operations on switch instructions (only) ............................--*/
3080
3082 return wrap(unwrap<SwitchInst>(Switch)->getDefaultDest());
3083}
3084
3085/*--.. Operations on alloca instructions (only) ............................--*/
3086
3088 return wrap(unwrap<AllocaInst>(Alloca)->getAllocatedType());
3089}
3090
3091/*--.. Operations on gep instructions (only) ...............................--*/
3092
3094 return unwrap<GEPOperator>(GEP)->isInBounds();
3095}
3096
3098 return unwrap<GetElementPtrInst>(GEP)->setIsInBounds(InBounds);
3099}
3100
3102 return wrap(unwrap<GEPOperator>(GEP)->getSourceElementType());
3103}
3104
3105/*--.. Operations on phi nodes .............................................--*/
3106
3107void LLVMAddIncoming(LLVMValueRef PhiNode, LLVMValueRef *IncomingValues,
3108 LLVMBasicBlockRef *IncomingBlocks, unsigned Count) {
3109 PHINode *PhiVal = unwrap<PHINode>(PhiNode);
3110 for (unsigned I = 0; I != Count; ++I)
3111 PhiVal->addIncoming(unwrap(IncomingValues[I]), unwrap(IncomingBlocks[I]));
3112}
3113
3115 return unwrap<PHINode>(PhiNode)->getNumIncomingValues();
3116}
3117
3119 return wrap(unwrap<PHINode>(PhiNode)->getIncomingValue(Index));
3120}
3121
3123 return wrap(unwrap<PHINode>(PhiNode)->getIncomingBlock(Index));
3124}
3125
3126/*--.. Operations on extractvalue and insertvalue nodes ....................--*/
3127
3129 auto *I = unwrap(Inst);
3130 if (auto *GEP = dyn_cast<GEPOperator>(I))
3131 return GEP->getNumIndices();
3132 if (auto *EV = dyn_cast<ExtractValueInst>(I))
3133 return EV->getNumIndices();
3134 if (auto *IV = dyn_cast<InsertValueInst>(I))
3135 return IV->getNumIndices();
3137 "LLVMGetNumIndices applies only to extractvalue and insertvalue!");
3138}
3139
3140const unsigned *LLVMGetIndices(LLVMValueRef Inst) {
3141 auto *I = unwrap(Inst);
3142 if (auto *EV = dyn_cast<ExtractValueInst>(I))
3143 return EV->getIndices().data();
3144 if (auto *IV = dyn_cast<InsertValueInst>(I))
3145 return IV->getIndices().data();
3147 "LLVMGetIndices applies only to extractvalue and insertvalue!");
3148}
3149
3150
3151/*===-- Instruction builders ----------------------------------------------===*/
3152
3154 return wrap(new IRBuilder<>(*unwrap(C)));
3155}
3156
3159}
3160
3162 Instruction *Instr, bool BeforeDbgRecords) {
3163 BasicBlock::iterator I = Instr ? Instr->getIterator() : Block->end();
3164 I.setHeadBit(BeforeDbgRecords);
3165 Builder->SetInsertPoint(Block, I);
3166}
3167
3169 LLVMValueRef Instr) {
3170 return LLVMPositionBuilderImpl(unwrap(Builder), unwrap(Block),
3171 unwrap<Instruction>(Instr), false);
3172}
3173
3176 LLVMValueRef Instr) {
3177 return LLVMPositionBuilderImpl(unwrap(Builder), unwrap(Block),
3178 unwrap<Instruction>(Instr), true);
3179}
3180
3182 Instruction *I = unwrap<Instruction>(Instr);
3183 return LLVMPositionBuilderImpl(unwrap(Builder), I->getParent(), I, false);
3184}
3185
3187 LLVMValueRef Instr) {
3188 Instruction *I = unwrap<Instruction>(Instr);
3189 return LLVMPositionBuilderImpl(unwrap(Builder), I->getParent(), I, true);
3190}
3191
3193 BasicBlock *BB = unwrap(Block);
3194 unwrap(Builder)->SetInsertPoint(BB);
3195}
3196
3198 return wrap(unwrap(Builder)->GetInsertBlock());
3199}
3200
3202 unwrap(Builder)->ClearInsertionPoint();
3203}
3204
3206 unwrap(Builder)->Insert(unwrap<Instruction>(Instr));
3207}
3208
3210 const char *Name) {
3211 unwrap(Builder)->Insert(unwrap<Instruction>(Instr), Name);
3212}
3213
3215 delete unwrap(Builder);
3216}
3217
3218/*--.. Metadata builders ...................................................--*/
3219
3221 return wrap(unwrap(Builder)->getCurrentDebugLocation().getAsMDNode());
3222}
3223
3225 if (Loc)
3226 unwrap(Builder)->SetCurrentDebugLocation(DebugLoc(unwrap<MDNode>(Loc)));
3227 else
3228 unwrap(Builder)->SetCurrentDebugLocation(DebugLoc());
3229}
3230
3232 MDNode *Loc =
3233 L ? cast<MDNode>(unwrap<MetadataAsValue>(L)->getMetadata()) : nullptr;
3234 unwrap(Builder)->SetCurrentDebugLocation(DebugLoc(Loc));
3235}
3236
3238 LLVMContext &Context = unwrap(Builder)->getContext();
3240 Context, unwrap(Builder)->getCurrentDebugLocation().getAsMDNode()));
3241}
3242
3244 unwrap(Builder)->SetInstDebugLocation(unwrap<Instruction>(Inst));
3245}
3246
3248 unwrap(Builder)->AddMetadataToInst(unwrap<Instruction>(Inst));
3249}
3250
3252 LLVMMetadataRef FPMathTag) {
3253
3254 unwrap(Builder)->setDefaultFPMathTag(FPMathTag
3255 ? unwrap<MDNode>(FPMathTag)
3256 : nullptr);
3257}
3258
3260 return wrap(unwrap(Builder)->getDefaultFPMathTag());
3261}
3262
3263/*--.. Instruction builders ................................................--*/
3264
3266 return wrap(unwrap(B)->CreateRetVoid());
3267}
3268
3270 return wrap(unwrap(B)->CreateRet(unwrap(V)));
3271}
3272
3274 unsigned N) {
3275 return wrap(unwrap(B)->CreateAggregateRet(unwrap(RetVals), N));
3276}
3277
3279 return wrap(unwrap(B)->CreateBr(unwrap(Dest)));
3280}
3281
3284 return wrap(unwrap(B)->CreateCondBr(unwrap(If), unwrap(Then), unwrap(Else)));
3285}
3286
3288 LLVMBasicBlockRef Else, unsigned NumCases) {
3289 return wrap(unwrap(B)->CreateSwitch(unwrap(V), unwrap(Else), NumCases));
3290}
3291
3293 unsigned NumDests) {
3294 return wrap(unwrap(B)->CreateIndirectBr(unwrap(Addr), NumDests));
3295}
3296
3298 LLVMBasicBlockRef DefaultDest,
3299 LLVMBasicBlockRef *IndirectDests,
3300 unsigned NumIndirectDests, LLVMValueRef *Args,
3301 unsigned NumArgs, LLVMOperandBundleRef *Bundles,
3302 unsigned NumBundles, const char *Name) {
3303
3305 for (auto *Bundle : ArrayRef(Bundles, NumBundles)) {
3306 OperandBundleDef *OB = unwrap(Bundle);
3307 OBs.push_back(*OB);
3308 }
3309
3310 return wrap(unwrap(B)->CreateCallBr(
3311 unwrap<FunctionType>(Ty), unwrap(Fn), unwrap(DefaultDest),
3312 ArrayRef(unwrap(IndirectDests), NumIndirectDests),
3313 ArrayRef<Value *>(unwrap(Args), NumArgs), OBs, Name));
3314}
3315
3317 LLVMValueRef *Args, unsigned NumArgs,
3319 const char *Name) {
3320 return wrap(unwrap(B)->CreateInvoke(unwrap<FunctionType>(Ty), unwrap(Fn),
3321 unwrap(Then), unwrap(Catch),
3322 ArrayRef(unwrap(Args), NumArgs), Name));
3323}
3324
3327 unsigned NumArgs, LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch,
3328 LLVMOperandBundleRef *Bundles, unsigned NumBundles, const char *Name) {
3330 for (auto *Bundle : ArrayRef(Bundles, NumBundles)) {
3331 OperandBundleDef *OB = unwrap(Bundle);
3332 OBs.push_back(*OB);
3333 }
3334 return wrap(unwrap(B)->CreateInvoke(
3335 unwrap<FunctionType>(Ty), unwrap(Fn), unwrap(Then), unwrap(Catch),
3336 ArrayRef(unwrap(Args), NumArgs), OBs, Name));
3337}
3338
3340 LLVMValueRef PersFn, unsigned NumClauses,
3341 const char *Name) {
3342 // The personality used to live on the landingpad instruction, but now it
3343 // lives on the parent function. For compatibility, take the provided
3344 // personality and put it on the parent function.
3345 if (PersFn)
3346 unwrap(B)->GetInsertBlock()->getParent()->setPersonalityFn(
3347 unwrap<Function>(PersFn));
3348 return wrap(unwrap(B)->CreateLandingPad(unwrap(Ty), NumClauses, Name));
3349}
3350
3352 LLVMValueRef *Args, unsigned NumArgs,
3353 const char *Name) {
3354 return wrap(unwrap(B)->CreateCatchPad(unwrap(ParentPad),
3355 ArrayRef(unwrap(Args), NumArgs), Name));
3356}
3357
3359 LLVMValueRef *Args, unsigned NumArgs,
3360 const char *Name) {
3361 if (ParentPad == nullptr) {
3362 Type *Ty = Type::getTokenTy(unwrap(B)->getContext());
3363 ParentPad = wrap(Constant::getNullValue(Ty));
3364 }
3365 return wrap(unwrap(B)->CreateCleanupPad(
3366 unwrap(ParentPad), ArrayRef(unwrap(Args), NumArgs), Name));
3367}
3368
3370 return wrap(unwrap(B)->CreateResume(unwrap(Exn)));
3371}
3372
3374 LLVMBasicBlockRef UnwindBB,
3375 unsigned NumHandlers, const char *Name) {
3376 if (ParentPad == nullptr) {
3377 Type *Ty = Type::getTokenTy(unwrap(B)->getContext());
3378 ParentPad = wrap(Constant::getNullValue(Ty));
3379 }
3380 return wrap(unwrap(B)->CreateCatchSwitch(unwrap(ParentPad), unwrap(UnwindBB),
3381 NumHandlers, Name));
3382}
3383
3385 LLVMBasicBlockRef BB) {
3386 return wrap(unwrap(B)->CreateCatchRet(unwrap<CatchPadInst>(CatchPad),
3387 unwrap(BB)));
3388}
3389
3391 LLVMBasicBlockRef BB) {
3392 return wrap(unwrap(B)->CreateCleanupRet(unwrap<CleanupPadInst>(CatchPad),
3393 unwrap(BB)));
3394}
3395
3397 return wrap(unwrap(B)->CreateUnreachable());
3398}
3399
3401 LLVMBasicBlockRef Dest) {
3402 unwrap<SwitchInst>(Switch)->addCase(unwrap<ConstantInt>(OnVal), unwrap(Dest));
3403}
3404
3406 unwrap<IndirectBrInst>(IndirectBr)->addDestination(unwrap(Dest));
3407}
3408
3409unsigned LLVMGetNumClauses(LLVMValueRef LandingPad) {
3410 return unwrap<LandingPadInst>(LandingPad)->getNumClauses();
3411}
3412
3414 return wrap(unwrap<LandingPadInst>(LandingPad)->getClause(Idx));
3415}
3416
3418 unwrap<LandingPadInst>(LandingPad)->addClause(unwrap<Constant>(ClauseVal));
3419}
3420
3422 return unwrap<LandingPadInst>(LandingPad)->isCleanup();
3423}
3424
3425void LLVMSetCleanup(LLVMValueRef LandingPad, LLVMBool Val) {
3426 unwrap<LandingPadInst>(LandingPad)->setCleanup(Val);
3427}
3428
3430 unwrap<CatchSwitchInst>(CatchSwitch)->addHandler(unwrap(Dest));
3431}
3432
3433unsigned LLVMGetNumHandlers(LLVMValueRef CatchSwitch) {
3434 return unwrap<CatchSwitchInst>(CatchSwitch)->getNumHandlers();
3435}
3436
3437void LLVMGetHandlers(LLVMValueRef CatchSwitch, LLVMBasicBlockRef *Handlers) {
3438 CatchSwitchInst *CSI = unwrap<CatchSwitchInst>(CatchSwitch);
3439 for (const BasicBlock *H : CSI->handlers())
3440 *Handlers++ = wrap(H);
3441}
3442
3444 return wrap(unwrap<CatchPadInst>(CatchPad)->getCatchSwitch());
3445}
3446
3448 unwrap<CatchPadInst>(CatchPad)
3449 ->setCatchSwitch(unwrap<CatchSwitchInst>(CatchSwitch));
3450}
3451
3452/*--.. Funclets ...........................................................--*/
3453
3455 return wrap(unwrap<FuncletPadInst>(Funclet)->getArgOperand(i));
3456}
3457
3459 unwrap<FuncletPadInst>(Funclet)->setArgOperand(i, unwrap(value));
3460}
3461
3462/*--.. Arithmetic ..........................................................--*/
3463
3465 FastMathFlags NewFMF;
3466 NewFMF.setAllowReassoc((FMF & LLVMFastMathAllowReassoc) != 0);
3467 NewFMF.setNoNaNs((FMF & LLVMFastMathNoNaNs) != 0);
3468 NewFMF.setNoInfs((FMF & LLVMFastMathNoInfs) != 0);
3469 NewFMF.setNoSignedZeros((FMF & LLVMFastMathNoSignedZeros) != 0);
3471 NewFMF.setAllowContract((FMF & LLVMFastMathAllowContract) != 0);
3472 NewFMF.setApproxFunc((FMF & LLVMFastMathApproxFunc) != 0);
3473
3474 return NewFMF;
3475}
3476
3479 if (FMF.allowReassoc())
3480 NewFMF |= LLVMFastMathAllowReassoc;
3481 if (FMF.noNaNs())
3482 NewFMF |= LLVMFastMathNoNaNs;
3483 if (FMF.noInfs())
3484 NewFMF |= LLVMFastMathNoInfs;
3485 if (FMF.noSignedZeros())
3486 NewFMF |= LLVMFastMathNoSignedZeros;
3487 if (FMF.allowReciprocal())
3489 if (FMF.allowContract())
3490 NewFMF |= LLVMFastMathAllowContract;
3491 if (FMF.approxFunc())
3492 NewFMF |= LLVMFastMathApproxFunc;
3493
3494 return NewFMF;
3495}
3496
3498 const char *Name) {
3499 return wrap(unwrap(B)->CreateAdd(unwrap(LHS), unwrap(RHS), Name));
3500}
3501
3503 const char *Name) {
3504 return wrap(unwrap(B)->CreateNSWAdd(unwrap(LHS), unwrap(RHS), Name));
3505}
3506
3508 const char *Name) {
3509 return wrap(unwrap(B)->CreateNUWAdd(unwrap(LHS), unwrap(RHS), Name));
3510}
3511
3513 const char *Name) {
3514 return wrap(unwrap(B)->CreateFAdd(unwrap(LHS), unwrap(RHS), Name));
3515}
3516
3518 const char *Name) {
3519 return wrap(unwrap(B)->CreateSub(unwrap(LHS), unwrap(RHS), Name));
3520}
3521
3523 const char *Name) {
3524 return wrap(unwrap(B)->CreateNSWSub(unwrap(LHS), unwrap(RHS), Name));
3525}
3526
3528 const char *Name) {
3529 return wrap(unwrap(B)->CreateNUWSub(unwrap(LHS), unwrap(RHS), Name));
3530}
3531
3533 const char *Name) {
3534 return wrap(unwrap(B)->CreateFSub(unwrap(LHS), unwrap(RHS), Name));
3535}
3536
3538 const char *Name) {
3539 return wrap(unwrap(B)->CreateMul(unwrap(LHS), unwrap(RHS), Name));
3540}
3541
3543 const char *Name) {
3544 return wrap(unwrap(B)->CreateNSWMul(unwrap(LHS), unwrap(RHS), Name));
3545}
3546
3548 const char *Name) {
3549 return wrap(unwrap(B)->CreateNUWMul(unwrap(LHS), unwrap(RHS), Name));
3550}
3551
3553 const char *Name) {
3554 return wrap(unwrap(B)->CreateFMul(unwrap(LHS), unwrap(RHS), Name));
3555}
3556
3558 const char *Name) {
3559 return wrap(unwrap(B)->CreateUDiv(unwrap(LHS), unwrap(RHS), Name));
3560}
3561
3563 LLVMValueRef RHS, const char *Name) {
3564 return wrap(unwrap(B)->CreateExactUDiv(unwrap(LHS), unwrap(RHS), Name));
3565}
3566
3568 const char *Name) {
3569 return wrap(unwrap(B)->CreateSDiv(unwrap(LHS), unwrap(RHS), Name));
3570}
3571
3573 LLVMValueRef RHS, const char *Name) {
3574 return wrap(unwrap(B)->CreateExactSDiv(unwrap(LHS), unwrap(RHS), Name));
3575}
3576
3578 const char *Name) {
3579 return wrap(unwrap(B)->CreateFDiv(unwrap(LHS), unwrap(RHS), Name));
3580}
3581
3583 const char *Name) {
3584 return wrap(unwrap(B)->CreateURem(unwrap(LHS), unwrap(RHS), Name));
3585}
3586
3588 const char *Name) {
3589 return wrap(unwrap(B)->CreateSRem(unwrap(LHS), unwrap(RHS), Name));
3590}
3591
3593 const char *Name) {
3594 return wrap(unwrap(B)->CreateFRem(unwrap(LHS), unwrap(RHS), Name));
3595}
3596
3598 const char *Name) {
3599 return wrap(unwrap(B)->CreateShl(unwrap(LHS), unwrap(RHS), Name));
3600}
3601
3603 const char *Name) {
3604 return wrap(unwrap(B)->CreateLShr(unwrap(LHS), unwrap(RHS), Name));
3605}
3606
3608 const char *Name) {
3609 return wrap(unwrap(B)->CreateAShr(unwrap(LHS), unwrap(RHS), Name));
3610}
3611
3613 const char *Name) {
3614 return wrap(unwrap(B)->CreateAnd(unwrap(LHS), unwrap(RHS), Name));
3615}
3616
3618 const char *Name) {
3619 return wrap(unwrap(B)->CreateOr(unwrap(LHS), unwrap(RHS), Name));
3620}
3621
3623 const char *Name) {
3624 return wrap(unwrap(B)->CreateXor(unwrap(LHS), unwrap(RHS), Name));
3625}
3626
3628 LLVMValueRef LHS, LLVMValueRef RHS,
3629 const char *Name) {
3631 unwrap(RHS), Name));
3632}
3633
3635 return wrap(unwrap(B)->CreateNeg(unwrap(V), Name));
3636}
3637
3639 const char *Name) {
3640 return wrap(unwrap(B)->CreateNSWNeg(unwrap(V), Name));
3641}
3642
3644 const char *Name) {
3645 Value *Neg = unwrap(B)->CreateNeg(unwrap(V), Name);
3646 if (auto *I = dyn_cast<BinaryOperator>(Neg))
3647 I->setHasNoUnsignedWrap();
3648 return wrap(Neg);
3649}
3650
3652 return wrap(unwrap(B)->CreateFNeg(unwrap(V), Name));
3653}
3654
3656 return wrap(unwrap(B)->CreateNot(unwrap(V), Name));
3657}
3658
3660 Value *P = unwrap<Value>(ArithInst);
3661 return cast<Instruction>(P)->hasNoUnsignedWrap();
3662}
3663
3664void LLVMSetNUW(LLVMValueRef ArithInst, LLVMBool HasNUW) {
3665 Value *P = unwrap<Value>(ArithInst);
3666 cast<Instruction>(P)->setHasNoUnsignedWrap(HasNUW);
3667}
3668
3670 Value *P = unwrap<Value>(ArithInst);
3671 return cast<Instruction>(P)->hasNoSignedWrap();
3672}
3673
3674void LLVMSetNSW(LLVMValueRef ArithInst, LLVMBool HasNSW) {
3675 Value *P = unwrap<Value>(ArithInst);
3676 cast<Instruction>(P)->setHasNoSignedWrap(HasNSW);
3677}
3678
3680 Value *P = unwrap<Value>(DivOrShrInst);
3681 return cast<Instruction>(P)->isExact();
3682}
3683
3684void LLVMSetExact(LLVMValueRef DivOrShrInst, LLVMBool IsExact) {
3685 Value *P = unwrap<Value>(DivOrShrInst);
3686 cast<Instruction>(P)->setIsExact(IsExact);
3687}
3688
3690 Value *P = unwrap<Value>(NonNegInst);
3691 return cast<Instruction>(P)->hasNonNeg();
3692}
3693
3694void LLVMSetNNeg(LLVMValueRef NonNegInst, LLVMBool IsNonNeg) {
3695 Value *P = unwrap<Value>(NonNegInst);
3696 cast<Instruction>(P)->setNonNeg(IsNonNeg);
3697}
3698
3700 Value *P = unwrap<Value>(FPMathInst);
3701 FastMathFlags FMF = cast<Instruction>(P)->getFastMathFlags();
3702 return mapToLLVMFastMathFlags(FMF);
3703}
3704
3706 Value *P = unwrap<Value>(FPMathInst);
3707 cast<Instruction>(P)->setFastMathFlags(mapFromLLVMFastMathFlags(FMF));
3708}
3709
3711 Value *Val = unwrap<Value>(V);
3712 return isa<FPMathOperator>(Val);
3713}
3714
3716 Value *P = unwrap<Value>(Inst);
3717 return cast<PossiblyDisjointInst>(P)->isDisjoint();
3718}
3719
3721 Value *P = unwrap<Value>(Inst);
3722 cast<PossiblyDisjointInst>(P)->setIsDisjoint(IsDisjoint);
3723}
3724
3725/*--.. Memory ..............................................................--*/
3726
3728 const char *Name) {
3729 Type* ITy = Type::getInt32Ty(unwrap(B)->GetInsertBlock()->getContext());
3730 Constant* AllocSize = ConstantExpr::getSizeOf(unwrap(Ty));
3731 AllocSize = ConstantExpr::getTruncOrBitCast(AllocSize, ITy);
3732 return wrap(unwrap(B)->CreateMalloc(ITy, unwrap(Ty), AllocSize, nullptr,
3733 nullptr, Name));
3734}
3735
3737 LLVMValueRef Val, const char *Name) {
3738 Type* ITy = Type::getInt32Ty(unwrap(B)->GetInsertBlock()->getContext());
3739 Constant* AllocSize = ConstantExpr::getSizeOf(unwrap(Ty));
3740 AllocSize = ConstantExpr::getTruncOrBitCast(AllocSize, ITy);
3741 return wrap(unwrap(B)->CreateMalloc(ITy, unwrap(Ty), AllocSize, unwrap(Val),
3742 nullptr, Name));
3743}
3744
3746 LLVMValueRef Val, LLVMValueRef Len,
3747 unsigned Align) {
3748 return wrap(unwrap(B)->CreateMemSet(unwrap(Ptr), unwrap(Val), unwrap(Len),
3749 MaybeAlign(Align)));
3750}
3751
3753 LLVMValueRef Dst, unsigned DstAlign,
3754 LLVMValueRef Src, unsigned SrcAlign,
3756 return wrap(unwrap(B)->CreateMemCpy(unwrap(Dst), MaybeAlign(DstAlign),
3757 unwrap(Src), MaybeAlign(SrcAlign),
3758 unwrap(Size)));
3759}
3760