1 //===-- Core.cpp ----------------------------------------------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements the common infrastructure (including the C bindings)
11 // for libLLVMCore.a, which implements the LLVM intermediate representation.
13 //===----------------------------------------------------------------------===//
15 #include "llvm-c/Core.h"
16 #include "llvm/ADT/StringSwitch.h"
17 #include "llvm/Bitcode/BitcodeReader.h"
18 #include "llvm/IR/Attributes.h"
19 #include "AttributeSetNode.h"
20 #include "llvm/IR/CallSite.h"
21 #include "llvm/IR/Constants.h"
22 #include "llvm/IR/DerivedTypes.h"
23 #include "llvm/IR/DiagnosticInfo.h"
24 #include "llvm/IR/DiagnosticPrinter.h"
25 #include "llvm/IR/GlobalAlias.h"
26 #include "llvm/IR/GlobalVariable.h"
27 #include "llvm/IR/IRBuilder.h"
28 #include "llvm/IR/InlineAsm.h"
29 #include "llvm/IR/IntrinsicInst.h"
30 #include "llvm/IR/LLVMContext.h"
31 #include "llvm/IR/LegacyPassManager.h"
32 #include "llvm/IR/Module.h"
33 #include "llvm/Support/Debug.h"
34 #include "llvm/Support/ErrorHandling.h"
35 #include "llvm/Support/FileSystem.h"
36 #include "llvm/Support/ManagedStatic.h"
37 #include "llvm/Support/MemoryBuffer.h"
38 #include "llvm/Support/Threading.h"
39 #include "llvm/Support/raw_ostream.h"
43 #include <system_error>
47 #define DEBUG_TYPE "ir"
49 void llvm::initializeCore(PassRegistry
&Registry
) {
50 initializeDominatorTreeWrapperPassPass(Registry
);
51 initializePrintModulePassWrapperPass(Registry
);
52 initializePrintFunctionPassWrapperPass(Registry
);
53 initializePrintBasicBlockPassPass(Registry
);
54 initializeVerifierLegacyPassPass(Registry
);
57 void LLVMInitializeCore(LLVMPassRegistryRef R
) {
58 initializeCore(*unwrap(R
));
65 /*===-- Error handling ----------------------------------------------------===*/
67 char *LLVMCreateMessage(const char *Message
) {
68 return strdup(Message
);
71 void LLVMDisposeMessage(char *Message
) {
76 /*===-- Operations on contexts --------------------------------------------===*/
78 static ManagedStatic
<LLVMContext
> GlobalContext
;
80 LLVMContextRef
LLVMContextCreate() {
81 return wrap(new LLVMContext());
84 LLVMContextRef
LLVMGetGlobalContext() { return wrap(&*GlobalContext
); }
86 void LLVMContextSetDiagnosticHandler(LLVMContextRef C
,
87 LLVMDiagnosticHandler Handler
,
88 void *DiagnosticContext
) {
89 unwrap(C
)->setDiagnosticHandler(
90 LLVM_EXTENSION
reinterpret_cast<LLVMContext::DiagnosticHandlerTy
>(
95 LLVMDiagnosticHandler
LLVMContextGetDiagnosticHandler(LLVMContextRef C
) {
96 return LLVM_EXTENSION
reinterpret_cast<LLVMDiagnosticHandler
>(
97 unwrap(C
)->getDiagnosticHandler());
100 void *LLVMContextGetDiagnosticContext(LLVMContextRef C
) {
101 return unwrap(C
)->getDiagnosticContext();
104 void LLVMContextSetYieldCallback(LLVMContextRef C
, LLVMYieldCallback Callback
,
105 void *OpaqueHandle
) {
107 LLVM_EXTENSION
reinterpret_cast<LLVMContext::YieldCallbackTy
>(Callback
);
108 unwrap(C
)->setYieldCallback(YieldCallback
, OpaqueHandle
);
111 void LLVMContextDispose(LLVMContextRef C
) {
115 unsigned LLVMGetMDKindIDInContext(LLVMContextRef C
, const char *Name
,
117 return unwrap(C
)->getMDKindID(StringRef(Name
, SLen
));
120 unsigned LLVMGetMDKindID(const char *Name
, unsigned SLen
) {
121 return LLVMGetMDKindIDInContext(LLVMGetGlobalContext(), Name
, SLen
);
124 #define GET_ATTR_KIND_FROM_NAME
125 #include "AttributesCompatFunc.inc"
127 unsigned LLVMGetEnumAttributeKindForName(const char *Name
, size_t SLen
) {
128 return getAttrKindFromName(StringRef(Name
, SLen
));
131 unsigned LLVMGetLastEnumAttributeKind(void) {
132 return Attribute::AttrKind::EndAttrKinds
;
135 LLVMAttributeRef
LLVMCreateEnumAttribute(LLVMContextRef C
, unsigned KindID
,
137 return wrap(Attribute::get(*unwrap(C
), (Attribute::AttrKind
)KindID
, Val
));
140 unsigned LLVMGetEnumAttributeKind(LLVMAttributeRef A
) {
141 return unwrap(A
).getKindAsEnum();
144 uint64_t LLVMGetEnumAttributeValue(LLVMAttributeRef A
) {
145 auto Attr
= unwrap(A
);
146 if (Attr
.isEnumAttribute())
148 return Attr
.getValueAsInt();
151 LLVMAttributeRef
LLVMCreateStringAttribute(LLVMContextRef C
,
152 const char *K
, unsigned KLength
,
153 const char *V
, unsigned VLength
) {
154 return wrap(Attribute::get(*unwrap(C
), StringRef(K
, KLength
),
155 StringRef(V
, VLength
)));
158 const char *LLVMGetStringAttributeKind(LLVMAttributeRef A
,
160 auto S
= unwrap(A
).getKindAsString();
165 const char *LLVMGetStringAttributeValue(LLVMAttributeRef A
,
167 auto S
= unwrap(A
).getValueAsString();
172 LLVMBool
LLVMIsEnumAttribute(LLVMAttributeRef A
) {
173 auto Attr
= unwrap(A
);
174 return Attr
.isEnumAttribute() || Attr
.isIntAttribute();
177 LLVMBool
LLVMIsStringAttribute(LLVMAttributeRef A
) {
178 return unwrap(A
).isStringAttribute();
181 char *LLVMGetDiagInfoDescription(LLVMDiagnosticInfoRef DI
) {
182 std::string MsgStorage
;
183 raw_string_ostream
Stream(MsgStorage
);
184 DiagnosticPrinterRawOStream
DP(Stream
);
186 unwrap(DI
)->print(DP
);
189 return LLVMCreateMessage(MsgStorage
.c_str());
192 LLVMDiagnosticSeverity
LLVMGetDiagInfoSeverity(LLVMDiagnosticInfoRef DI
) {
193 LLVMDiagnosticSeverity severity
;
195 switch(unwrap(DI
)->getSeverity()) {
197 severity
= LLVMDSError
;
200 severity
= LLVMDSWarning
;
203 severity
= LLVMDSRemark
;
206 severity
= LLVMDSNote
;
213 /*===-- Operations on modules ---------------------------------------------===*/
215 LLVMModuleRef
LLVMModuleCreateWithName(const char *ModuleID
) {
216 return wrap(new Module(ModuleID
, *GlobalContext
));
219 LLVMModuleRef
LLVMModuleCreateWithNameInContext(const char *ModuleID
,
221 return wrap(new Module(ModuleID
, *unwrap(C
)));
224 void LLVMDisposeModule(LLVMModuleRef M
) {
228 const char *LLVMGetModuleIdentifier(LLVMModuleRef M
, size_t *Len
) {
229 auto &Str
= unwrap(M
)->getModuleIdentifier();
234 void LLVMSetModuleIdentifier(LLVMModuleRef M
, const char *Ident
, size_t Len
) {
235 unwrap(M
)->setModuleIdentifier(StringRef(Ident
, Len
));
239 /*--.. Data layout .........................................................--*/
240 const char *LLVMGetDataLayoutStr(LLVMModuleRef M
) {
241 return unwrap(M
)->getDataLayoutStr().c_str();
244 const char *LLVMGetDataLayout(LLVMModuleRef M
) {
245 return LLVMGetDataLayoutStr(M
);
248 void LLVMSetDataLayout(LLVMModuleRef M
, const char *DataLayoutStr
) {
249 unwrap(M
)->setDataLayout(DataLayoutStr
);
252 /*--.. Target triple .......................................................--*/
253 const char * LLVMGetTarget(LLVMModuleRef M
) {
254 return unwrap(M
)->getTargetTriple().c_str();
257 void LLVMSetTarget(LLVMModuleRef M
, const char *Triple
) {
258 unwrap(M
)->setTargetTriple(Triple
);
261 void LLVMDumpModule(LLVMModuleRef M
) {
262 unwrap(M
)->print(errs(), nullptr,
263 /*ShouldPreserveUseListOrder=*/false, /*IsForDebug=*/true);
266 LLVMBool
LLVMPrintModuleToFile(LLVMModuleRef M
, const char *Filename
,
267 char **ErrorMessage
) {
269 raw_fd_ostream
dest(Filename
, EC
, sys::fs::F_Text
);
271 *ErrorMessage
= strdup(EC
.message().c_str());
275 unwrap(M
)->print(dest
, nullptr);
279 if (dest
.has_error()) {
280 *ErrorMessage
= strdup("Error printing to file");
287 char *LLVMPrintModuleToString(LLVMModuleRef M
) {
289 raw_string_ostream
os(buf
);
291 unwrap(M
)->print(os
, nullptr);
294 return strdup(buf
.c_str());
297 /*--.. Operations on inline assembler ......................................--*/
298 void LLVMSetModuleInlineAsm(LLVMModuleRef M
, const char *Asm
) {
299 unwrap(M
)->setModuleInlineAsm(StringRef(Asm
));
303 /*--.. Operations on module contexts ......................................--*/
304 LLVMContextRef
LLVMGetModuleContext(LLVMModuleRef M
) {
305 return wrap(&unwrap(M
)->getContext());
309 /*===-- Operations on types -----------------------------------------------===*/
311 /*--.. Operations on all types (mostly) ....................................--*/
313 LLVMTypeKind
LLVMGetTypeKind(LLVMTypeRef Ty
) {
314 switch (unwrap(Ty
)->getTypeID()) {
316 return LLVMVoidTypeKind
;
318 return LLVMHalfTypeKind
;
319 case Type::FloatTyID
:
320 return LLVMFloatTypeKind
;
321 case Type::DoubleTyID
:
322 return LLVMDoubleTypeKind
;
323 case Type::X86_FP80TyID
:
324 return LLVMX86_FP80TypeKind
;
325 case Type::FP128TyID
:
326 return LLVMFP128TypeKind
;
327 case Type::PPC_FP128TyID
:
328 return LLVMPPC_FP128TypeKind
;
329 case Type::LabelTyID
:
330 return LLVMLabelTypeKind
;
331 case Type::MetadataTyID
:
332 return LLVMMetadataTypeKind
;
333 case Type::IntegerTyID
:
334 return LLVMIntegerTypeKind
;
335 case Type::FunctionTyID
:
336 return LLVMFunctionTypeKind
;
337 case Type::StructTyID
:
338 return LLVMStructTypeKind
;
339 case Type::ArrayTyID
:
340 return LLVMArrayTypeKind
;
341 case Type::PointerTyID
:
342 return LLVMPointerTypeKind
;
343 case Type::VectorTyID
:
344 return LLVMVectorTypeKind
;
345 case Type::X86_MMXTyID
:
346 return LLVMX86_MMXTypeKind
;
347 case Type::TokenTyID
:
348 return LLVMTokenTypeKind
;
350 llvm_unreachable("Unhandled TypeID.");
353 LLVMBool
LLVMTypeIsSized(LLVMTypeRef Ty
)
355 return unwrap(Ty
)->isSized();
358 LLVMContextRef
LLVMGetTypeContext(LLVMTypeRef Ty
) {
359 return wrap(&unwrap(Ty
)->getContext());
362 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
363 LLVM_DUMP_METHOD
void LLVMDumpType(LLVMTypeRef Ty
) {
364 return unwrap(Ty
)->dump();
368 char *LLVMPrintTypeToString(LLVMTypeRef Ty
) {
370 raw_string_ostream
os(buf
);
373 unwrap(Ty
)->print(os
);
375 os
<< "Printing <null> Type";
379 return strdup(buf
.c_str());
382 /*--.. Operations on integer types .........................................--*/
384 LLVMTypeRef
LLVMInt1TypeInContext(LLVMContextRef C
) {
385 return (LLVMTypeRef
) Type::getInt1Ty(*unwrap(C
));
387 LLVMTypeRef
LLVMInt8TypeInContext(LLVMContextRef C
) {
388 return (LLVMTypeRef
) Type::getInt8Ty(*unwrap(C
));
390 LLVMTypeRef
LLVMInt16TypeInContext(LLVMContextRef C
) {
391 return (LLVMTypeRef
) Type::getInt16Ty(*unwrap(C
));
393 LLVMTypeRef
LLVMInt32TypeInContext(LLVMContextRef C
) {
394 return (LLVMTypeRef
) Type::getInt32Ty(*unwrap(C
));
396 LLVMTypeRef
LLVMInt64TypeInContext(LLVMContextRef C
) {
397 return (LLVMTypeRef
) Type::getInt64Ty(*unwrap(C
));
399 LLVMTypeRef
LLVMInt128TypeInContext(LLVMContextRef C
) {
400 return (LLVMTypeRef
) Type::getInt128Ty(*unwrap(C
));
402 LLVMTypeRef
LLVMIntTypeInContext(LLVMContextRef C
, unsigned NumBits
) {
403 return wrap(IntegerType::get(*unwrap(C
), NumBits
));
406 LLVMTypeRef
LLVMInt1Type(void) {
407 return LLVMInt1TypeInContext(LLVMGetGlobalContext());
409 LLVMTypeRef
LLVMInt8Type(void) {
410 return LLVMInt8TypeInContext(LLVMGetGlobalContext());
412 LLVMTypeRef
LLVMInt16Type(void) {
413 return LLVMInt16TypeInContext(LLVMGetGlobalContext());
415 LLVMTypeRef
LLVMInt32Type(void) {
416 return LLVMInt32TypeInContext(LLVMGetGlobalContext());
418 LLVMTypeRef
LLVMInt64Type(void) {
419 return LLVMInt64TypeInContext(LLVMGetGlobalContext());
421 LLVMTypeRef
LLVMInt128Type(void) {
422 return LLVMInt128TypeInContext(LLVMGetGlobalContext());
424 LLVMTypeRef
LLVMIntType(unsigned NumBits
) {
425 return LLVMIntTypeInContext(LLVMGetGlobalContext(), NumBits
);
428 unsigned LLVMGetIntTypeWidth(LLVMTypeRef IntegerTy
) {
429 return unwrap
<IntegerType
>(IntegerTy
)->getBitWidth();
432 /*--.. Operations on real types ............................................--*/
434 LLVMTypeRef
LLVMHalfTypeInContext(LLVMContextRef C
) {
435 return (LLVMTypeRef
) Type::getHalfTy(*unwrap(C
));
437 LLVMTypeRef
LLVMFloatTypeInContext(LLVMContextRef C
) {
438 return (LLVMTypeRef
) Type::getFloatTy(*unwrap(C
));
440 LLVMTypeRef
LLVMDoubleTypeInContext(LLVMContextRef C
) {
441 return (LLVMTypeRef
) Type::getDoubleTy(*unwrap(C
));
443 LLVMTypeRef
LLVMX86FP80TypeInContext(LLVMContextRef C
) {
444 return (LLVMTypeRef
) Type::getX86_FP80Ty(*unwrap(C
));
446 LLVMTypeRef
LLVMFP128TypeInContext(LLVMContextRef C
) {
447 return (LLVMTypeRef
) Type::getFP128Ty(*unwrap(C
));
449 LLVMTypeRef
LLVMPPCFP128TypeInContext(LLVMContextRef C
) {
450 return (LLVMTypeRef
) Type::getPPC_FP128Ty(*unwrap(C
));
452 LLVMTypeRef
LLVMX86MMXTypeInContext(LLVMContextRef C
) {
453 return (LLVMTypeRef
) Type::getX86_MMXTy(*unwrap(C
));
455 LLVMTypeRef
LLVMTokenTypeInContext(LLVMContextRef C
) {
456 return (LLVMTypeRef
) Type::getTokenTy(*unwrap(C
));
459 LLVMTypeRef
LLVMHalfType(void) {
460 return LLVMHalfTypeInContext(LLVMGetGlobalContext());
462 LLVMTypeRef
LLVMFloatType(void) {
463 return LLVMFloatTypeInContext(LLVMGetGlobalContext());
465 LLVMTypeRef
LLVMDoubleType(void) {
466 return LLVMDoubleTypeInContext(LLVMGetGlobalContext());
468 LLVMTypeRef
LLVMX86FP80Type(void) {
469 return LLVMX86FP80TypeInContext(LLVMGetGlobalContext());
471 LLVMTypeRef
LLVMFP128Type(void) {
472 return LLVMFP128TypeInContext(LLVMGetGlobalContext());
474 LLVMTypeRef
LLVMPPCFP128Type(void) {
475 return LLVMPPCFP128TypeInContext(LLVMGetGlobalContext());
477 LLVMTypeRef
LLVMX86MMXType(void) {
478 return LLVMX86MMXTypeInContext(LLVMGetGlobalContext());
481 /*--.. Operations on function types ........................................--*/
483 LLVMTypeRef
LLVMFunctionType(LLVMTypeRef ReturnType
,
484 LLVMTypeRef
*ParamTypes
, unsigned ParamCount
,
486 ArrayRef
<Type
*> Tys(unwrap(ParamTypes
), ParamCount
);
487 return wrap(FunctionType::get(unwrap(ReturnType
), Tys
, IsVarArg
!= 0));
490 LLVMBool
LLVMIsFunctionVarArg(LLVMTypeRef FunctionTy
) {
491 return unwrap
<FunctionType
>(FunctionTy
)->isVarArg();
494 LLVMTypeRef
LLVMGetReturnType(LLVMTypeRef FunctionTy
) {
495 return wrap(unwrap
<FunctionType
>(FunctionTy
)->getReturnType());
498 unsigned LLVMCountParamTypes(LLVMTypeRef FunctionTy
) {
499 return unwrap
<FunctionType
>(FunctionTy
)->getNumParams();
502 void LLVMGetParamTypes(LLVMTypeRef FunctionTy
, LLVMTypeRef
*Dest
) {
503 FunctionType
*Ty
= unwrap
<FunctionType
>(FunctionTy
);
504 for (FunctionType::param_iterator I
= Ty
->param_begin(),
505 E
= Ty
->param_end(); I
!= E
; ++I
)
509 /*--.. Operations on struct types ..........................................--*/
511 LLVMTypeRef
LLVMStructTypeInContext(LLVMContextRef C
, LLVMTypeRef
*ElementTypes
,
512 unsigned ElementCount
, LLVMBool Packed
) {
513 ArrayRef
<Type
*> Tys(unwrap(ElementTypes
), ElementCount
);
514 return wrap(StructType::get(*unwrap(C
), Tys
, Packed
!= 0));
517 LLVMTypeRef
LLVMStructType(LLVMTypeRef
*ElementTypes
,
518 unsigned ElementCount
, LLVMBool Packed
) {
519 return LLVMStructTypeInContext(LLVMGetGlobalContext(), ElementTypes
,
520 ElementCount
, Packed
);
523 LLVMTypeRef
LLVMStructCreateNamed(LLVMContextRef C
, const char *Name
)
525 return wrap(StructType::create(*unwrap(C
), Name
));
528 const char *LLVMGetStructName(LLVMTypeRef Ty
)
530 StructType
*Type
= unwrap
<StructType
>(Ty
);
531 if (!Type
->hasName())
533 return Type
->getName().data();
536 void LLVMStructSetBody(LLVMTypeRef StructTy
, LLVMTypeRef
*ElementTypes
,
537 unsigned ElementCount
, LLVMBool Packed
) {
538 ArrayRef
<Type
*> Tys(unwrap(ElementTypes
), ElementCount
);
539 unwrap
<StructType
>(StructTy
)->setBody(Tys
, Packed
!= 0);
542 unsigned LLVMCountStructElementTypes(LLVMTypeRef StructTy
) {
543 return unwrap
<StructType
>(StructTy
)->getNumElements();
546 void LLVMGetStructElementTypes(LLVMTypeRef StructTy
, LLVMTypeRef
*Dest
) {
547 StructType
*Ty
= unwrap
<StructType
>(StructTy
);
548 for (StructType::element_iterator I
= Ty
->element_begin(),
549 E
= Ty
->element_end(); I
!= E
; ++I
)
553 LLVMTypeRef
LLVMStructGetTypeAtIndex(LLVMTypeRef StructTy
, unsigned i
) {
554 StructType
*Ty
= unwrap
<StructType
>(StructTy
);
555 return wrap(Ty
->getTypeAtIndex(i
));
558 LLVMBool
LLVMIsPackedStruct(LLVMTypeRef StructTy
) {
559 return unwrap
<StructType
>(StructTy
)->isPacked();
562 LLVMBool
LLVMIsOpaqueStruct(LLVMTypeRef StructTy
) {
563 return unwrap
<StructType
>(StructTy
)->isOpaque();
566 LLVMTypeRef
LLVMGetTypeByName(LLVMModuleRef M
, const char *Name
) {
567 return wrap(unwrap(M
)->getTypeByName(Name
));
570 /*--.. Operations on array, pointer, and vector types (sequence types) .....--*/
572 LLVMTypeRef
LLVMArrayType(LLVMTypeRef ElementType
, unsigned ElementCount
) {
573 return wrap(ArrayType::get(unwrap(ElementType
), ElementCount
));
576 LLVMTypeRef
LLVMPointerType(LLVMTypeRef ElementType
, unsigned AddressSpace
) {
577 return wrap(PointerType::get(unwrap(ElementType
), AddressSpace
));
580 LLVMTypeRef
LLVMVectorType(LLVMTypeRef ElementType
, unsigned ElementCount
) {
581 return wrap(VectorType::get(unwrap(ElementType
), ElementCount
));
584 LLVMTypeRef
LLVMGetElementType(LLVMTypeRef WrappedTy
) {
585 auto *Ty
= unwrap
<Type
>(WrappedTy
);
586 if (auto *PTy
= dyn_cast
<PointerType
>(Ty
))
587 return wrap(PTy
->getElementType());
588 return wrap(cast
<SequentialType
>(Ty
)->getElementType());
591 unsigned LLVMGetArrayLength(LLVMTypeRef ArrayTy
) {
592 return unwrap
<ArrayType
>(ArrayTy
)->getNumElements();
595 unsigned LLVMGetPointerAddressSpace(LLVMTypeRef PointerTy
) {
596 return unwrap
<PointerType
>(PointerTy
)->getAddressSpace();
599 unsigned LLVMGetVectorSize(LLVMTypeRef VectorTy
) {
600 return unwrap
<VectorType
>(VectorTy
)->getNumElements();
603 /*--.. Operations on other types ...........................................--*/
605 LLVMTypeRef
LLVMVoidTypeInContext(LLVMContextRef C
) {
606 return wrap(Type::getVoidTy(*unwrap(C
)));
608 LLVMTypeRef
LLVMLabelTypeInContext(LLVMContextRef C
) {
609 return wrap(Type::getLabelTy(*unwrap(C
)));
612 LLVMTypeRef
LLVMVoidType(void) {
613 return LLVMVoidTypeInContext(LLVMGetGlobalContext());
615 LLVMTypeRef
LLVMLabelType(void) {
616 return LLVMLabelTypeInContext(LLVMGetGlobalContext());
619 /*===-- Operations on values ----------------------------------------------===*/
621 /*--.. Operations on all values ............................................--*/
623 LLVMTypeRef
LLVMTypeOf(LLVMValueRef Val
) {
624 return wrap(unwrap(Val
)->getType());
627 LLVMValueKind
LLVMGetValueKind(LLVMValueRef Val
) {
628 switch(unwrap(Val
)->getValueID()) {
629 #define HANDLE_VALUE(Name) \
630 case Value::Name##Val: \
631 return LLVM##Name##ValueKind;
632 #include "llvm/IR/Value.def"
634 return LLVMInstructionValueKind
;
638 const char *LLVMGetValueName(LLVMValueRef Val
) {
639 return unwrap(Val
)->getName().data();
642 void LLVMSetValueName(LLVMValueRef Val
, const char *Name
) {
643 unwrap(Val
)->setName(Name
);
646 LLVM_DUMP_METHOD
void LLVMDumpValue(LLVMValueRef Val
) {
647 unwrap(Val
)->print(errs(), /*IsForDebug=*/true);
650 char* LLVMPrintValueToString(LLVMValueRef Val
) {
652 raw_string_ostream
os(buf
);
655 unwrap(Val
)->print(os
);
657 os
<< "Printing <null> Value";
661 return strdup(buf
.c_str());
664 void LLVMReplaceAllUsesWith(LLVMValueRef OldVal
, LLVMValueRef NewVal
) {
665 unwrap(OldVal
)->replaceAllUsesWith(unwrap(NewVal
));
668 int LLVMHasMetadata(LLVMValueRef Inst
) {
669 return unwrap
<Instruction
>(Inst
)->hasMetadata();
672 LLVMValueRef
LLVMGetMetadata(LLVMValueRef Inst
, unsigned KindID
) {
673 auto *I
= unwrap
<Instruction
>(Inst
);
674 assert(I
&& "Expected instruction");
675 if (auto *MD
= I
->getMetadata(KindID
))
676 return wrap(MetadataAsValue::get(I
->getContext(), MD
));
680 // MetadataAsValue uses a canonical format which strips the actual MDNode for
681 // MDNode with just a single constant value, storing just a ConstantAsMetadata
682 // This undoes this canonicalization, reconstructing the MDNode.
683 static MDNode
*extractMDNode(MetadataAsValue
*MAV
) {
684 Metadata
*MD
= MAV
->getMetadata();
685 assert((isa
<MDNode
>(MD
) || isa
<ConstantAsMetadata
>(MD
)) &&
686 "Expected a metadata node or a canonicalized constant");
688 if (MDNode
*N
= dyn_cast
<MDNode
>(MD
))
691 return MDNode::get(MAV
->getContext(), MD
);
694 void LLVMSetMetadata(LLVMValueRef Inst
, unsigned KindID
, LLVMValueRef Val
) {
695 MDNode
*N
= Val
? extractMDNode(unwrap
<MetadataAsValue
>(Val
)) : nullptr;
697 unwrap
<Instruction
>(Inst
)->setMetadata(KindID
, N
);
700 /*--.. Conversion functions ................................................--*/
702 #define LLVM_DEFINE_VALUE_CAST(name) \
703 LLVMValueRef LLVMIsA##name(LLVMValueRef Val) { \
704 return wrap(static_cast<Value*>(dyn_cast_or_null<name>(unwrap(Val)))); \
707 LLVM_FOR_EACH_VALUE_SUBCLASS(LLVM_DEFINE_VALUE_CAST
)
709 LLVMValueRef
LLVMIsAMDNode(LLVMValueRef Val
) {
710 if (auto *MD
= dyn_cast_or_null
<MetadataAsValue
>(unwrap(Val
)))
711 if (isa
<MDNode
>(MD
->getMetadata()) ||
712 isa
<ValueAsMetadata
>(MD
->getMetadata()))
717 LLVMValueRef
LLVMIsAMDString(LLVMValueRef Val
) {
718 if (auto *MD
= dyn_cast_or_null
<MetadataAsValue
>(unwrap(Val
)))
719 if (isa
<MDString
>(MD
->getMetadata()))
724 /*--.. Operations on Uses ..................................................--*/
725 LLVMUseRef
LLVMGetFirstUse(LLVMValueRef Val
) {
726 Value
*V
= unwrap(Val
);
727 Value::use_iterator I
= V
->use_begin();
728 if (I
== V
->use_end())
733 LLVMUseRef
LLVMGetNextUse(LLVMUseRef U
) {
734 Use
*Next
= unwrap(U
)->getNext();
740 LLVMValueRef
LLVMGetUser(LLVMUseRef U
) {
741 return wrap(unwrap(U
)->getUser());
744 LLVMValueRef
LLVMGetUsedValue(LLVMUseRef U
) {
745 return wrap(unwrap(U
)->get());
748 /*--.. Operations on Users .................................................--*/
750 static LLVMValueRef
getMDNodeOperandImpl(LLVMContext
&Context
, const MDNode
*N
,
752 Metadata
*Op
= N
->getOperand(Index
);
755 if (auto *C
= dyn_cast
<ConstantAsMetadata
>(Op
))
756 return wrap(C
->getValue());
757 return wrap(MetadataAsValue::get(Context
, Op
));
760 LLVMValueRef
LLVMGetOperand(LLVMValueRef Val
, unsigned Index
) {
761 Value
*V
= unwrap(Val
);
762 if (auto *MD
= dyn_cast
<MetadataAsValue
>(V
)) {
763 if (auto *L
= dyn_cast
<ValueAsMetadata
>(MD
->getMetadata())) {
764 assert(Index
== 0 && "Function-local metadata can only have one operand");
765 return wrap(L
->getValue());
767 return getMDNodeOperandImpl(V
->getContext(),
768 cast
<MDNode
>(MD
->getMetadata()), Index
);
771 return wrap(cast
<User
>(V
)->getOperand(Index
));
774 LLVMUseRef
LLVMGetOperandUse(LLVMValueRef Val
, unsigned Index
) {
775 Value
*V
= unwrap(Val
);
776 return wrap(&cast
<User
>(V
)->getOperandUse(Index
));
779 void LLVMSetOperand(LLVMValueRef Val
, unsigned Index
, LLVMValueRef Op
) {
780 unwrap
<User
>(Val
)->setOperand(Index
, unwrap(Op
));
783 int LLVMGetNumOperands(LLVMValueRef Val
) {
784 Value
*V
= unwrap(Val
);
785 if (isa
<MetadataAsValue
>(V
))
786 return LLVMGetMDNodeNumOperands(Val
);
788 return cast
<User
>(V
)->getNumOperands();
791 /*--.. Operations on constants of any type .................................--*/
793 LLVMValueRef
LLVMConstNull(LLVMTypeRef Ty
) {
794 return wrap(Constant::getNullValue(unwrap(Ty
)));
797 LLVMValueRef
LLVMConstAllOnes(LLVMTypeRef Ty
) {
798 return wrap(Constant::getAllOnesValue(unwrap(Ty
)));
801 LLVMValueRef
LLVMGetUndef(LLVMTypeRef Ty
) {
802 return wrap(UndefValue::get(unwrap(Ty
)));
805 LLVMBool
LLVMIsConstant(LLVMValueRef Ty
) {
806 return isa
<Constant
>(unwrap(Ty
));
809 LLVMBool
LLVMIsNull(LLVMValueRef Val
) {
810 if (Constant
*C
= dyn_cast
<Constant
>(unwrap(Val
)))
811 return C
->isNullValue();
815 LLVMBool
LLVMIsUndef(LLVMValueRef Val
) {
816 return isa
<UndefValue
>(unwrap(Val
));
819 LLVMValueRef
LLVMConstPointerNull(LLVMTypeRef Ty
) {
820 return wrap(ConstantPointerNull::get(unwrap
<PointerType
>(Ty
)));
823 /*--.. Operations on metadata nodes ........................................--*/
825 LLVMValueRef
LLVMMDStringInContext(LLVMContextRef C
, const char *Str
,
827 LLVMContext
&Context
= *unwrap(C
);
828 return wrap(MetadataAsValue::get(
829 Context
, MDString::get(Context
, StringRef(Str
, SLen
))));
832 LLVMValueRef
LLVMMDString(const char *Str
, unsigned SLen
) {
833 return LLVMMDStringInContext(LLVMGetGlobalContext(), Str
, SLen
);
836 LLVMValueRef
LLVMMDNodeInContext(LLVMContextRef C
, LLVMValueRef
*Vals
,
838 LLVMContext
&Context
= *unwrap(C
);
839 SmallVector
<Metadata
*, 8> MDs
;
840 for (auto *OV
: makeArrayRef(Vals
, Count
)) {
841 Value
*V
= unwrap(OV
);
845 else if (auto *C
= dyn_cast
<Constant
>(V
))
846 MD
= ConstantAsMetadata::get(C
);
847 else if (auto *MDV
= dyn_cast
<MetadataAsValue
>(V
)) {
848 MD
= MDV
->getMetadata();
849 assert(!isa
<LocalAsMetadata
>(MD
) && "Unexpected function-local metadata "
850 "outside of direct argument to call");
852 // This is function-local metadata. Pretend to make an MDNode.
854 "Expected only one operand to function-local metadata");
855 return wrap(MetadataAsValue::get(Context
, LocalAsMetadata::get(V
)));
860 return wrap(MetadataAsValue::get(Context
, MDNode::get(Context
, MDs
)));
863 LLVMValueRef
LLVMMDNode(LLVMValueRef
*Vals
, unsigned Count
) {
864 return LLVMMDNodeInContext(LLVMGetGlobalContext(), Vals
, Count
);
867 const char *LLVMGetMDString(LLVMValueRef V
, unsigned *Length
) {
868 if (const auto *MD
= dyn_cast
<MetadataAsValue
>(unwrap(V
)))
869 if (const MDString
*S
= dyn_cast
<MDString
>(MD
->getMetadata())) {
870 *Length
= S
->getString().size();
871 return S
->getString().data();
877 unsigned LLVMGetMDNodeNumOperands(LLVMValueRef V
) {
878 auto *MD
= cast
<MetadataAsValue
>(unwrap(V
));
879 if (isa
<ValueAsMetadata
>(MD
->getMetadata()))
881 return cast
<MDNode
>(MD
->getMetadata())->getNumOperands();
884 void LLVMGetMDNodeOperands(LLVMValueRef V
, LLVMValueRef
*Dest
) {
885 auto *MD
= cast
<MetadataAsValue
>(unwrap(V
));
886 if (auto *MDV
= dyn_cast
<ValueAsMetadata
>(MD
->getMetadata())) {
887 *Dest
= wrap(MDV
->getValue());
890 const auto *N
= cast
<MDNode
>(MD
->getMetadata());
891 const unsigned numOperands
= N
->getNumOperands();
892 LLVMContext
&Context
= unwrap(V
)->getContext();
893 for (unsigned i
= 0; i
< numOperands
; i
++)
894 Dest
[i
] = getMDNodeOperandImpl(Context
, N
, i
);
897 unsigned LLVMGetNamedMetadataNumOperands(LLVMModuleRef M
, const char *Name
) {
898 if (NamedMDNode
*N
= unwrap(M
)->getNamedMetadata(Name
)) {
899 return N
->getNumOperands();
904 void LLVMGetNamedMetadataOperands(LLVMModuleRef M
, const char *Name
,
905 LLVMValueRef
*Dest
) {
906 NamedMDNode
*N
= unwrap(M
)->getNamedMetadata(Name
);
909 LLVMContext
&Context
= unwrap(M
)->getContext();
910 for (unsigned i
=0;i
<N
->getNumOperands();i
++)
911 Dest
[i
] = wrap(MetadataAsValue::get(Context
, N
->getOperand(i
)));
914 void LLVMAddNamedMetadataOperand(LLVMModuleRef M
, const char *Name
,
916 NamedMDNode
*N
= unwrap(M
)->getOrInsertNamedMetadata(Name
);
921 N
->addOperand(extractMDNode(unwrap
<MetadataAsValue
>(Val
)));
924 /*--.. Operations on scalar constants ......................................--*/
926 LLVMValueRef
LLVMConstInt(LLVMTypeRef IntTy
, unsigned long long N
,
927 LLVMBool SignExtend
) {
928 return wrap(ConstantInt::get(unwrap
<IntegerType
>(IntTy
), N
, SignExtend
!= 0));
931 LLVMValueRef
LLVMConstIntOfArbitraryPrecision(LLVMTypeRef IntTy
,
933 const uint64_t Words
[]) {
934 IntegerType
*Ty
= unwrap
<IntegerType
>(IntTy
);
935 return wrap(ConstantInt::get(Ty
->getContext(),
936 APInt(Ty
->getBitWidth(),
937 makeArrayRef(Words
, NumWords
))));
940 LLVMValueRef
LLVMConstIntOfString(LLVMTypeRef IntTy
, const char Str
[],
942 return wrap(ConstantInt::get(unwrap
<IntegerType
>(IntTy
), StringRef(Str
),
946 LLVMValueRef
LLVMConstIntOfStringAndSize(LLVMTypeRef IntTy
, const char Str
[],
947 unsigned SLen
, uint8_t Radix
) {
948 return wrap(ConstantInt::get(unwrap
<IntegerType
>(IntTy
), StringRef(Str
, SLen
),
952 LLVMValueRef
LLVMConstReal(LLVMTypeRef RealTy
, double N
) {
953 return wrap(ConstantFP::get(unwrap(RealTy
), N
));
956 LLVMValueRef
LLVMConstRealOfString(LLVMTypeRef RealTy
, const char *Text
) {
957 return wrap(ConstantFP::get(unwrap(RealTy
), StringRef(Text
)));
960 LLVMValueRef
LLVMConstRealOfStringAndSize(LLVMTypeRef RealTy
, const char Str
[],
962 return wrap(ConstantFP::get(unwrap(RealTy
), StringRef(Str
, SLen
)));
965 unsigned long long LLVMConstIntGetZExtValue(LLVMValueRef ConstantVal
) {
966 return unwrap
<ConstantInt
>(ConstantVal
)->getZExtValue();
969 long long LLVMConstIntGetSExtValue(LLVMValueRef ConstantVal
) {
970 return unwrap
<ConstantInt
>(ConstantVal
)->getSExtValue();
973 double LLVMConstRealGetDouble(LLVMValueRef ConstantVal
, LLVMBool
*LosesInfo
) {
974 ConstantFP
*cFP
= unwrap
<ConstantFP
>(ConstantVal
) ;
975 Type
*Ty
= cFP
->getType();
977 if (Ty
->isFloatTy()) {
979 return cFP
->getValueAPF().convertToFloat();
982 if (Ty
->isDoubleTy()) {
984 return cFP
->getValueAPF().convertToDouble();
988 APFloat APF
= cFP
->getValueAPF();
989 APF
.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven
, &APFLosesInfo
);
990 *LosesInfo
= APFLosesInfo
;
991 return APF
.convertToDouble();
994 /*--.. Operations on composite constants ...................................--*/
996 LLVMValueRef
LLVMConstStringInContext(LLVMContextRef C
, const char *Str
,
998 LLVMBool DontNullTerminate
) {
999 /* Inverted the sense of AddNull because ', 0)' is a
1000 better mnemonic for null termination than ', 1)'. */
1001 return wrap(ConstantDataArray::getString(*unwrap(C
), StringRef(Str
, Length
),
1002 DontNullTerminate
== 0));
1005 LLVMValueRef
LLVMConstString(const char *Str
, unsigned Length
,
1006 LLVMBool DontNullTerminate
) {
1007 return LLVMConstStringInContext(LLVMGetGlobalContext(), Str
, Length
,
1011 LLVMValueRef
LLVMGetElementAsConstant(LLVMValueRef C
, unsigned idx
) {
1012 return wrap(unwrap
<ConstantDataSequential
>(C
)->getElementAsConstant(idx
));
1015 LLVMBool
LLVMIsConstantString(LLVMValueRef C
) {
1016 return unwrap
<ConstantDataSequential
>(C
)->isString();
1019 const char *LLVMGetAsString(LLVMValueRef C
, size_t *Length
) {
1020 StringRef Str
= unwrap
<ConstantDataSequential
>(C
)->getAsString();
1021 *Length
= Str
.size();
1025 LLVMValueRef
LLVMConstArray(LLVMTypeRef ElementTy
,
1026 LLVMValueRef
*ConstantVals
, unsigned Length
) {
1027 ArrayRef
<Constant
*> V(unwrap
<Constant
>(ConstantVals
, Length
), Length
);
1028 return wrap(ConstantArray::get(ArrayType::get(unwrap(ElementTy
), Length
), V
));
1031 LLVMValueRef
LLVMConstStructInContext(LLVMContextRef C
,
1032 LLVMValueRef
*ConstantVals
,
1033 unsigned Count
, LLVMBool Packed
) {
1034 Constant
**Elements
= unwrap
<Constant
>(ConstantVals
, Count
);
1035 return wrap(ConstantStruct::getAnon(*unwrap(C
), makeArrayRef(Elements
, Count
),
1039 LLVMValueRef
LLVMConstStruct(LLVMValueRef
*ConstantVals
, unsigned Count
,
1041 return LLVMConstStructInContext(LLVMGetGlobalContext(), ConstantVals
, Count
,
1045 LLVMValueRef
LLVMConstNamedStruct(LLVMTypeRef StructTy
,
1046 LLVMValueRef
*ConstantVals
,
1048 Constant
**Elements
= unwrap
<Constant
>(ConstantVals
, Count
);
1049 StructType
*Ty
= cast
<StructType
>(unwrap(StructTy
));
1051 return wrap(ConstantStruct::get(Ty
, makeArrayRef(Elements
, Count
)));
1054 LLVMValueRef
LLVMConstVector(LLVMValueRef
*ScalarConstantVals
, unsigned Size
) {
1055 return wrap(ConstantVector::get(makeArrayRef(
1056 unwrap
<Constant
>(ScalarConstantVals
, Size
), Size
)));
1059 /*-- Opcode mapping */
1061 static LLVMOpcode
map_to_llvmopcode(int opcode
)
1064 default: llvm_unreachable("Unhandled Opcode.");
1065 #define HANDLE_INST(num, opc, clas) case num: return LLVM##opc;
1066 #include "llvm/IR/Instruction.def"
1071 static int map_from_llvmopcode(LLVMOpcode code
)
1074 #define HANDLE_INST(num, opc, clas) case LLVM##opc: return num;
1075 #include "llvm/IR/Instruction.def"
1078 llvm_unreachable("Unhandled Opcode.");
1081 /*--.. Constant expressions ................................................--*/
1083 LLVMOpcode
LLVMGetConstOpcode(LLVMValueRef ConstantVal
) {
1084 return map_to_llvmopcode(unwrap
<ConstantExpr
>(ConstantVal
)->getOpcode());
1087 LLVMValueRef
LLVMAlignOf(LLVMTypeRef Ty
) {
1088 return wrap(ConstantExpr::getAlignOf(unwrap(Ty
)));
1091 LLVMValueRef
LLVMSizeOf(LLVMTypeRef Ty
) {
1092 return wrap(ConstantExpr::getSizeOf(unwrap(Ty
)));
1095 LLVMValueRef
LLVMConstNeg(LLVMValueRef ConstantVal
) {
1096 return wrap(ConstantExpr::getNeg(unwrap
<Constant
>(ConstantVal
)));
1099 LLVMValueRef
LLVMConstNSWNeg(LLVMValueRef ConstantVal
) {
1100 return wrap(ConstantExpr::getNSWNeg(unwrap
<Constant
>(ConstantVal
)));
1103 LLVMValueRef
LLVMConstNUWNeg(LLVMValueRef ConstantVal
) {
1104 return wrap(ConstantExpr::getNUWNeg(unwrap
<Constant
>(ConstantVal
)));
1108 LLVMValueRef
LLVMConstFNeg(LLVMValueRef ConstantVal
) {
1109 return wrap(ConstantExpr::getFNeg(unwrap
<Constant
>(ConstantVal
)));
1112 LLVMValueRef
LLVMConstNot(LLVMValueRef ConstantVal
) {
1113 return wrap(ConstantExpr::getNot(unwrap
<Constant
>(ConstantVal
)));
1116 LLVMValueRef
LLVMConstAdd(LLVMValueRef LHSConstant
, LLVMValueRef RHSConstant
) {
1117 return wrap(ConstantExpr::getAdd(unwrap
<Constant
>(LHSConstant
),
1118 unwrap
<Constant
>(RHSConstant
)));
1121 LLVMValueRef
LLVMConstNSWAdd(LLVMValueRef LHSConstant
,
1122 LLVMValueRef RHSConstant
) {
1123 return wrap(ConstantExpr::getNSWAdd(unwrap
<Constant
>(LHSConstant
),
1124 unwrap
<Constant
>(RHSConstant
)));
1127 LLVMValueRef
LLVMConstNUWAdd(LLVMValueRef LHSConstant
,
1128 LLVMValueRef RHSConstant
) {
1129 return wrap(ConstantExpr::getNUWAdd(unwrap
<Constant
>(LHSConstant
),
1130 unwrap
<Constant
>(RHSConstant
)));
1133 LLVMValueRef
LLVMConstFAdd(LLVMValueRef LHSConstant
, LLVMValueRef RHSConstant
) {
1134 return wrap(ConstantExpr::getFAdd(unwrap
<Constant
>(LHSConstant
),
1135 unwrap
<Constant
>(RHSConstant
)));
1138 LLVMValueRef
LLVMConstSub(LLVMValueRef LHSConstant
, LLVMValueRef RHSConstant
) {
1139 return wrap(ConstantExpr::getSub(unwrap
<Constant
>(LHSConstant
),
1140 unwrap
<Constant
>(RHSConstant
)));
1143 LLVMValueRef
LLVMConstNSWSub(LLVMValueRef LHSConstant
,
1144 LLVMValueRef RHSConstant
) {
1145 return wrap(ConstantExpr::getNSWSub(unwrap
<Constant
>(LHSConstant
),
1146 unwrap
<Constant
>(RHSConstant
)));
1149 LLVMValueRef
LLVMConstNUWSub(LLVMValueRef LHSConstant
,
1150 LLVMValueRef RHSConstant
) {
1151 return wrap(ConstantExpr::getNUWSub(unwrap
<Constant
>(LHSConstant
),
1152 unwrap
<Constant
>(RHSConstant
)));
1155 LLVMValueRef
LLVMConstFSub(LLVMValueRef LHSConstant
, LLVMValueRef RHSConstant
) {
1156 return wrap(ConstantExpr::getFSub(unwrap
<Constant
>(LHSConstant
),
1157 unwrap
<Constant
>(RHSConstant
)));
1160 LLVMValueRef
LLVMConstMul(LLVMValueRef LHSConstant
, LLVMValueRef RHSConstant
) {
1161 return wrap(ConstantExpr::getMul(unwrap
<Constant
>(LHSConstant
),
1162 unwrap
<Constant
>(RHSConstant
)));
1165 LLVMValueRef
LLVMConstNSWMul(LLVMValueRef LHSConstant
,
1166 LLVMValueRef RHSConstant
) {
1167 return wrap(ConstantExpr::getNSWMul(unwrap
<Constant
>(LHSConstant
),
1168 unwrap
<Constant
>(RHSConstant
)));
1171 LLVMValueRef
LLVMConstNUWMul(LLVMValueRef LHSConstant
,
1172 LLVMValueRef RHSConstant
) {
1173 return wrap(ConstantExpr::getNUWMul(unwrap
<Constant
>(LHSConstant
),
1174 unwrap
<Constant
>(RHSConstant
)));
1177 LLVMValueRef
LLVMConstFMul(LLVMValueRef LHSConstant
, LLVMValueRef RHSConstant
) {
1178 return wrap(ConstantExpr::getFMul(unwrap
<Constant
>(LHSConstant
),
1179 unwrap
<Constant
>(RHSConstant
)));
1182 LLVMValueRef
LLVMConstUDiv(LLVMValueRef LHSConstant
, LLVMValueRef RHSConstant
) {
1183 return wrap(ConstantExpr::getUDiv(unwrap
<Constant
>(LHSConstant
),
1184 unwrap
<Constant
>(RHSConstant
)));
1187 LLVMValueRef
LLVMConstExactUDiv(LLVMValueRef LHSConstant
,
1188 LLVMValueRef RHSConstant
) {
1189 return wrap(ConstantExpr::getExactUDiv(unwrap
<Constant
>(LHSConstant
),
1190 unwrap
<Constant
>(RHSConstant
)));
1193 LLVMValueRef
LLVMConstSDiv(LLVMValueRef LHSConstant
, LLVMValueRef RHSConstant
) {
1194 return wrap(ConstantExpr::getSDiv(unwrap
<Constant
>(LHSConstant
),
1195 unwrap
<Constant
>(RHSConstant
)));
1198 LLVMValueRef
LLVMConstExactSDiv(LLVMValueRef LHSConstant
,
1199 LLVMValueRef RHSConstant
) {
1200 return wrap(ConstantExpr::getExactSDiv(unwrap
<Constant
>(LHSConstant
),
1201 unwrap
<Constant
>(RHSConstant
)));
1204 LLVMValueRef
LLVMConstFDiv(LLVMValueRef LHSConstant
, LLVMValueRef RHSConstant
) {
1205 return wrap(ConstantExpr::getFDiv(unwrap
<Constant
>(LHSConstant
),
1206 unwrap
<Constant
>(RHSConstant
)));
1209 LLVMValueRef
LLVMConstURem(LLVMValueRef LHSConstant
, LLVMValueRef RHSConstant
) {
1210 return wrap(ConstantExpr::getURem(unwrap
<Constant
>(LHSConstant
),
1211 unwrap
<Constant
>(RHSConstant
)));
1214 LLVMValueRef
LLVMConstSRem(LLVMValueRef LHSConstant
, LLVMValueRef RHSConstant
) {
1215 return wrap(ConstantExpr::getSRem(unwrap
<Constant
>(LHSConstant
),
1216 unwrap
<Constant
>(RHSConstant
)));
1219 LLVMValueRef
LLVMConstFRem(LLVMValueRef LHSConstant
, LLVMValueRef RHSConstant
) {
1220 return wrap(ConstantExpr::getFRem(unwrap
<Constant
>(LHSConstant
),
1221 unwrap
<Constant
>(RHSConstant
)));
1224 LLVMValueRef
LLVMConstAnd(LLVMValueRef LHSConstant
, LLVMValueRef RHSConstant
) {
1225 return wrap(ConstantExpr::getAnd(unwrap
<Constant
>(LHSConstant
),
1226 unwrap
<Constant
>(RHSConstant
)));
1229 LLVMValueRef
LLVMConstOr(LLVMValueRef LHSConstant
, LLVMValueRef RHSConstant
) {
1230 return wrap(ConstantExpr::getOr(unwrap
<Constant
>(LHSConstant
),
1231 unwrap
<Constant
>(RHSConstant
)));
1234 LLVMValueRef
LLVMConstXor(LLVMValueRef LHSConstant
, LLVMValueRef RHSConstant
) {
1235 return wrap(ConstantExpr::getXor(unwrap
<Constant
>(LHSConstant
),
1236 unwrap
<Constant
>(RHSConstant
)));
1239 LLVMValueRef
LLVMConstICmp(LLVMIntPredicate Predicate
,
1240 LLVMValueRef LHSConstant
, LLVMValueRef RHSConstant
) {
1241 return wrap(ConstantExpr::getICmp(Predicate
,
1242 unwrap
<Constant
>(LHSConstant
),
1243 unwrap
<Constant
>(RHSConstant
)));
1246 LLVMValueRef
LLVMConstFCmp(LLVMRealPredicate Predicate
,
1247 LLVMValueRef LHSConstant
, LLVMValueRef RHSConstant
) {
1248 return wrap(ConstantExpr::getFCmp(Predicate
,
1249 unwrap
<Constant
>(LHSConstant
),
1250 unwrap
<Constant
>(RHSConstant
)));
1253 LLVMValueRef
LLVMConstShl(LLVMValueRef LHSConstant
, LLVMValueRef RHSConstant
) {
1254 return wrap(ConstantExpr::getShl(unwrap
<Constant
>(LHSConstant
),
1255 unwrap
<Constant
>(RHSConstant
)));
1258 LLVMValueRef
LLVMConstLShr(LLVMValueRef LHSConstant
, LLVMValueRef RHSConstant
) {
1259 return wrap(ConstantExpr::getLShr(unwrap
<Constant
>(LHSConstant
),
1260 unwrap
<Constant
>(RHSConstant
)));
1263 LLVMValueRef
LLVMConstAShr(LLVMValueRef LHSConstant
, LLVMValueRef RHSConstant
) {
1264 return wrap(ConstantExpr::getAShr(unwrap
<Constant
>(LHSConstant
),
1265 unwrap
<Constant
>(RHSConstant
)));
1268 LLVMValueRef
LLVMConstGEP(LLVMValueRef ConstantVal
,
1269 LLVMValueRef
*ConstantIndices
, unsigned NumIndices
) {
1270 ArrayRef
<Constant
*> IdxList(unwrap
<Constant
>(ConstantIndices
, NumIndices
),
1272 return wrap(ConstantExpr::getGetElementPtr(
1273 nullptr, unwrap
<Constant
>(ConstantVal
), IdxList
));
1276 LLVMValueRef
LLVMConstInBoundsGEP(LLVMValueRef ConstantVal
,
1277 LLVMValueRef
*ConstantIndices
,
1278 unsigned NumIndices
) {
1279 Constant
* Val
= unwrap
<Constant
>(ConstantVal
);
1280 ArrayRef
<Constant
*> IdxList(unwrap
<Constant
>(ConstantIndices
, NumIndices
),
1282 return wrap(ConstantExpr::getInBoundsGetElementPtr(nullptr, Val
, IdxList
));
1285 LLVMValueRef
LLVMConstTrunc(LLVMValueRef ConstantVal
, LLVMTypeRef ToType
) {
1286 return wrap(ConstantExpr::getTrunc(unwrap
<Constant
>(ConstantVal
),
1290 LLVMValueRef
LLVMConstSExt(LLVMValueRef ConstantVal
, LLVMTypeRef ToType
) {
1291 return wrap(ConstantExpr::getSExt(unwrap
<Constant
>(ConstantVal
),
1295 LLVMValueRef
LLVMConstZExt(LLVMValueRef ConstantVal
, LLVMTypeRef ToType
) {
1296 return wrap(ConstantExpr::getZExt(unwrap
<Constant
>(ConstantVal
),
1300 LLVMValueRef
LLVMConstFPTrunc(LLVMValueRef ConstantVal
, LLVMTypeRef ToType
) {
1301 return wrap(ConstantExpr::getFPTrunc(unwrap
<Constant
>(ConstantVal
),
1305 LLVMValueRef
LLVMConstFPExt(LLVMValueRef ConstantVal
, LLVMTypeRef ToType
) {
1306 return wrap(ConstantExpr::getFPExtend(unwrap
<Constant
>(ConstantVal
),
1310 LLVMValueRef
LLVMConstUIToFP(LLVMValueRef ConstantVal
, LLVMTypeRef ToType
) {
1311 return wrap(ConstantExpr::getUIToFP(unwrap
<Constant
>(ConstantVal
),
1315 LLVMValueRef
LLVMConstSIToFP(LLVMValueRef ConstantVal
, LLVMTypeRef ToType
) {
1316 return wrap(ConstantExpr::getSIToFP(unwrap
<Constant
>(ConstantVal
),
1320 LLVMValueRef
LLVMConstFPToUI(LLVMValueRef ConstantVal
, LLVMTypeRef ToType
) {
1321 return wrap(ConstantExpr::getFPToUI(unwrap
<Constant
>(ConstantVal
),
1325 LLVMValueRef
LLVMConstFPToSI(LLVMValueRef ConstantVal
, LLVMTypeRef ToType
) {
1326 return wrap(ConstantExpr::getFPToSI(unwrap
<Constant
>(ConstantVal
),
1330 LLVMValueRef
LLVMConstPtrToInt(LLVMValueRef ConstantVal
, LLVMTypeRef ToType
) {
1331 return wrap(ConstantExpr::getPtrToInt(unwrap
<Constant
>(ConstantVal
),
1335 LLVMValueRef
LLVMConstIntToPtr(LLVMValueRef ConstantVal
, LLVMTypeRef ToType
) {
1336 return wrap(ConstantExpr::getIntToPtr(unwrap
<Constant
>(ConstantVal
),
1340 LLVMValueRef
LLVMConstBitCast(LLVMValueRef ConstantVal
, LLVMTypeRef ToType
) {
1341 return wrap(ConstantExpr::getBitCast(unwrap
<Constant
>(ConstantVal
),
1345 LLVMValueRef
LLVMConstAddrSpaceCast(LLVMValueRef ConstantVal
,
1346 LLVMTypeRef ToType
) {
1347 return wrap(ConstantExpr::getAddrSpaceCast(unwrap
<Constant
>(ConstantVal
),
1351 LLVMValueRef
LLVMConstZExtOrBitCast(LLVMValueRef ConstantVal
,
1352 LLVMTypeRef ToType
) {
1353 return wrap(ConstantExpr::getZExtOrBitCast(unwrap
<Constant
>(ConstantVal
),
1357 LLVMValueRef
LLVMConstSExtOrBitCast(LLVMValueRef ConstantVal
,
1358 LLVMTypeRef ToType
) {
1359 return wrap(ConstantExpr::getSExtOrBitCast(unwrap
<Constant
>(ConstantVal
),
1363 LLVMValueRef
LLVMConstTruncOrBitCast(LLVMValueRef ConstantVal
,
1364 LLVMTypeRef ToType
) {
1365 return wrap(ConstantExpr::getTruncOrBitCast(unwrap
<Constant
>(ConstantVal
),
1369 LLVMValueRef
LLVMConstPointerCast(LLVMValueRef ConstantVal
,
1370 LLVMTypeRef ToType
) {
1371 return wrap(ConstantExpr::getPointerCast(unwrap
<Constant
>(ConstantVal
),
1375 LLVMValueRef
LLVMConstIntCast(LLVMValueRef ConstantVal
, LLVMTypeRef ToType
,
1376 LLVMBool isSigned
) {
1377 return wrap(ConstantExpr::getIntegerCast(unwrap
<Constant
>(ConstantVal
),
1378 unwrap(ToType
), isSigned
));
1381 LLVMValueRef
LLVMConstFPCast(LLVMValueRef ConstantVal
, LLVMTypeRef ToType
) {
1382 return wrap(ConstantExpr::getFPCast(unwrap
<Constant
>(ConstantVal
),
1386 LLVMValueRef
LLVMConstSelect(LLVMValueRef ConstantCondition
,
1387 LLVMValueRef ConstantIfTrue
,
1388 LLVMValueRef ConstantIfFalse
) {
1389 return wrap(ConstantExpr::getSelect(unwrap
<Constant
>(ConstantCondition
),
1390 unwrap
<Constant
>(ConstantIfTrue
),
1391 unwrap
<Constant
>(ConstantIfFalse
)));
1394 LLVMValueRef
LLVMConstExtractElement(LLVMValueRef VectorConstant
,
1395 LLVMValueRef IndexConstant
) {
1396 return wrap(ConstantExpr::getExtractElement(unwrap
<Constant
>(VectorConstant
),
1397 unwrap
<Constant
>(IndexConstant
)));
1400 LLVMValueRef
LLVMConstInsertElement(LLVMValueRef VectorConstant
,
1401 LLVMValueRef ElementValueConstant
,
1402 LLVMValueRef IndexConstant
) {
1403 return wrap(ConstantExpr::getInsertElement(unwrap
<Constant
>(VectorConstant
),
1404 unwrap
<Constant
>(ElementValueConstant
),
1405 unwrap
<Constant
>(IndexConstant
)));
1408 LLVMValueRef
LLVMConstShuffleVector(LLVMValueRef VectorAConstant
,
1409 LLVMValueRef VectorBConstant
,
1410 LLVMValueRef MaskConstant
) {
1411 return wrap(ConstantExpr::getShuffleVector(unwrap
<Constant
>(VectorAConstant
),
1412 unwrap
<Constant
>(VectorBConstant
),
1413 unwrap
<Constant
>(MaskConstant
)));
1416 LLVMValueRef
LLVMConstExtractValue(LLVMValueRef AggConstant
, unsigned *IdxList
,
1418 return wrap(ConstantExpr::getExtractValue(unwrap
<Constant
>(AggConstant
),
1419 makeArrayRef(IdxList
, NumIdx
)));
1422 LLVMValueRef
LLVMConstInsertValue(LLVMValueRef AggConstant
,
1423 LLVMValueRef ElementValueConstant
,
1424 unsigned *IdxList
, unsigned NumIdx
) {
1425 return wrap(ConstantExpr::getInsertValue(unwrap
<Constant
>(AggConstant
),
1426 unwrap
<Constant
>(ElementValueConstant
),
1427 makeArrayRef(IdxList
, NumIdx
)));
1430 LLVMValueRef
LLVMConstInlineAsm(LLVMTypeRef Ty
, const char *AsmString
,
1431 const char *Constraints
,
1432 LLVMBool HasSideEffects
,
1433 LLVMBool IsAlignStack
) {
1434 return wrap(InlineAsm::get(dyn_cast
<FunctionType
>(unwrap(Ty
)), AsmString
,
1435 Constraints
, HasSideEffects
, IsAlignStack
));
1438 LLVMValueRef
LLVMBlockAddress(LLVMValueRef F
, LLVMBasicBlockRef BB
) {
1439 return wrap(BlockAddress::get(unwrap
<Function
>(F
), unwrap(BB
)));
1442 /*--.. Operations on global variables, functions, and aliases (globals) ....--*/
1444 LLVMModuleRef
LLVMGetGlobalParent(LLVMValueRef Global
) {
1445 return wrap(unwrap
<GlobalValue
>(Global
)->getParent());
1448 LLVMBool
LLVMIsDeclaration(LLVMValueRef Global
) {
1449 return unwrap
<GlobalValue
>(Global
)->isDeclaration();
1452 LLVMLinkage
LLVMGetLinkage(LLVMValueRef Global
) {
1453 switch (unwrap
<GlobalValue
>(Global
)->getLinkage()) {
1454 case GlobalValue::ExternalLinkage
:
1455 return LLVMExternalLinkage
;
1456 case GlobalValue::AvailableExternallyLinkage
:
1457 return LLVMAvailableExternallyLinkage
;
1458 case GlobalValue::LinkOnceAnyLinkage
:
1459 return LLVMLinkOnceAnyLinkage
;
1460 case GlobalValue::LinkOnceODRLinkage
:
1461 return LLVMLinkOnceODRLinkage
;
1462 case GlobalValue::WeakAnyLinkage
:
1463 return LLVMWeakAnyLinkage
;
1464 case GlobalValue::WeakODRLinkage
:
1465 return LLVMWeakODRLinkage
;
1466 case GlobalValue::AppendingLinkage
:
1467 return LLVMAppendingLinkage
;
1468 case GlobalValue::InternalLinkage
:
1469 return LLVMInternalLinkage
;
1470 case GlobalValue::PrivateLinkage
:
1471 return LLVMPrivateLinkage
;
1472 case GlobalValue::ExternalWeakLinkage
:
1473 return LLVMExternalWeakLinkage
;
1474 case GlobalValue::CommonLinkage
:
1475 return LLVMCommonLinkage
;
1478 llvm_unreachable("Invalid GlobalValue linkage!");
1481 void LLVMSetLinkage(LLVMValueRef Global
, LLVMLinkage Linkage
) {
1482 GlobalValue
*GV
= unwrap
<GlobalValue
>(Global
);
1485 case LLVMExternalLinkage
:
1486 GV
->setLinkage(GlobalValue::ExternalLinkage
);
1488 case LLVMAvailableExternallyLinkage
:
1489 GV
->setLinkage(GlobalValue::AvailableExternallyLinkage
);
1491 case LLVMLinkOnceAnyLinkage
:
1492 GV
->setLinkage(GlobalValue::LinkOnceAnyLinkage
);
1494 case LLVMLinkOnceODRLinkage
:
1495 GV
->setLinkage(GlobalValue::LinkOnceODRLinkage
);
1497 case LLVMLinkOnceODRAutoHideLinkage
:
1498 DEBUG(errs() << "LLVMSetLinkage(): LLVMLinkOnceODRAutoHideLinkage is no "
1499 "longer supported.");
1501 case LLVMWeakAnyLinkage
:
1502 GV
->setLinkage(GlobalValue::WeakAnyLinkage
);
1504 case LLVMWeakODRLinkage
:
1505 GV
->setLinkage(GlobalValue::WeakODRLinkage
);
1507 case LLVMAppendingLinkage
:
1508 GV
->setLinkage(GlobalValue::AppendingLinkage
);
1510 case LLVMInternalLinkage
:
1511 GV
->setLinkage(GlobalValue::InternalLinkage
);
1513 case LLVMPrivateLinkage
:
1514 GV
->setLinkage(GlobalValue::PrivateLinkage
);
1516 case LLVMLinkerPrivateLinkage
:
1517 GV
->setLinkage(GlobalValue::PrivateLinkage
);
1519 case LLVMLinkerPrivateWeakLinkage
:
1520 GV
->setLinkage(GlobalValue::PrivateLinkage
);
1522 case LLVMDLLImportLinkage
:
1524 << "LLVMSetLinkage(): LLVMDLLImportLinkage is no longer supported.");
1526 case LLVMDLLExportLinkage
:
1528 << "LLVMSetLinkage(): LLVMDLLExportLinkage is no longer supported.");
1530 case LLVMExternalWeakLinkage
:
1531 GV
->setLinkage(GlobalValue::ExternalWeakLinkage
);
1533 case LLVMGhostLinkage
:
1535 << "LLVMSetLinkage(): LLVMGhostLinkage is no longer supported.");
1537 case LLVMCommonLinkage
:
1538 GV
->setLinkage(GlobalValue::CommonLinkage
);
1543 const char *LLVMGetSection(LLVMValueRef Global
) {
1544 // Using .data() is safe because of how GlobalObject::setSection is
1546 return unwrap
<GlobalValue
>(Global
)->getSection().data();
1549 void LLVMSetSection(LLVMValueRef Global
, const char *Section
) {
1550 unwrap
<GlobalObject
>(Global
)->setSection(Section
);
1553 LLVMVisibility
LLVMGetVisibility(LLVMValueRef Global
) {
1554 return static_cast<LLVMVisibility
>(
1555 unwrap
<GlobalValue
>(Global
)->getVisibility());
1558 void LLVMSetVisibility(LLVMValueRef Global
, LLVMVisibility Viz
) {
1559 unwrap
<GlobalValue
>(Global
)
1560 ->setVisibility(static_cast<GlobalValue::VisibilityTypes
>(Viz
));
1563 LLVMDLLStorageClass
LLVMGetDLLStorageClass(LLVMValueRef Global
) {
1564 return static_cast<LLVMDLLStorageClass
>(
1565 unwrap
<GlobalValue
>(Global
)->getDLLStorageClass());
1568 void LLVMSetDLLStorageClass(LLVMValueRef Global
, LLVMDLLStorageClass Class
) {
1569 unwrap
<GlobalValue
>(Global
)->setDLLStorageClass(
1570 static_cast<GlobalValue::DLLStorageClassTypes
>(Class
));
1573 LLVMBool
LLVMHasUnnamedAddr(LLVMValueRef Global
) {
1574 return unwrap
<GlobalValue
>(Global
)->hasGlobalUnnamedAddr();
1577 void LLVMSetUnnamedAddr(LLVMValueRef Global
, LLVMBool HasUnnamedAddr
) {
1578 unwrap
<GlobalValue
>(Global
)->setUnnamedAddr(
1579 HasUnnamedAddr
? GlobalValue::UnnamedAddr::Global
1580 : GlobalValue::UnnamedAddr::None
);
1583 /*--.. Operations on global variables, load and store instructions .........--*/
1585 unsigned LLVMGetAlignment(LLVMValueRef V
) {
1586 Value
*P
= unwrap
<Value
>(V
);
1587 if (GlobalValue
*GV
= dyn_cast
<GlobalValue
>(P
))
1588 return GV
->getAlignment();
1589 if (AllocaInst
*AI
= dyn_cast
<AllocaInst
>(P
))
1590 return AI
->getAlignment();
1591 if (LoadInst
*LI
= dyn_cast
<LoadInst
>(P
))
1592 return LI
->getAlignment();
1593 if (StoreInst
*SI
= dyn_cast
<StoreInst
>(P
))
1594 return SI
->getAlignment();
1597 "only GlobalValue, AllocaInst, LoadInst and StoreInst have alignment");
1600 void LLVMSetAlignment(LLVMValueRef V
, unsigned Bytes
) {
1601 Value
*P
= unwrap
<Value
>(V
);
1602 if (GlobalObject
*GV
= dyn_cast
<GlobalObject
>(P
))
1603 GV
->setAlignment(Bytes
);
1604 else if (AllocaInst
*AI
= dyn_cast
<AllocaInst
>(P
))
1605 AI
->setAlignment(Bytes
);
1606 else if (LoadInst
*LI
= dyn_cast
<LoadInst
>(P
))
1607 LI
->setAlignment(Bytes
);
1608 else if (StoreInst
*SI
= dyn_cast
<StoreInst
>(P
))
1609 SI
->setAlignment(Bytes
);
1612 "only GlobalValue, AllocaInst, LoadInst and StoreInst have alignment");
1615 /*--.. Operations on global variables ......................................--*/
1617 LLVMValueRef
LLVMAddGlobal(LLVMModuleRef M
, LLVMTypeRef Ty
, const char *Name
) {
1618 return wrap(new GlobalVariable(*unwrap(M
), unwrap(Ty
), false,
1619 GlobalValue::ExternalLinkage
, nullptr, Name
));
1622 LLVMValueRef
LLVMAddGlobalInAddressSpace(LLVMModuleRef M
, LLVMTypeRef Ty
,
1624 unsigned AddressSpace
) {
1625 return wrap(new GlobalVariable(*unwrap(M
), unwrap(Ty
), false,
1626 GlobalValue::ExternalLinkage
, nullptr, Name
,
1627 nullptr, GlobalVariable::NotThreadLocal
,
1631 LLVMValueRef
LLVMGetNamedGlobal(LLVMModuleRef M
, const char *Name
) {
1632 return wrap(unwrap(M
)->getNamedGlobal(Name
));
1635 LLVMValueRef
LLVMGetFirstGlobal(LLVMModuleRef M
) {
1636 Module
*Mod
= unwrap(M
);
1637 Module::global_iterator I
= Mod
->global_begin();
1638 if (I
== Mod
->global_end())
1643 LLVMValueRef
LLVMGetLastGlobal(LLVMModuleRef M
) {
1644 Module
*Mod
= unwrap(M
);
1645 Module::global_iterator I
= Mod
->global_end();
1646 if (I
== Mod
->global_begin())
1651 LLVMValueRef
LLVMGetNextGlobal(LLVMValueRef GlobalVar
) {
1652 GlobalVariable
*GV
= unwrap
<GlobalVariable
>(GlobalVar
);
1653 Module::global_iterator
I(GV
);
1654 if (++I
== GV
->getParent()->global_end())
1659 LLVMValueRef
LLVMGetPreviousGlobal(LLVMValueRef GlobalVar
) {
1660 GlobalVariable
*GV
= unwrap
<GlobalVariable
>(GlobalVar
);
1661 Module::global_iterator
I(GV
);
1662 if (I
== GV
->getParent()->global_begin())
1667 void LLVMDeleteGlobal(LLVMValueRef GlobalVar
) {
1668 unwrap
<GlobalVariable
>(GlobalVar
)->eraseFromParent();
1671 LLVMValueRef
LLVMGetInitializer(LLVMValueRef GlobalVar
) {
1672 GlobalVariable
* GV
= unwrap
<GlobalVariable
>(GlobalVar
);
1673 if ( !GV
->hasInitializer() )
1675 return wrap(GV
->getInitializer());
1678 void LLVMSetInitializer(LLVMValueRef GlobalVar
, LLVMValueRef ConstantVal
) {
1679 unwrap
<GlobalVariable
>(GlobalVar
)
1680 ->setInitializer(unwrap
<Constant
>(ConstantVal
));
1683 LLVMBool
LLVMIsThreadLocal(LLVMValueRef GlobalVar
) {
1684 return unwrap
<GlobalVariable
>(GlobalVar
)->isThreadLocal();
1687 void LLVMSetThreadLocal(LLVMValueRef GlobalVar
, LLVMBool IsThreadLocal
) {
1688 unwrap
<GlobalVariable
>(GlobalVar
)->setThreadLocal(IsThreadLocal
!= 0);
1691 LLVMBool
LLVMIsGlobalConstant(LLVMValueRef GlobalVar
) {
1692 return unwrap
<GlobalVariable
>(GlobalVar
)->isConstant();
1695 void LLVMSetGlobalConstant(LLVMValueRef GlobalVar
, LLVMBool IsConstant
) {
1696 unwrap
<GlobalVariable
>(GlobalVar
)->setConstant(IsConstant
!= 0);
1699 LLVMThreadLocalMode
LLVMGetThreadLocalMode(LLVMValueRef GlobalVar
) {
1700 switch (unwrap
<GlobalVariable
>(GlobalVar
)->getThreadLocalMode()) {
1701 case GlobalVariable::NotThreadLocal
:
1702 return LLVMNotThreadLocal
;
1703 case GlobalVariable::GeneralDynamicTLSModel
:
1704 return LLVMGeneralDynamicTLSModel
;
1705 case GlobalVariable::LocalDynamicTLSModel
:
1706 return LLVMLocalDynamicTLSModel
;
1707 case GlobalVariable::InitialExecTLSModel
:
1708 return LLVMInitialExecTLSModel
;
1709 case GlobalVariable::LocalExecTLSModel
:
1710 return LLVMLocalExecTLSModel
;
1713 llvm_unreachable("Invalid GlobalVariable thread local mode");
1716 void LLVMSetThreadLocalMode(LLVMValueRef GlobalVar
, LLVMThreadLocalMode Mode
) {
1717 GlobalVariable
*GV
= unwrap
<GlobalVariable
>(GlobalVar
);
1720 case LLVMNotThreadLocal
:
1721 GV
->setThreadLocalMode(GlobalVariable::NotThreadLocal
);
1723 case LLVMGeneralDynamicTLSModel
:
1724 GV
->setThreadLocalMode(GlobalVariable::GeneralDynamicTLSModel
);
1726 case LLVMLocalDynamicTLSModel
:
1727 GV
->setThreadLocalMode(GlobalVariable::LocalDynamicTLSModel
);
1729 case LLVMInitialExecTLSModel
:
1730 GV
->setThreadLocalMode(GlobalVariable::InitialExecTLSModel
);
1732 case LLVMLocalExecTLSModel
:
1733 GV
->setThreadLocalMode(GlobalVariable::LocalExecTLSModel
);
1738 LLVMBool
LLVMIsExternallyInitialized(LLVMValueRef GlobalVar
) {
1739 return unwrap
<GlobalVariable
>(GlobalVar
)->isExternallyInitialized();
1742 void LLVMSetExternallyInitialized(LLVMValueRef GlobalVar
, LLVMBool IsExtInit
) {
1743 unwrap
<GlobalVariable
>(GlobalVar
)->setExternallyInitialized(IsExtInit
);
1746 /*--.. Operations on aliases ......................................--*/
1748 LLVMValueRef
LLVMAddAlias(LLVMModuleRef M
, LLVMTypeRef Ty
, LLVMValueRef Aliasee
,
1750 auto *PTy
= cast
<PointerType
>(unwrap(Ty
));
1751 return wrap(GlobalAlias::create(PTy
->getElementType(), PTy
->getAddressSpace(),
1752 GlobalValue::ExternalLinkage
, Name
,
1753 unwrap
<Constant
>(Aliasee
), unwrap(M
)));
1756 /*--.. Operations on functions .............................................--*/
1758 LLVMValueRef
LLVMAddFunction(LLVMModuleRef M
, const char *Name
,
1759 LLVMTypeRef FunctionTy
) {
1760 return wrap(Function::Create(unwrap
<FunctionType
>(FunctionTy
),
1761 GlobalValue::ExternalLinkage
, Name
, unwrap(M
)));
1764 LLVMValueRef
LLVMGetNamedFunction(LLVMModuleRef M
, const char *Name
) {
1765 return wrap(unwrap(M
)->getFunction(Name
));
1768 LLVMValueRef
LLVMGetFirstFunction(LLVMModuleRef M
) {
1769 Module
*Mod
= unwrap(M
);
1770 Module::iterator I
= Mod
->begin();
1771 if (I
== Mod
->end())
1776 LLVMValueRef
LLVMGetLastFunction(LLVMModuleRef M
) {
1777 Module
*Mod
= unwrap(M
);
1778 Module::iterator I
= Mod
->end();
1779 if (I
== Mod
->begin())
1784 LLVMValueRef
LLVMGetNextFunction(LLVMValueRef Fn
) {
1785 Function
*Func
= unwrap
<Function
>(Fn
);
1786 Module::iterator
I(Func
);
1787 if (++I
== Func
->getParent()->end())
1792 LLVMValueRef
LLVMGetPreviousFunction(LLVMValueRef Fn
) {
1793 Function
*Func
= unwrap
<Function
>(Fn
);
1794 Module::iterator
I(Func
);
1795 if (I
== Func
->getParent()->begin())
1800 void LLVMDeleteFunction(LLVMValueRef Fn
) {
1801 unwrap
<Function
>(Fn
)->eraseFromParent();
1804 LLVMBool
LLVMHasPersonalityFn(LLVMValueRef Fn
) {
1805 return unwrap
<Function
>(Fn
)->hasPersonalityFn();
1808 LLVMValueRef
LLVMGetPersonalityFn(LLVMValueRef Fn
) {
1809 return wrap(unwrap
<Function
>(Fn
)->getPersonalityFn());
1812 void LLVMSetPersonalityFn(LLVMValueRef Fn
, LLVMValueRef PersonalityFn
) {
1813 unwrap
<Function
>(Fn
)->setPersonalityFn(unwrap
<Constant
>(PersonalityFn
));
1816 unsigned LLVMGetIntrinsicID(LLVMValueRef Fn
) {
1817 if (Function
*F
= dyn_cast
<Function
>(unwrap(Fn
)))
1818 return F
->getIntrinsicID();
1822 unsigned LLVMGetFunctionCallConv(LLVMValueRef Fn
) {
1823 return unwrap
<Function
>(Fn
)->getCallingConv();
1826 void LLVMSetFunctionCallConv(LLVMValueRef Fn
, unsigned CC
) {
1827 return unwrap
<Function
>(Fn
)->setCallingConv(
1828 static_cast<CallingConv::ID
>(CC
));
1831 const char *LLVMGetGC(LLVMValueRef Fn
) {
1832 Function
*F
= unwrap
<Function
>(Fn
);
1833 return F
->hasGC()? F
->getGC().c_str() : nullptr;
1836 void LLVMSetGC(LLVMValueRef Fn
, const char *GC
) {
1837 Function
*F
= unwrap
<Function
>(Fn
);
1844 void LLVMAddAttributeAtIndex(LLVMValueRef F
, LLVMAttributeIndex Idx
,
1845 LLVMAttributeRef A
) {
1846 unwrap
<Function
>(F
)->addAttribute(Idx
, unwrap(A
));
1849 unsigned LLVMGetAttributeCountAtIndex(LLVMValueRef F
, LLVMAttributeIndex Idx
) {
1850 auto *ASN
= AttributeSetNode::get(unwrap
<Function
>(F
)->getAttributes(), Idx
);
1853 return ASN
->getNumAttributes();
1856 void LLVMGetAttributesAtIndex(LLVMValueRef F
, LLVMAttributeIndex Idx
,
1857 LLVMAttributeRef
*Attrs
) {
1858 auto *ASN
= AttributeSetNode::get(unwrap
<Function
>(F
)->getAttributes(), Idx
);
1861 for (auto A
: make_range(ASN
->begin(), ASN
->end()))
1865 LLVMAttributeRef
LLVMGetEnumAttributeAtIndex(LLVMValueRef F
,
1866 LLVMAttributeIndex Idx
,
1868 return wrap(unwrap
<Function
>(F
)->getAttribute(Idx
,
1869 (Attribute::AttrKind
)KindID
));
1872 LLVMAttributeRef
LLVMGetStringAttributeAtIndex(LLVMValueRef F
,
1873 LLVMAttributeIndex Idx
,
1874 const char *K
, unsigned KLen
) {
1875 return wrap(unwrap
<Function
>(F
)->getAttribute(Idx
, StringRef(K
, KLen
)));
1878 void LLVMRemoveEnumAttributeAtIndex(LLVMValueRef F
, LLVMAttributeIndex Idx
,
1880 unwrap
<Function
>(F
)->removeAttribute(Idx
, (Attribute::AttrKind
)KindID
);
1883 void LLVMRemoveStringAttributeAtIndex(LLVMValueRef F
, LLVMAttributeIndex Idx
,
1884 const char *K
, unsigned KLen
) {
1885 unwrap
<Function
>(F
)->removeAttribute(Idx
, StringRef(K
, KLen
));
1888 void LLVMAddTargetDependentFunctionAttr(LLVMValueRef Fn
, const char *A
,
1890 Function
*Func
= unwrap
<Function
>(Fn
);
1891 AttributeList::AttrIndex Idx
=
1892 AttributeList::AttrIndex(AttributeList::FunctionIndex
);
1895 B
.addAttribute(A
, V
);
1896 AttributeList Set
= AttributeList::get(Func
->getContext(), Idx
, B
);
1897 Func
->addAttributes(Idx
, Set
);
1900 /*--.. Operations on parameters ............................................--*/
1902 unsigned LLVMCountParams(LLVMValueRef FnRef
) {
1903 // This function is strictly redundant to
1904 // LLVMCountParamTypes(LLVMGetElementType(LLVMTypeOf(FnRef)))
1905 return unwrap
<Function
>(FnRef
)->arg_size();
1908 void LLVMGetParams(LLVMValueRef FnRef
, LLVMValueRef
*ParamRefs
) {
1909 Function
*Fn
= unwrap
<Function
>(FnRef
);
1910 for (Function::arg_iterator I
= Fn
->arg_begin(),
1911 E
= Fn
->arg_end(); I
!= E
; I
++)
1912 *ParamRefs
++ = wrap(&*I
);
1915 LLVMValueRef
LLVMGetParam(LLVMValueRef FnRef
, unsigned index
) {
1916 Function
*Fn
= unwrap
<Function
>(FnRef
);
1917 return wrap(&Fn
->arg_begin()[index
]);
1920 LLVMValueRef
LLVMGetParamParent(LLVMValueRef V
) {
1921 return wrap(unwrap
<Argument
>(V
)->getParent());
1924 LLVMValueRef
LLVMGetFirstParam(LLVMValueRef Fn
) {
1925 Function
*Func
= unwrap
<Function
>(Fn
);
1926 Function::arg_iterator I
= Func
->arg_begin();
1927 if (I
== Func
->arg_end())
1932 LLVMValueRef
LLVMGetLastParam(LLVMValueRef Fn
) {
1933 Function
*Func
= unwrap
<Function
>(Fn
);
1934 Function::arg_iterator I
= Func
->arg_end();
1935 if (I
== Func
->arg_begin())
1940 LLVMValueRef
LLVMGetNextParam(LLVMValueRef Arg
) {
1941 Argument
*A
= unwrap
<Argument
>(Arg
);
1942 Function
*Fn
= A
->getParent();
1943 if (A
->getArgNo() + 1 >= Fn
->arg_size())
1945 return wrap(&Fn
->arg_begin()[A
->getArgNo() + 1]);
1948 LLVMValueRef
LLVMGetPreviousParam(LLVMValueRef Arg
) {
1949 Argument
*A
= unwrap
<Argument
>(Arg
);
1950 if (A
->getArgNo() == 0)
1952 return wrap(&A
->getParent()->arg_begin()[A
->getArgNo() - 1]);
1955 void LLVMSetParamAlignment(LLVMValueRef Arg
, unsigned align
) {
1956 Argument
*A
= unwrap
<Argument
>(Arg
);
1958 B
.addAlignmentAttr(align
);
1959 A
->addAttr(AttributeList::get(A
->getContext(), A
->getArgNo() + 1, B
));
1962 /*--.. Operations on basic blocks ..........................................--*/
1964 LLVMValueRef
LLVMBasicBlockAsValue(LLVMBasicBlockRef BB
) {
1965 return wrap(static_cast<Value
*>(unwrap(BB
)));
1968 LLVMBool
LLVMValueIsBasicBlock(LLVMValueRef Val
) {
1969 return isa
<BasicBlock
>(unwrap(Val
));
1972 LLVMBasicBlockRef
LLVMValueAsBasicBlock(LLVMValueRef Val
) {
1973 return wrap(unwrap
<BasicBlock
>(Val
));
1976 const char *LLVMGetBasicBlockName(LLVMBasicBlockRef BB
) {
1977 return unwrap(BB
)->getName().data();
1980 LLVMValueRef
LLVMGetBasicBlockParent(LLVMBasicBlockRef BB
) {
1981 return wrap(unwrap(BB
)->getParent());
1984 LLVMValueRef
LLVMGetBasicBlockTerminator(LLVMBasicBlockRef BB
) {
1985 return wrap(unwrap(BB
)->getTerminator());
1988 unsigned LLVMCountBasicBlocks(LLVMValueRef FnRef
) {
1989 return unwrap
<Function
>(FnRef
)->size();
1992 void LLVMGetBasicBlocks(LLVMValueRef FnRef
, LLVMBasicBlockRef
*BasicBlocksRefs
){
1993 Function
*Fn
= unwrap
<Function
>(FnRef
);
1994 for (BasicBlock
&BB
: *Fn
)
1995 *BasicBlocksRefs
++ = wrap(&BB
);
1998 LLVMBasicBlockRef
LLVMGetEntryBasicBlock(LLVMValueRef Fn
) {
1999 return wrap(&unwrap
<Function
>(Fn
)->getEntryBlock());
2002 LLVMBasicBlockRef
LLVMGetFirstBasicBlock(LLVMValueRef Fn
) {
2003 Function
*Func
= unwrap
<Function
>(Fn
);
2004 Function::iterator I
= Func
->begin();
2005 if (I
== Func
->end())
2010 LLVMBasicBlockRef
LLVMGetLastBasicBlock(LLVMValueRef Fn
) {
2011 Function
*Func
= unwrap
<Function
>(Fn
);
2012 Function::iterator I
= Func
->end();
2013 if (I
== Func
->begin())
2018 LLVMBasicBlockRef
LLVMGetNextBasicBlock(LLVMBasicBlockRef BB
) {
2019 BasicBlock
*Block
= unwrap(BB
);
2020 Function::iterator
I(Block
);
2021 if (++I
== Block
->getParent()->end())
2026 LLVMBasicBlockRef
LLVMGetPreviousBasicBlock(LLVMBasicBlockRef BB
) {
2027 BasicBlock
*Block
= unwrap(BB
);
2028 Function::iterator
I(Block
);
2029 if (I
== Block
->getParent()->begin())
2034 LLVMBasicBlockRef
LLVMAppendBasicBlockInContext(LLVMContextRef C
,
2037 return wrap(BasicBlock::Create(*unwrap(C
), Name
, unwrap
<Function
>(FnRef
)));
2040 LLVMBasicBlockRef
LLVMAppendBasicBlock(LLVMValueRef FnRef
, const char *Name
) {
2041 return LLVMAppendBasicBlockInContext(LLVMGetGlobalContext(), FnRef
, Name
);
2044 LLVMBasicBlockRef
LLVMInsertBasicBlockInContext(LLVMContextRef C
,
2045 LLVMBasicBlockRef BBRef
,
2047 BasicBlock
*BB
= unwrap(BBRef
);
2048 return wrap(BasicBlock::Create(*unwrap(C
), Name
, BB
->getParent(), BB
));
2051 LLVMBasicBlockRef
LLVMInsertBasicBlock(LLVMBasicBlockRef BBRef
,
2053 return LLVMInsertBasicBlockInContext(LLVMGetGlobalContext(), BBRef
, Name
);
2056 void LLVMDeleteBasicBlock(LLVMBasicBlockRef BBRef
) {
2057 unwrap(BBRef
)->eraseFromParent();
2060 void LLVMRemoveBasicBlockFromParent(LLVMBasicBlockRef BBRef
) {
2061 unwrap(BBRef
)->removeFromParent();
2064 void LLVMMoveBasicBlockBefore(LLVMBasicBlockRef BB
, LLVMBasicBlockRef MovePos
) {
2065 unwrap(BB
)->moveBefore(unwrap(MovePos
));
2068 void LLVMMoveBasicBlockAfter(LLVMBasicBlockRef BB
, LLVMBasicBlockRef MovePos
) {
2069 unwrap(BB
)->moveAfter(unwrap(MovePos
));
2072 /*--.. Operations on instructions ..........................................--*/
2074 LLVMBasicBlockRef
LLVMGetInstructionParent(LLVMValueRef Inst
) {
2075 return wrap(unwrap
<Instruction
>(Inst
)->getParent());
2078 LLVMValueRef
LLVMGetFirstInstruction(LLVMBasicBlockRef BB
) {
2079 BasicBlock
*Block
= unwrap(BB
);
2080 BasicBlock::iterator I
= Block
->begin();
2081 if (I
== Block
->end())
2086 LLVMValueRef
LLVMGetLastInstruction(LLVMBasicBlockRef BB
) {
2087 BasicBlock
*Block
= unwrap(BB
);
2088 BasicBlock::iterator I
= Block
->end();
2089 if (I
== Block
->begin())
2094 LLVMValueRef
LLVMGetNextInstruction(LLVMValueRef Inst
) {
2095 Instruction
*Instr
= unwrap
<Instruction
>(Inst
);
2096 BasicBlock::iterator
I(Instr
);
2097 if (++I
== Instr
->getParent()->end())
2102 LLVMValueRef
LLVMGetPreviousInstruction(LLVMValueRef Inst
) {
2103 Instruction
*Instr
= unwrap
<Instruction
>(Inst
);
2104 BasicBlock::iterator
I(Instr
);
2105 if (I
== Instr
->getParent()->begin())
2110 void LLVMInstructionRemoveFromParent(LLVMValueRef Inst
) {
2111 unwrap
<Instruction
>(Inst
)->removeFromParent();
2114 void LLVMInstructionEraseFromParent(LLVMValueRef Inst
) {
2115 unwrap
<Instruction
>(Inst
)->eraseFromParent();
2118 LLVMIntPredicate
LLVMGetICmpPredicate(LLVMValueRef Inst
) {
2119 if (ICmpInst
*I
= dyn_cast
<ICmpInst
>(unwrap(Inst
)))
2120 return (LLVMIntPredicate
)I
->getPredicate();
2121 if (ConstantExpr
*CE
= dyn_cast
<ConstantExpr
>(unwrap(Inst
)))
2122 if (CE
->getOpcode() == Instruction::ICmp
)
2123 return (LLVMIntPredicate
)CE
->getPredicate();
2124 return (LLVMIntPredicate
)0;
2127 LLVMRealPredicate
LLVMGetFCmpPredicate(LLVMValueRef Inst
) {
2128 if (FCmpInst
*I
= dyn_cast
<FCmpInst
>(unwrap(Inst
)))
2129 return (LLVMRealPredicate
)I
->getPredicate();
2130 if (ConstantExpr
*CE
= dyn_cast
<ConstantExpr
>(unwrap(Inst
)))
2131 if (CE
->getOpcode() == Instruction::FCmp
)
2132 return (LLVMRealPredicate
)CE
->getPredicate();
2133 return (LLVMRealPredicate
)0;
2136 LLVMOpcode
LLVMGetInstructionOpcode(LLVMValueRef Inst
) {
2137 if (Instruction
*C
= dyn_cast
<Instruction
>(unwrap(Inst
)))
2138 return map_to_llvmopcode(C
->getOpcode());
2139 return (LLVMOpcode
)0;
2142 LLVMValueRef
LLVMInstructionClone(LLVMValueRef Inst
) {
2143 if (Instruction
*C
= dyn_cast
<Instruction
>(unwrap(Inst
)))
2144 return wrap(C
->clone());
2148 /*--.. Call and invoke instructions ........................................--*/
2150 unsigned LLVMGetNumArgOperands(LLVMValueRef Instr
) {
2151 return CallSite(unwrap
<Instruction
>(Instr
)).getNumArgOperands();
2154 unsigned LLVMGetInstructionCallConv(LLVMValueRef Instr
) {
2155 return CallSite(unwrap
<Instruction
>(Instr
)).getCallingConv();
2158 void LLVMSetInstructionCallConv(LLVMValueRef Instr
, unsigned CC
) {
2159 return CallSite(unwrap
<Instruction
>(Instr
))
2160 .setCallingConv(static_cast<CallingConv::ID
>(CC
));
2163 void LLVMSetInstrParamAlignment(LLVMValueRef Instr
, unsigned index
,
2165 CallSite Call
= CallSite(unwrap
<Instruction
>(Instr
));
2167 B
.addAlignmentAttr(align
);
2168 Call
.setAttributes(Call
.getAttributes().addAttributes(
2169 Call
->getContext(), index
,
2170 AttributeList::get(Call
->getContext(), index
, B
)));
2173 void LLVMAddCallSiteAttribute(LLVMValueRef C
, LLVMAttributeIndex Idx
,
2174 LLVMAttributeRef A
) {
2175 CallSite(unwrap
<Instruction
>(C
)).addAttribute(Idx
, unwrap(A
));
2178 unsigned LLVMGetCallSiteAttributeCount(LLVMValueRef C
,
2179 LLVMAttributeIndex Idx
) {
2180 auto CS
= CallSite(unwrap
<Instruction
>(C
));
2181 auto *ASN
= AttributeSetNode::get(CS
.getAttributes(), Idx
);
2184 return ASN
->getNumAttributes();
2187 void LLVMGetCallSiteAttributes(LLVMValueRef C
, LLVMAttributeIndex Idx
,
2188 LLVMAttributeRef
*Attrs
) {
2189 auto CS
= CallSite(unwrap
<Instruction
>(C
));
2190 auto *ASN
= AttributeSetNode::get(CS
.getAttributes(), Idx
);
2193 for (auto A
: make_range(ASN
->begin(), ASN
->end()))
2197 LLVMAttributeRef
LLVMGetCallSiteEnumAttribute(LLVMValueRef C
,
2198 LLVMAttributeIndex Idx
,
2200 return wrap(CallSite(unwrap
<Instruction
>(C
))
2201 .getAttribute(Idx
, (Attribute::AttrKind
)KindID
));
2204 LLVMAttributeRef
LLVMGetCallSiteStringAttribute(LLVMValueRef C
,
2205 LLVMAttributeIndex Idx
,
2206 const char *K
, unsigned KLen
) {
2207 return wrap(CallSite(unwrap
<Instruction
>(C
))
2208 .getAttribute(Idx
, StringRef(K
, KLen
)));
2211 void LLVMRemoveCallSiteEnumAttribute(LLVMValueRef C
, LLVMAttributeIndex Idx
,
2213 CallSite(unwrap
<Instruction
>(C
))
2214 .removeAttribute(Idx
, (Attribute::AttrKind
)KindID
);
2217 void LLVMRemoveCallSiteStringAttribute(LLVMValueRef C
, LLVMAttributeIndex Idx
,
2218 const char *K
, unsigned KLen
) {
2219 CallSite(unwrap
<Instruction
>(C
)).removeAttribute(Idx
, StringRef(K
, KLen
));
2222 LLVMValueRef
LLVMGetCalledValue(LLVMValueRef Instr
) {
2223 return wrap(CallSite(unwrap
<Instruction
>(Instr
)).getCalledValue());
2226 /*--.. Operations on call instructions (only) ..............................--*/
2228 LLVMBool
LLVMIsTailCall(LLVMValueRef Call
) {
2229 return unwrap
<CallInst
>(Call
)->isTailCall();
2232 void LLVMSetTailCall(LLVMValueRef Call
, LLVMBool isTailCall
) {
2233 unwrap
<CallInst
>(Call
)->setTailCall(isTailCall
);
2236 /*--.. Operations on invoke instructions (only) ............................--*/
2238 LLVMBasicBlockRef
LLVMGetNormalDest(LLVMValueRef Invoke
) {
2239 return wrap(unwrap
<InvokeInst
>(Invoke
)->getNormalDest());
2242 LLVMBasicBlockRef
LLVMGetUnwindDest(LLVMValueRef Invoke
) {
2243 return wrap(unwrap
<InvokeInst
>(Invoke
)->getUnwindDest());
2246 void LLVMSetNormalDest(LLVMValueRef Invoke
, LLVMBasicBlockRef B
) {
2247 unwrap
<InvokeInst
>(Invoke
)->setNormalDest(unwrap(B
));
2250 void LLVMSetUnwindDest(LLVMValueRef Invoke
, LLVMBasicBlockRef B
) {
2251 unwrap
<InvokeInst
>(Invoke
)->setUnwindDest(unwrap(B
));
2254 /*--.. Operations on terminators ...........................................--*/
2256 unsigned LLVMGetNumSuccessors(LLVMValueRef Term
) {
2257 return unwrap
<TerminatorInst
>(Term
)->getNumSuccessors();
2260 LLVMBasicBlockRef
LLVMGetSuccessor(LLVMValueRef Term
, unsigned i
) {
2261 return wrap(unwrap
<TerminatorInst
>(Term
)->getSuccessor(i
));
2264 void LLVMSetSuccessor(LLVMValueRef Term
, unsigned i
, LLVMBasicBlockRef block
) {
2265 return unwrap
<TerminatorInst
>(Term
)->setSuccessor(i
,unwrap(block
));
2268 /*--.. Operations on branch instructions (only) ............................--*/
2270 LLVMBool
LLVMIsConditional(LLVMValueRef Branch
) {
2271 return unwrap
<BranchInst
>(Branch
)->isConditional();
2274 LLVMValueRef
LLVMGetCondition(LLVMValueRef Branch
) {
2275 return wrap(unwrap
<BranchInst
>(Branch
)->getCondition());
2278 void LLVMSetCondition(LLVMValueRef Branch
, LLVMValueRef Cond
) {
2279 return unwrap
<BranchInst
>(Branch
)->setCondition(unwrap(Cond
));
2282 /*--.. Operations on switch instructions (only) ............................--*/
2284 LLVMBasicBlockRef
LLVMGetSwitchDefaultDest(LLVMValueRef Switch
) {
2285 return wrap(unwrap
<SwitchInst
>(Switch
)->getDefaultDest());
2288 /*--.. Operations on alloca instructions (only) ............................--*/
2290 LLVMTypeRef
LLVMGetAllocatedType(LLVMValueRef Alloca
) {
2291 return wrap(unwrap
<AllocaInst
>(Alloca
)->getAllocatedType());
2294 /*--.. Operations on gep instructions (only) ...............................--*/
2296 LLVMBool
LLVMIsInBounds(LLVMValueRef GEP
) {
2297 return unwrap
<GetElementPtrInst
>(GEP
)->isInBounds();
2300 void LLVMSetIsInBounds(LLVMValueRef GEP
, LLVMBool InBounds
) {
2301 return unwrap
<GetElementPtrInst
>(GEP
)->setIsInBounds(InBounds
);
2304 /*--.. Operations on phi nodes .............................................--*/
2306 void LLVMAddIncoming(LLVMValueRef PhiNode
, LLVMValueRef
*IncomingValues
,
2307 LLVMBasicBlockRef
*IncomingBlocks
, unsigned Count
) {
2308 PHINode
*PhiVal
= unwrap
<PHINode
>(PhiNode
);
2309 for (unsigned I
= 0; I
!= Count
; ++I
)
2310 PhiVal
->addIncoming(unwrap(IncomingValues
[I
]), unwrap(IncomingBlocks
[I
]));
2313 unsigned LLVMCountIncoming(LLVMValueRef PhiNode
) {
2314 return unwrap
<PHINode
>(PhiNode
)->getNumIncomingValues();
2317 LLVMValueRef
LLVMGetIncomingValue(LLVMValueRef PhiNode
, unsigned Index
) {
2318 return wrap(unwrap
<PHINode
>(PhiNode
)->getIncomingValue(Index
));
2321 LLVMBasicBlockRef
LLVMGetIncomingBlock(LLVMValueRef PhiNode
, unsigned Index
) {
2322 return wrap(unwrap
<PHINode
>(PhiNode
)->getIncomingBlock(Index
));
2325 /*--.. Operations on extractvalue and insertvalue nodes ....................--*/
2327 unsigned LLVMGetNumIndices(LLVMValueRef Inst
) {
2328 auto *I
= unwrap(Inst
);
2329 if (auto *GEP
= dyn_cast
<GetElementPtrInst
>(I
))
2330 return GEP
->getNumIndices();
2331 if (auto *EV
= dyn_cast
<ExtractValueInst
>(I
))
2332 return EV
->getNumIndices();
2333 if (auto *IV
= dyn_cast
<InsertValueInst
>(I
))
2334 return IV
->getNumIndices();
2336 "LLVMGetNumIndices applies only to extractvalue and insertvalue!");
2339 const unsigned *LLVMGetIndices(LLVMValueRef Inst
) {
2340 auto *I
= unwrap(Inst
);
2341 if (auto *EV
= dyn_cast
<ExtractValueInst
>(I
))
2342 return EV
->getIndices().data();
2343 if (auto *IV
= dyn_cast
<InsertValueInst
>(I
))
2344 return IV
->getIndices().data();
2346 "LLVMGetIndices applies only to extractvalue and insertvalue!");
2350 /*===-- Instruction builders ----------------------------------------------===*/
2352 LLVMBuilderRef
LLVMCreateBuilderInContext(LLVMContextRef C
) {
2353 return wrap(new IRBuilder
<>(*unwrap(C
)));
2356 LLVMBuilderRef
LLVMCreateBuilder(void) {
2357 return LLVMCreateBuilderInContext(LLVMGetGlobalContext());
2360 void LLVMPositionBuilder(LLVMBuilderRef Builder
, LLVMBasicBlockRef Block
,
2361 LLVMValueRef Instr
) {
2362 BasicBlock
*BB
= unwrap(Block
);
2363 auto I
= Instr
? unwrap
<Instruction
>(Instr
)->getIterator() : BB
->end();
2364 unwrap(Builder
)->SetInsertPoint(BB
, I
);
2367 void LLVMPositionBuilderBefore(LLVMBuilderRef Builder
, LLVMValueRef Instr
) {
2368 Instruction
*I
= unwrap
<Instruction
>(Instr
);
2369 unwrap(Builder
)->SetInsertPoint(I
->getParent(), I
->getIterator());
2372 void LLVMPositionBuilderAtEnd(LLVMBuilderRef Builder
, LLVMBasicBlockRef Block
) {
2373 BasicBlock
*BB
= unwrap(Block
);
2374 unwrap(Builder
)->SetInsertPoint(BB
);
2377 LLVMBasicBlockRef
LLVMGetInsertBlock(LLVMBuilderRef Builder
) {
2378 return wrap(unwrap(Builder
)->GetInsertBlock());
2381 void LLVMClearInsertionPosition(LLVMBuilderRef Builder
) {
2382 unwrap(Builder
)->ClearInsertionPoint();
2385 void LLVMInsertIntoBuilder(LLVMBuilderRef Builder
, LLVMValueRef Instr
) {
2386 unwrap(Builder
)->Insert(unwrap
<Instruction
>(Instr
));
2389 void LLVMInsertIntoBuilderWithName(LLVMBuilderRef Builder
, LLVMValueRef Instr
,
2391 unwrap(Builder
)->Insert(unwrap
<Instruction
>(Instr
), Name
);
2394 void LLVMDisposeBuilder(LLVMBuilderRef Builder
) {
2395 delete unwrap(Builder
);
2398 /*--.. Metadata builders ...................................................--*/
2400 void LLVMSetCurrentDebugLocation(LLVMBuilderRef Builder
, LLVMValueRef L
) {
2402 L
? cast
<MDNode
>(unwrap
<MetadataAsValue
>(L
)->getMetadata()) : nullptr;
2403 unwrap(Builder
)->SetCurrentDebugLocation(DebugLoc(Loc
));
2406 LLVMValueRef
LLVMGetCurrentDebugLocation(LLVMBuilderRef Builder
) {
2407 LLVMContext
&Context
= unwrap(Builder
)->getContext();
2408 return wrap(MetadataAsValue::get(
2409 Context
, unwrap(Builder
)->getCurrentDebugLocation().getAsMDNode()));
2412 void LLVMSetInstDebugLocation(LLVMBuilderRef Builder
, LLVMValueRef Inst
) {
2413 unwrap(Builder
)->SetInstDebugLocation(unwrap
<Instruction
>(Inst
));
2417 /*--.. Instruction builders ................................................--*/
2419 LLVMValueRef
LLVMBuildRetVoid(LLVMBuilderRef B
) {
2420 return wrap(unwrap(B
)->CreateRetVoid());
2423 LLVMValueRef
LLVMBuildRet(LLVMBuilderRef B
, LLVMValueRef V
) {
2424 return wrap(unwrap(B
)->CreateRet(unwrap(V
)));
2427 LLVMValueRef
LLVMBuildAggregateRet(LLVMBuilderRef B
, LLVMValueRef
*RetVals
,
2429 return wrap(unwrap(B
)->CreateAggregateRet(unwrap(RetVals
), N
));
2432 LLVMValueRef
LLVMBuildBr(LLVMBuilderRef B
, LLVMBasicBlockRef Dest
) {
2433 return wrap(unwrap(B
)->CreateBr(unwrap(Dest
)));
2436 LLVMValueRef
LLVMBuildCondBr(LLVMBuilderRef B
, LLVMValueRef If
,
2437 LLVMBasicBlockRef Then
, LLVMBasicBlockRef Else
) {
2438 return wrap(unwrap(B
)->CreateCondBr(unwrap(If
), unwrap(Then
), unwrap(Else
)));
2441 LLVMValueRef
LLVMBuildSwitch(LLVMBuilderRef B
, LLVMValueRef V
,
2442 LLVMBasicBlockRef Else
, unsigned NumCases
) {
2443 return wrap(unwrap(B
)->CreateSwitch(unwrap(V
), unwrap(Else
), NumCases
));
2446 LLVMValueRef
LLVMBuildIndirectBr(LLVMBuilderRef B
, LLVMValueRef Addr
,
2447 unsigned NumDests
) {
2448 return wrap(unwrap(B
)->CreateIndirectBr(unwrap(Addr
), NumDests
));
2451 LLVMValueRef
LLVMBuildInvoke(LLVMBuilderRef B
, LLVMValueRef Fn
,
2452 LLVMValueRef
*Args
, unsigned NumArgs
,
2453 LLVMBasicBlockRef Then
, LLVMBasicBlockRef Catch
,
2455 return wrap(unwrap(B
)->CreateInvoke(unwrap(Fn
), unwrap(Then
), unwrap(Catch
),
2456 makeArrayRef(unwrap(Args
), NumArgs
),
2460 LLVMValueRef
LLVMBuildLandingPad(LLVMBuilderRef B
, LLVMTypeRef Ty
,
2461 LLVMValueRef PersFn
, unsigned NumClauses
,
2463 // The personality used to live on the landingpad instruction, but now it
2464 // lives on the parent function. For compatibility, take the provided
2465 // personality and put it on the parent function.
2467 unwrap(B
)->GetInsertBlock()->getParent()->setPersonalityFn(
2468 cast
<Function
>(unwrap(PersFn
)));
2469 return wrap(unwrap(B
)->CreateLandingPad(unwrap(Ty
), NumClauses
, Name
));
2472 LLVMValueRef
LLVMBuildResume(LLVMBuilderRef B
, LLVMValueRef Exn
) {
2473 return wrap(unwrap(B
)->CreateResume(unwrap(Exn
)));
2476 LLVMValueRef
LLVMBuildUnreachable(LLVMBuilderRef B
) {
2477 return wrap(unwrap(B
)->CreateUnreachable());
2480 void LLVMAddCase(LLVMValueRef Switch
, LLVMValueRef OnVal
,
2481 LLVMBasicBlockRef Dest
) {
2482 unwrap
<SwitchInst
>(Switch
)->addCase(unwrap
<ConstantInt
>(OnVal
), unwrap(Dest
));
2485 void LLVMAddDestination(LLVMValueRef IndirectBr
, LLVMBasicBlockRef Dest
) {
2486 unwrap
<IndirectBrInst
>(IndirectBr
)->addDestination(unwrap(Dest
));
2489 unsigned LLVMGetNumClauses(LLVMValueRef LandingPad
) {
2490 return unwrap
<LandingPadInst
>(LandingPad
)->getNumClauses();
2493 LLVMValueRef
LLVMGetClause(LLVMValueRef LandingPad
, unsigned Idx
) {
2494 return wrap(unwrap
<LandingPadInst
>(LandingPad
)->getClause(Idx
));
2497 void LLVMAddClause(LLVMValueRef LandingPad
, LLVMValueRef ClauseVal
) {
2498 unwrap
<LandingPadInst
>(LandingPad
)->
2499 addClause(cast
<Constant
>(unwrap(ClauseVal
)));
2502 LLVMBool
LLVMIsCleanup(LLVMValueRef LandingPad
) {
2503 return unwrap
<LandingPadInst
>(LandingPad
)->isCleanup();
2506 void LLVMSetCleanup(LLVMValueRef LandingPad
, LLVMBool Val
) {
2507 unwrap
<LandingPadInst
>(LandingPad
)->setCleanup(Val
);
2510 /*--.. Arithmetic ..........................................................--*/
2512 LLVMValueRef
LLVMBuildAdd(LLVMBuilderRef B
, LLVMValueRef LHS
, LLVMValueRef RHS
,
2514 return wrap(unwrap(B
)->CreateAdd(unwrap(LHS
), unwrap(RHS
), Name
));
2517 LLVMValueRef
LLVMBuildNSWAdd(LLVMBuilderRef B
, LLVMValueRef LHS
, LLVMValueRef RHS
,
2519 return wrap(unwrap(B
)->CreateNSWAdd(unwrap(LHS
), unwrap(RHS
), Name
));
2522 LLVMValueRef
LLVMBuildNUWAdd(LLVMBuilderRef B
, LLVMValueRef LHS
, LLVMValueRef RHS
,
2524 return wrap(unwrap(B
)->CreateNUWAdd(unwrap(LHS
), unwrap(RHS
), Name
));
2527 LLVMValueRef
LLVMBuildFAdd(LLVMBuilderRef B
, LLVMValueRef LHS
, LLVMValueRef RHS
,
2529 return wrap(unwrap(B
)->CreateFAdd(unwrap(LHS
), unwrap(RHS
), Name
));
2532 LLVMValueRef
LLVMBuildSub(LLVMBuilderRef B
, LLVMValueRef LHS
, LLVMValueRef RHS
,
2534 return wrap(unwrap(B
)->CreateSub(unwrap(LHS
), unwrap(RHS
), Name
));
2537 LLVMValueRef
LLVMBuildNSWSub(LLVMBuilderRef B
, LLVMValueRef LHS
, LLVMValueRef RHS
,
2539 return wrap(unwrap(B
)->CreateNSWSub(unwrap(LHS
), unwrap(RHS
), Name
));
2542 LLVMValueRef
LLVMBuildNUWSub(LLVMBuilderRef B
, LLVMValueRef LHS
, LLVMValueRef RHS
,
2544 return wrap(unwrap(B
)->CreateNUWSub(unwrap(LHS
), unwrap(RHS
), Name
));
2547 LLVMValueRef
LLVMBuildFSub(LLVMBuilderRef B
, LLVMValueRef LHS
, LLVMValueRef RHS
,
2549 return wrap(unwrap(B
)->CreateFSub(unwrap(LHS
), unwrap(RHS
), Name
));
2552 LLVMValueRef
LLVMBuildMul(LLVMBuilderRef B
, LLVMValueRef LHS
, LLVMValueRef RHS
,
2554 return wrap(unwrap(B
)->CreateMul(unwrap(LHS
), unwrap(RHS
), Name
));
2557 LLVMValueRef
LLVMBuildNSWMul(LLVMBuilderRef B
, LLVMValueRef LHS
, LLVMValueRef RHS
,
2559 return wrap(unwrap(B
)->CreateNSWMul(unwrap(LHS
), unwrap(RHS
), Name
));
2562 LLVMValueRef
LLVMBuildNUWMul(LLVMBuilderRef B
, LLVMValueRef LHS
, LLVMValueRef RHS
,
2564 return wrap(unwrap(B
)->CreateNUWMul(unwrap(LHS
), unwrap(RHS
), Name
));
2567 LLVMValueRef
LLVMBuildFMul(LLVMBuilderRef B
, LLVMValueRef LHS
, LLVMValueRef RHS
,
2569 return wrap(unwrap(B
)->CreateFMul(unwrap(LHS
), unwrap(RHS
), Name
));
2572 LLVMValueRef
LLVMBuildUDiv(LLVMBuilderRef B
, LLVMValueRef LHS
, LLVMValueRef RHS
,
2574 return wrap(unwrap(B
)->CreateUDiv(unwrap(LHS
), unwrap(RHS
), Name
));
2577 LLVMValueRef
LLVMBuildExactUDiv(LLVMBuilderRef B
, LLVMValueRef LHS
,
2578 LLVMValueRef RHS
, const char *Name
) {
2579 return wrap(unwrap(B
)->CreateExactUDiv(unwrap(LHS
), unwrap(RHS
), Name
));
2582 LLVMValueRef
LLVMBuildSDiv(LLVMBuilderRef B
, LLVMValueRef LHS
, LLVMValueRef RHS
,
2584 return wrap(unwrap(B
)->CreateSDiv(unwrap(LHS
), unwrap(RHS
), Name
));
2587 LLVMValueRef
LLVMBuildExactSDiv(LLVMBuilderRef B
, LLVMValueRef LHS
,
2588 LLVMValueRef RHS
, const char *Name
) {
2589 return wrap(unwrap(B
)->CreateExactSDiv(unwrap(LHS
), unwrap(RHS
), Name
));
2592 LLVMValueRef
LLVMBuildFDiv(LLVMBuilderRef B
, LLVMValueRef LHS
, LLVMValueRef RHS
,
2594 return wrap(unwrap(B
)->CreateFDiv(unwrap(LHS
), unwrap(RHS
), Name
));
2597 LLVMValueRef
LLVMBuildURem(LLVMBuilderRef B
, LLVMValueRef LHS
, LLVMValueRef RHS
,
2599 return wrap(unwrap(B
)->CreateURem(unwrap(LHS
), unwrap(RHS
), Name
));
2602 LLVMValueRef
LLVMBuildSRem(LLVMBuilderRef B
, LLVMValueRef LHS
, LLVMValueRef RHS
,
2604 return wrap(unwrap(B
)->CreateSRem(unwrap(LHS
), unwrap(RHS
), Name
));
2607 LLVMValueRef
LLVMBuildFRem(LLVMBuilderRef B
, LLVMValueRef LHS
, LLVMValueRef RHS
,
2609 return wrap(unwrap(B
)->CreateFRem(unwrap(LHS
), unwrap(RHS
), Name
));
2612 LLVMValueRef
LLVMBuildShl(LLVMBuilderRef B
, LLVMValueRef LHS
, LLVMValueRef RHS
,
2614 return wrap(unwrap(B
)->CreateShl(unwrap(LHS
), unwrap(RHS
), Name
));
2617 LLVMValueRef
LLVMBuildLShr(LLVMBuilderRef B
, LLVMValueRef LHS
, LLVMValueRef RHS
,
2619 return wrap(unwrap(B
)->CreateLShr(unwrap(LHS
), unwrap(RHS
), Name
));
2622 LLVMValueRef
LLVMBuildAShr(LLVMBuilderRef B
, LLVMValueRef LHS
, LLVMValueRef RHS
,
2624 return wrap(unwrap(B
)->CreateAShr(unwrap(LHS
), unwrap(RHS
), Name
));
2627 LLVMValueRef
LLVMBuildAnd(LLVMBuilderRef B
, LLVMValueRef LHS
, LLVMValueRef RHS
,
2629 return wrap(unwrap(B
)->CreateAnd(unwrap(LHS
), unwrap(RHS
), Name
));
2632 LLVMValueRef
LLVMBuildOr(LLVMBuilderRef B
, LLVMValueRef LHS
, LLVMValueRef RHS
,
2634 return wrap(unwrap(B
)->CreateOr(unwrap(LHS
), unwrap(RHS
), Name
));
2637 LLVMValueRef
LLVMBuildXor(LLVMBuilderRef B
, LLVMValueRef LHS
, LLVMValueRef RHS
,
2639 return wrap(unwrap(B
)->CreateXor(unwrap(LHS
), unwrap(RHS
), Name
));
2642 LLVMValueRef
LLVMBuildBinOp(LLVMBuilderRef B
, LLVMOpcode Op
,
2643 LLVMValueRef LHS
, LLVMValueRef RHS
,
2645 return wrap(unwrap(B
)->CreateBinOp(Instruction::BinaryOps(map_from_llvmopcode(Op
)), unwrap(LHS
),
2646 unwrap(RHS
), Name
));
2649 LLVMValueRef
LLVMBuildNeg(LLVMBuilderRef B
, LLVMValueRef V
, const char *Name
) {
2650 return wrap(unwrap(B
)->CreateNeg(unwrap(V
), Name
));
2653 LLVMValueRef
LLVMBuildNSWNeg(LLVMBuilderRef B
, LLVMValueRef V
,
2655 return wrap(unwrap(B
)->CreateNSWNeg(unwrap(V
), Name
));
2658 LLVMValueRef
LLVMBuildNUWNeg(LLVMBuilderRef B
, LLVMValueRef V
,
2660 return wrap(unwrap(B
)->CreateNUWNeg(unwrap(V
), Name
));
2663 LLVMValueRef
LLVMBuildFNeg(LLVMBuilderRef B
, LLVMValueRef V
, const char *Name
) {
2664 return wrap(unwrap(B
)->CreateFNeg(unwrap(V
), Name
));
2667 LLVMValueRef
LLVMBuildNot(LLVMBuilderRef B
, LLVMValueRef V
, const char *Name
) {
2668 return wrap(unwrap(B
)->CreateNot(unwrap(V
), Name
));
2671 /*--.. Memory ..............................................................--*/
2673 LLVMValueRef
LLVMBuildMalloc(LLVMBuilderRef B
, LLVMTypeRef Ty
,
2675 Type
* ITy
= Type::getInt32Ty(unwrap(B
)->GetInsertBlock()->getContext());
2676 Constant
* AllocSize
= ConstantExpr::getSizeOf(unwrap(Ty
));
2677 AllocSize
= ConstantExpr::getTruncOrBitCast(AllocSize
, ITy
);
2678 Instruction
* Malloc
= CallInst::CreateMalloc(unwrap(B
)->GetInsertBlock(),
2679 ITy
, unwrap(Ty
), AllocSize
,
2680 nullptr, nullptr, "");
2681 return wrap(unwrap(B
)->Insert(Malloc
, Twine(Name
)));
2684 LLVMValueRef
LLVMBuildArrayMalloc(LLVMBuilderRef B
, LLVMTypeRef Ty
,
2685 LLVMValueRef Val
, const char *Name
) {
2686 Type
* ITy
= Type::getInt32Ty(unwrap(B
)->GetInsertBlock()->getContext());
2687 Constant
* AllocSize
= ConstantExpr::getSizeOf(unwrap(Ty
));
2688 AllocSize
= ConstantExpr::getTruncOrBitCast(AllocSize
, ITy
);
2689 Instruction
* Malloc
= CallInst::CreateMalloc(unwrap(B
)->GetInsertBlock(),
2690 ITy
, unwrap(Ty
), AllocSize
,
2691 unwrap(Val
), nullptr, "");
2692 return wrap(unwrap(B
)->Insert(Malloc
, Twine(Name
)));
2695 LLVMValueRef
LLVMBuildAlloca(LLVMBuilderRef B
, LLVMTypeRef Ty
,
2697 return wrap(unwrap(B
)->CreateAlloca(unwrap(Ty
), nullptr, Name
));
2700 LLVMValueRef
LLVMBuildArrayAlloca(LLVMBuilderRef B
, LLVMTypeRef Ty
,
2701 LLVMValueRef Val
, const char *Name
) {
2702 return wrap(unwrap(B
)->CreateAlloca(unwrap(Ty
), unwrap(Val
), Name
));
2705 LLVMValueRef
LLVMBuildFree(LLVMBuilderRef B
, LLVMValueRef PointerVal
) {
2706 return wrap(unwrap(B
)->Insert(
2707 CallInst::CreateFree(unwrap(PointerVal
), unwrap(B
)->GetInsertBlock())));
2710 LLVMValueRef
LLVMBuildLoad(LLVMBuilderRef B
, LLVMValueRef PointerVal
,
2712 return wrap(unwrap(B
)->CreateLoad(unwrap(PointerVal
), Name
));
2715 LLVMValueRef
LLVMBuildStore(LLVMBuilderRef B
, LLVMValueRef Val
,
2716 LLVMValueRef PointerVal
) {
2717 return wrap(unwrap(B
)->CreateStore(unwrap(Val
), unwrap(PointerVal
)));
2720 static AtomicOrdering
mapFromLLVMOrdering(LLVMAtomicOrdering Ordering
) {
2722 case LLVMAtomicOrderingNotAtomic
: return AtomicOrdering::NotAtomic
;
2723 case LLVMAtomicOrderingUnordered
: return AtomicOrdering::Unordered
;
2724 case LLVMAtomicOrderingMonotonic
: return AtomicOrdering::Monotonic
;
2725 case LLVMAtomicOrderingAcquire
: return AtomicOrdering::Acquire
;
2726 case LLVMAtomicOrderingRelease
: return AtomicOrdering::Release
;
2727 case LLVMAtomicOrderingAcquireRelease
:
2728 return AtomicOrdering::AcquireRelease
;
2729 case LLVMAtomicOrderingSequentiallyConsistent
:
2730 return AtomicOrdering::SequentiallyConsistent
;
2733 llvm_unreachable("Invalid LLVMAtomicOrdering value!");
2736 static LLVMAtomicOrdering
mapToLLVMOrdering(AtomicOrdering Ordering
) {
2738 case AtomicOrdering::NotAtomic
: return LLVMAtomicOrderingNotAtomic
;
2739 case AtomicOrdering::Unordered
: return LLVMAtomicOrderingUnordered
;
2740 case AtomicOrdering::Monotonic
: return LLVMAtomicOrderingMonotonic
;
2741 case AtomicOrdering::Acquire
: return LLVMAtomicOrderingAcquire
;
2742 case AtomicOrdering::Release
: return LLVMAtomicOrderingRelease
;
2743 case AtomicOrdering::AcquireRelease
:
2744 return LLVMAtomicOrderingAcquireRelease
;
2745 case AtomicOrdering::SequentiallyConsistent
:
2746 return LLVMAtomicOrderingSequentiallyConsistent
;
2749 llvm_unreachable("Invalid AtomicOrdering value!");
2752 LLVMValueRef
LLVMBuildFence(LLVMBuilderRef B
, LLVMAtomicOrdering Ordering
,
2753 LLVMBool isSingleThread
, const char *Name
) {
2755 unwrap(B
)->CreateFence(mapFromLLVMOrdering(Ordering
),
2756 isSingleThread
? SingleThread
: CrossThread
,
2760 LLVMValueRef
LLVMBuildGEP(LLVMBuilderRef B
, LLVMValueRef Pointer
,
2761 LLVMValueRef
*Indices
, unsigned NumIndices
,
2763 ArrayRef
<Value
*> IdxList(unwrap(Indices
), NumIndices
);
2764 return wrap(unwrap(B
)->CreateGEP(nullptr, unwrap(Pointer
), IdxList
, Name
));
2767 LLVMValueRef
LLVMBuildInBoundsGEP(LLVMBuilderRef B
, LLVMValueRef Pointer
,
2768 LLVMValueRef
*Indices
, unsigned NumIndices
,
2770 ArrayRef
<Value
*> IdxList(unwrap(Indices
), NumIndices
);
2772 unwrap(B
)->CreateInBoundsGEP(nullptr, unwrap(Pointer
), IdxList
, Name
));
2775 LLVMValueRef
LLVMBuildStructGEP(LLVMBuilderRef B
, LLVMValueRef Pointer
,
2776 unsigned Idx
, const char *Name
) {
2777 return wrap(unwrap(B
)->CreateStructGEP(nullptr, unwrap(Pointer
), Idx
, Name
));
2780 LLVMValueRef
LLVMBuildGlobalString(LLVMBuilderRef B
, const char *Str
,
2782 return wrap(unwrap(B
)->CreateGlobalString(Str
, Name
));
2785 LLVMValueRef
LLVMBuildGlobalStringPtr(LLVMBuilderRef B
, const char *Str
,
2787 return wrap(unwrap(B
)->CreateGlobalStringPtr(Str
, Name
));
2790 LLVMBool
LLVMGetVolatile(LLVMValueRef MemAccessInst
) {
2791 Value
*P
= unwrap
<Value
>(MemAccessInst
);
2792 if (LoadInst
*LI
= dyn_cast
<LoadInst
>(P
))
2793 return LI
->isVolatile();
2794 return cast
<StoreInst
>(P
)->isVolatile();
2797 void LLVMSetVolatile(LLVMValueRef MemAccessInst
, LLVMBool isVolatile
) {
2798 Value
*P
= unwrap
<Value
>(MemAccessInst
);
2799 if (LoadInst
*LI
= dyn_cast
<LoadInst
>(P
))
2800 return LI
->setVolatile(isVolatile
);
2801 return cast
<StoreInst
>(P
)->setVolatile(isVolatile
);
2804 LLVMAtomicOrdering
LLVMGetOrdering(LLVMValueRef MemAccessInst
) {
2805 Value
*P
= unwrap
<Value
>(MemAccessInst
);
2807 if (LoadInst
*LI
= dyn_cast
<LoadInst
>(P
))
2808 O
= LI
->getOrdering();
2810 O
= cast
<StoreInst
>(P
)->getOrdering();
2811 return mapToLLVMOrdering(O
);
2814 void LLVMSetOrdering(LLVMValueRef MemAccessInst
, LLVMAtomicOrdering Ordering
) {
2815 Value
*P
= unwrap
<Value
>(MemAccessInst
);
2816 AtomicOrdering O
= mapFromLLVMOrdering(Ordering
);
2818 if (LoadInst
*LI
= dyn_cast
<LoadInst
>(P
))
2819 return LI
->setOrdering(O
);
2820 return cast
<StoreInst
>(P
)->setOrdering(O
);
2823 /*--.. Casts ...............................................................--*/
2825 LLVMValueRef
LLVMBuildTrunc(LLVMBuilderRef B
, LLVMValueRef Val
,
2826 LLVMTypeRef DestTy
, const char *Name
) {
2827 return wrap(unwrap(B
)->CreateTrunc(unwrap(Val
), unwrap(DestTy
), Name
));
2830 LLVMValueRef
LLVMBuildZExt(LLVMBuilderRef B
, LLVMValueRef Val
,
2831 LLVMTypeRef DestTy
, const char *Name
) {
2832 return wrap(unwrap(B
)->CreateZExt(unwrap(Val
), unwrap(DestTy
), Name
));
2835 LLVMValueRef
LLVMBuildSExt(LLVMBuilderRef B
, LLVMValueRef Val
,
2836 LLVMTypeRef DestTy
, const char *Name
) {
2837 return wrap(unwrap(B
)->CreateSExt(unwrap(Val
), unwrap(DestTy
), Name
));
2840 LLVMValueRef
LLVMBuildFPToUI(LLVMBuilderRef B
, LLVMValueRef Val
,
2841 LLVMTypeRef DestTy
, const char *Name
) {
2842 return wrap(unwrap(B
)->CreateFPToUI(unwrap(Val
), unwrap(DestTy
), Name
));
2845 LLVMValueRef
LLVMBuildFPToSI(LLVMBuilderRef B
, LLVMValueRef Val
,
2846 LLVMTypeRef DestTy
, const char *Name
) {
2847 return wrap(unwrap(B
)->CreateFPToSI(unwrap(Val
), unwrap(DestTy
), Name
));
2850 LLVMValueRef
LLVMBuildUIToFP(LLVMBuilderRef B
, LLVMValueRef Val
,
2851 LLVMTypeRef DestTy
, const char *Name
) {
2852 return wrap(unwrap(B
)->CreateUIToFP(unwrap(Val
), unwrap(DestTy
), Name
));
2855 LLVMValueRef
LLVMBuildSIToFP(LLVMBuilderRef B
, LLVMValueRef Val
,
2856 LLVMTypeRef DestTy
, const char *Name
) {
2857 return wrap(unwrap(B
)->CreateSIToFP(unwrap(Val
), unwrap(DestTy
), Name
));
2860 LLVMValueRef
LLVMBuildFPTrunc(LLVMBuilderRef B
, LLVMValueRef Val
,
2861 LLVMTypeRef DestTy
, const char *Name
) {
2862 return wrap(unwrap(B
)->CreateFPTrunc(unwrap(Val
), unwrap(DestTy
), Name
));
2865 LLVMValueRef
LLVMBuildFPExt(LLVMBuilderRef B
, LLVMValueRef Val
,
2866 LLVMTypeRef DestTy
, const char *Name
) {
2867 return wrap(unwrap(B
)->CreateFPExt(unwrap(Val
), unwrap(DestTy
), Name
));
2870 LLVMValueRef
LLVMBuildPtrToInt(LLVMBuilderRef B
, LLVMValueRef Val
,
2871 LLVMTypeRef DestTy
, const char *Name
) {
2872 return wrap(unwrap(B
)->CreatePtrToInt(unwrap(Val
), unwrap(DestTy
), Name
));
2875 LLVMValueRef
LLVMBuildIntToPtr(LLVMBuilderRef B
, LLVMValueRef Val
,
2876 LLVMTypeRef DestTy
, const char *Name
) {
2877 return wrap(unwrap(B
)->CreateIntToPtr(unwrap(Val
), unwrap(DestTy
), Name
));
2880 LLVMValueRef
LLVMBuildBitCast(LLVMBuilderRef B
, LLVMValueRef Val
,
2881 LLVMTypeRef DestTy
, const char *Name
) {
2882 return wrap(unwrap(B
)->CreateBitCast(unwrap(Val
), unwrap(DestTy
), Name
));
2885 LLVMValueRef
LLVMBuildAddrSpaceCast(LLVMBuilderRef B
, LLVMValueRef Val
,
2886 LLVMTypeRef DestTy
, const char *Name
) {
2887 return wrap(unwrap(B
)->CreateAddrSpaceCast(unwrap(Val
), unwrap(DestTy
), Name
));
2890 LLVMValueRef
LLVMBuildZExtOrBitCast(LLVMBuilderRef B
, LLVMValueRef Val
,
2891 LLVMTypeRef DestTy
, const char *Name
) {
2892 return wrap(unwrap(B
)->CreateZExtOrBitCast(unwrap(Val
), unwrap(DestTy
),
2896 LLVMValueRef
LLVMBuildSExtOrBitCast(LLVMBuilderRef B
, LLVMValueRef Val
,
2897 LLVMTypeRef DestTy
, const char *Name
) {
2898 return wrap(unwrap(B
)->CreateSExtOrBitCast(unwrap(Val
), unwrap(DestTy
),
2902 LLVMValueRef
LLVMBuildTruncOrBitCast(LLVMBuilderRef B
, LLVMValueRef Val
,
2903 LLVMTypeRef DestTy
, const char *Name
) {
2904 return wrap(unwrap(B
)->CreateTruncOrBitCast(unwrap(Val
), unwrap(DestTy
),
2908 LLVMValueRef
LLVMBuildCast(LLVMBuilderRef B
, LLVMOpcode Op
, LLVMValueRef Val
,
2909 LLVMTypeRef DestTy
, const char *Name
) {
2910 return wrap(unwrap(B
)->CreateCast(Instruction::CastOps(map_from_llvmopcode(Op
)), unwrap(Val
),
2911 unwrap(DestTy
), Name
));
2914 LLVMValueRef
LLVMBuildPointerCast(LLVMBuilderRef B
, LLVMValueRef Val
,
2915 LLVMTypeRef DestTy
, const char *Name
) {
2916 return wrap(unwrap(B
)->CreatePointerCast(unwrap(Val
), unwrap(DestTy
), Name
));
2919 LLVMValueRef
LLVMBuildIntCast(LLVMBuilderRef B
, LLVMValueRef Val
,
2920 LLVMTypeRef DestTy
, const char *Name
) {
2921 return wrap(unwrap(B
)->CreateIntCast(unwrap(Val
), unwrap(DestTy
),
2922 /*isSigned*/true, Name
));
2925 LLVMValueRef
LLVMBuildFPCast(LLVMBuilderRef B
, LLVMValueRef Val
,
2926 LLVMTypeRef DestTy
, const char *Name
) {
2927 return wrap(unwrap(B
)->CreateFPCast(unwrap(Val
), unwrap(DestTy
), Name
));
2930 /*--.. Comparisons .........................................................--*/
2932 LLVMValueRef
LLVMBuildICmp(LLVMBuilderRef B
, LLVMIntPredicate Op
,
2933 LLVMValueRef LHS
, LLVMValueRef RHS
,
2935 return wrap(unwrap(B
)->CreateICmp(static_cast<ICmpInst::Predicate
>(Op
),
2936 unwrap(LHS
), unwrap(RHS
), Name
));
2939 LLVMValueRef
LLVMBuildFCmp(LLVMBuilderRef B
, LLVMRealPredicate Op
,
2940 LLVMValueRef LHS
, LLVMValueRef RHS
,
2942 return wrap(unwrap(B
)->CreateFCmp(static_cast<FCmpInst::Predicate
>(Op
),
2943 unwrap(LHS
), unwrap(RHS
), Name
));
2946 /*--.. Miscellaneous instructions ..........................................--*/
2948 LLVMValueRef
LLVMBuildPhi(LLVMBuilderRef B
, LLVMTypeRef Ty
, const char *Name
) {
2949 return wrap(unwrap(B
)->CreatePHI(unwrap(Ty
), 0, Name
));
2952 LLVMValueRef
LLVMBuildCall(LLVMBuilderRef B
, LLVMValueRef Fn
,
2953 LLVMValueRef
*Args
, unsigned NumArgs
,
2955 return wrap(unwrap(B
)->CreateCall(unwrap(Fn
),
2956 makeArrayRef(unwrap(Args
), NumArgs
),
2960 LLVMValueRef
LLVMBuildSelect(LLVMBuilderRef B
, LLVMValueRef If
,
2961 LLVMValueRef Then
, LLVMValueRef Else
,
2963 return wrap(unwrap(B
)->CreateSelect(unwrap(If
), unwrap(Then
), unwrap(Else
),
2967 LLVMValueRef
LLVMBuildVAArg(LLVMBuilderRef B
, LLVMValueRef List
,
2968 LLVMTypeRef Ty
, const char *Name
) {
2969 return wrap(unwrap(B
)->CreateVAArg(unwrap(List
), unwrap(Ty
), Name
));
2972 LLVMValueRef
LLVMBuildExtractElement(LLVMBuilderRef B
, LLVMValueRef VecVal
,
2973 LLVMValueRef Index
, const char *Name
) {
2974 return wrap(unwrap(B
)->CreateExtractElement(unwrap(VecVal
), unwrap(Index
),
2978 LLVMValueRef
LLVMBuildInsertElement(LLVMBuilderRef B
, LLVMValueRef VecVal
,
2979 LLVMValueRef EltVal
, LLVMValueRef Index
,
2981 return wrap(unwrap(B
)->CreateInsertElement(unwrap(VecVal
), unwrap(EltVal
),
2982 unwrap(Index
), Name
));
2985 LLVMValueRef
LLVMBuildShuffleVector(LLVMBuilderRef B
, LLVMValueRef V1
,
2986 LLVMValueRef V2
, LLVMValueRef Mask
,
2988 return wrap(unwrap(B
)->CreateShuffleVector(unwrap(V1
), unwrap(V2
),
2989 unwrap(Mask
), Name
));
2992 LLVMValueRef
LLVMBuildExtractValue(LLVMBuilderRef B
, LLVMValueRef AggVal
,
2993 unsigned Index
, const char *Name
) {
2994 return wrap(unwrap(B
)->CreateExtractValue(unwrap(AggVal
), Index
, Name
));
2997 LLVMValueRef
LLVMBuildInsertValue(LLVMBuilderRef B
, LLVMValueRef AggVal
,
2998 LLVMValueRef EltVal
, unsigned Index
,
3000 return wrap(unwrap(B
)->CreateInsertValue(unwrap(AggVal
), unwrap(EltVal
),
3004 LLVMValueRef
LLVMBuildIsNull(LLVMBuilderRef B
, LLVMValueRef Val
,
3006 return wrap(unwrap(B
)->CreateIsNull(unwrap(Val
), Name
));
3009 LLVMValueRef
LLVMBuildIsNotNull(LLVMBuilderRef B
, LLVMValueRef Val
,
3011 return wrap(unwrap(B
)->CreateIsNotNull(unwrap(Val
), Name
));
3014 LLVMValueRef
LLVMBuildPtrDiff(LLVMBuilderRef B
, LLVMValueRef LHS
,
3015 LLVMValueRef RHS
, const char *Name
) {
3016 return wrap(unwrap(B
)->CreatePtrDiff(unwrap(LHS
), unwrap(RHS
), Name
));
3019 LLVMValueRef
LLVMBuildAtomicRMW(LLVMBuilderRef B
,LLVMAtomicRMWBinOp op
,
3020 LLVMValueRef PTR
, LLVMValueRef Val
,
3021 LLVMAtomicOrdering ordering
,
3022 LLVMBool singleThread
) {
3023 AtomicRMWInst::BinOp intop
;
3025 case LLVMAtomicRMWBinOpXchg
: intop
= AtomicRMWInst::Xchg
; break;
3026 case LLVMAtomicRMWBinOpAdd
: intop
= AtomicRMWInst::Add
; break;
3027 case LLVMAtomicRMWBinOpSub
: intop
= AtomicRMWInst::Sub
; break;
3028 case LLVMAtomicRMWBinOpAnd
: intop
= AtomicRMWInst::And
; break;
3029 case LLVMAtomicRMWBinOpNand
: intop
= AtomicRMWInst::Nand
; break;
3030 case LLVMAtomicRMWBinOpOr
: intop
= AtomicRMWInst::Or
; break;
3031 case LLVMAtomicRMWBinOpXor
: intop
= AtomicRMWInst::Xor
; break;
3032 case LLVMAtomicRMWBinOpMax
: intop
= AtomicRMWInst::Max
; break;
3033 case LLVMAtomicRMWBinOpMin
: intop
= AtomicRMWInst::Min
; break;
3034 case LLVMAtomicRMWBinOpUMax
: intop
= AtomicRMWInst::UMax
; break;
3035 case LLVMAtomicRMWBinOpUMin
: intop
= AtomicRMWInst::UMin
; break;
3037 return wrap(unwrap(B
)->CreateAtomicRMW(intop
, unwrap(PTR
), unwrap(Val
),
3038 mapFromLLVMOrdering(ordering
), singleThread
? SingleThread
: CrossThread
));
3041 LLVMValueRef
LLVMBuildAtomicCmpXchg(LLVMBuilderRef B
, LLVMValueRef Ptr
,
3042 LLVMValueRef Cmp
, LLVMValueRef New
,
3043 LLVMAtomicOrdering SuccessOrdering
,
3044 LLVMAtomicOrdering FailureOrdering
,
3045 LLVMBool singleThread
) {
3047 return wrap(unwrap(B
)->CreateAtomicCmpXchg(unwrap(Ptr
), unwrap(Cmp
),
3048 unwrap(New
), mapFromLLVMOrdering(SuccessOrdering
),
3049 mapFromLLVMOrdering(FailureOrdering
),
3050 singleThread
? SingleThread
: CrossThread
));
3054 LLVMBool
LLVMIsAtomicSingleThread(LLVMValueRef AtomicInst
) {
3055 Value
*P
= unwrap
<Value
>(AtomicInst
);
3057 if (AtomicRMWInst
*I
= dyn_cast
<AtomicRMWInst
>(P
))
3058 return I
->getSynchScope() == SingleThread
;
3059 return cast
<AtomicCmpXchgInst
>(P
)->getSynchScope() == SingleThread
;
3062 void LLVMSetAtomicSingleThread(LLVMValueRef AtomicInst
, LLVMBool NewValue
) {
3063 Value
*P
= unwrap
<Value
>(AtomicInst
);
3064 SynchronizationScope Sync
= NewValue
? SingleThread
: CrossThread
;
3066 if (AtomicRMWInst
*I
= dyn_cast
<AtomicRMWInst
>(P
))
3067 return I
->setSynchScope(Sync
);
3068 return cast
<AtomicCmpXchgInst
>(P
)->setSynchScope(Sync
);
3071 LLVMAtomicOrdering
LLVMGetCmpXchgSuccessOrdering(LLVMValueRef CmpXchgInst
) {
3072 Value
*P
= unwrap
<Value
>(CmpXchgInst
);
3073 return mapToLLVMOrdering(cast
<AtomicCmpXchgInst
>(P
)->getSuccessOrdering());
3076 void LLVMSetCmpXchgSuccessOrdering(LLVMValueRef CmpXchgInst
,
3077 LLVMAtomicOrdering Ordering
) {
3078 Value
*P
= unwrap
<Value
>(CmpXchgInst
);
3079 AtomicOrdering O
= mapFromLLVMOrdering(Ordering
);
3081 return cast
<AtomicCmpXchgInst
>(P
)->setSuccessOrdering(O
);
3084 LLVMAtomicOrdering
LLVMGetCmpXchgFailureOrdering(LLVMValueRef CmpXchgInst
) {
3085 Value
*P
= unwrap
<Value
>(CmpXchgInst
);
3086 return mapToLLVMOrdering(cast
<AtomicCmpXchgInst
>(P
)->getFailureOrdering());
3089 void LLVMSetCmpXchgFailureOrdering(LLVMValueRef CmpXchgInst
,
3090 LLVMAtomicOrdering Ordering
) {
3091 Value
*P
= unwrap
<Value
>(CmpXchgInst
);
3092 AtomicOrdering O
= mapFromLLVMOrdering(Ordering
);
3094 return cast
<AtomicCmpXchgInst
>(P
)->setFailureOrdering(O
);
3097 /*===-- Module providers --------------------------------------------------===*/
3099 LLVMModuleProviderRef
3100 LLVMCreateModuleProviderForExistingModule(LLVMModuleRef M
) {
3101 return reinterpret_cast<LLVMModuleProviderRef
>(M
);
3104 void LLVMDisposeModuleProvider(LLVMModuleProviderRef MP
) {
3109 /*===-- Memory buffers ----------------------------------------------------===*/
3111 LLVMBool
LLVMCreateMemoryBufferWithContentsOfFile(
3113 LLVMMemoryBufferRef
*OutMemBuf
,
3114 char **OutMessage
) {
3116 ErrorOr
<std::unique_ptr
<MemoryBuffer
>> MBOrErr
= MemoryBuffer::getFile(Path
);
3117 if (std::error_code EC
= MBOrErr
.getError()) {
3118 *OutMessage
= strdup(EC
.message().c_str());
3121 *OutMemBuf
= wrap(MBOrErr
.get().release());
3125 LLVMBool
LLVMCreateMemoryBufferWithSTDIN(LLVMMemoryBufferRef
*OutMemBuf
,
3126 char **OutMessage
) {
3127 ErrorOr
<std::unique_ptr
<MemoryBuffer
>> MBOrErr
= MemoryBuffer::getSTDIN();
3128 if (std::error_code EC
= MBOrErr
.getError()) {
3129 *OutMessage
= strdup(EC
.message().c_str());
3132 *OutMemBuf
= wrap(MBOrErr
.get().release());
3136 LLVMMemoryBufferRef
LLVMCreateMemoryBufferWithMemoryRange(
3137 const char *InputData
,
3138 size_t InputDataLength
,
3139 const char *BufferName
,
3140 LLVMBool RequiresNullTerminator
) {
3142 return wrap(MemoryBuffer::getMemBuffer(StringRef(InputData
, InputDataLength
),
3143 StringRef(BufferName
),
3144 RequiresNullTerminator
).release());
3147 LLVMMemoryBufferRef
LLVMCreateMemoryBufferWithMemoryRangeCopy(
3148 const char *InputData
,
3149 size_t InputDataLength
,
3150 const char *BufferName
) {
3153 MemoryBuffer::getMemBufferCopy(StringRef(InputData
, InputDataLength
),
3154 StringRef(BufferName
)).release());
3157 const char *LLVMGetBufferStart(LLVMMemoryBufferRef MemBuf
) {
3158 return unwrap(MemBuf
)->getBufferStart();
3161 size_t LLVMGetBufferSize(LLVMMemoryBufferRef MemBuf
) {
3162 return unwrap(MemBuf
)->getBufferSize();
3165 void LLVMDisposeMemoryBuffer(LLVMMemoryBufferRef MemBuf
) {
3166 delete unwrap(MemBuf
);
3169 /*===-- Pass Registry -----------------------------------------------------===*/
3171 LLVMPassRegistryRef
LLVMGetGlobalPassRegistry(void) {
3172 return wrap(PassRegistry::getPassRegistry());
3175 /*===-- Pass Manager ------------------------------------------------------===*/
3177 LLVMPassManagerRef
LLVMCreatePassManager() {
3178 return wrap(new legacy::PassManager());
3181 LLVMPassManagerRef
LLVMCreateFunctionPassManagerForModule(LLVMModuleRef M
) {
3182 return wrap(new legacy::FunctionPassManager(unwrap(M
)));
3185 LLVMPassManagerRef
LLVMCreateFunctionPassManager(LLVMModuleProviderRef P
) {
3186 return LLVMCreateFunctionPassManagerForModule(
3187 reinterpret_cast<LLVMModuleRef
>(P
));
3190 LLVMBool
LLVMRunPassManager(LLVMPassManagerRef PM
, LLVMModuleRef M
) {
3191 return unwrap
<legacy::PassManager
>(PM
)->run(*unwrap(M
));
3194 LLVMBool
LLVMInitializeFunctionPassManager(LLVMPassManagerRef FPM
) {
3195 return unwrap
<legacy::FunctionPassManager
>(FPM
)->doInitialization();
3198 LLVMBool
LLVMRunFunctionPassManager(LLVMPassManagerRef FPM
, LLVMValueRef F
) {
3199 return unwrap
<legacy::FunctionPassManager
>(FPM
)->run(*unwrap
<Function
>(F
));
3202 LLVMBool
LLVMFinalizeFunctionPassManager(LLVMPassManagerRef FPM
) {
3203 return unwrap
<legacy::FunctionPassManager
>(FPM
)->doFinalization();
3206 void LLVMDisposePassManager(LLVMPassManagerRef PM
) {
3210 /*===-- Threading ------------------------------------------------------===*/
3212 LLVMBool
LLVMStartMultithreaded() {
3213 return LLVMIsMultithreaded();
3216 void LLVMStopMultithreaded() {
3219 LLVMBool
LLVMIsMultithreaded() {
3220 return llvm_is_multithreaded();