43 #include <system_error>
47 #define DEBUG_TYPE "ir"
68 return strdup(Message);
88 void *DiagnosticContext) {
89 unwrap(C)->setDiagnosticHandler(
97 unwrap(C)->getDiagnosticHandler());
101 return unwrap(C)->getDiagnosticContext();
105 void *OpaqueHandle) {
108 unwrap(C)->setYieldCallback(YieldCallback, OpaqueHandle);
124 #define GET_ATTR_KIND_FROM_NAME
125 #include "AttributesCompatFunc.inc"
128 return getAttrKindFromName(
StringRef(Name, SLen));
132 return Attribute::AttrKind::EndAttrKinds;
146 if (Attr.isEnumAttribute())
148 return Attr.getValueAsInt();
152 const char *K,
unsigned KLength,
153 const char *V,
unsigned VLength) {
174 return Attr.isEnumAttribute() || Attr.isIntAttribute();
182 std::string MsgStorage;
195 switch(
unwrap(DI)->getSeverity()) {
229 auto &Str =
unwrap(M)->getModuleIdentifier();
241 return unwrap(M)->getDataLayoutStr().c_str();
249 unwrap(M)->setDataLayout(DataLayoutStr);
254 return unwrap(M)->getTargetTriple().c_str();
258 unwrap(M)->setTargetTriple(Triple);
266 char **ErrorMessage) {
270 *ErrorMessage = strdup(EC.message().c_str());
274 unwrap(M)->print(dest,
nullptr);
279 *ErrorMessage = strdup(
"Error printing to file");
290 unwrap(M)->print(os,
nullptr);
293 return strdup(buf.c_str());
354 return unwrap(Ty)->isSized();
362 return unwrap(Ty)->dump();
372 os <<
"Printing <null> Type";
376 return strdup(buf.c_str());
426 return unwrap<IntegerType>(IntegerTy)->
getBitWidth();
488 return unwrap<FunctionType>(FunctionTy)->isVarArg();
492 return wrap(unwrap<FunctionType>(FunctionTy)->getReturnType());
496 return unwrap<FunctionType>(FunctionTy)->getNumParams();
509 unsigned ElementCount,
LLVMBool Packed) {
515 unsigned ElementCount,
LLVMBool Packed) {
517 ElementCount, Packed);
534 unsigned ElementCount,
LLVMBool Packed) {
536 unwrap<StructType>(StructTy)->setBody(Tys, Packed != 0);
540 return unwrap<StructType>(StructTy)->getNumElements();
544 StructType *Ty = unwrap<StructType>(StructTy);
551 StructType *Ty = unwrap<StructType>(StructTy);
556 return unwrap<StructType>(StructTy)->isPacked();
560 return unwrap<StructType>(StructTy)->isOpaque();
582 auto *Ty = unwrap<Type>(WrappedTy);
583 if (
auto *PTy = dyn_cast<PointerType>(Ty))
584 return wrap(PTy->getElementType());
585 return wrap(cast<SequentialType>(Ty)->getElementType());
589 return unwrap<ArrayType>(ArrayTy)->getNumElements();
593 return unwrap<PointerType>(
PointerTy)->getAddressSpace();
597 return unwrap<VectorType>(VectorTy)->getNumElements();
625 switch(
unwrap(Val)->getValueID()) {
626 #define HANDLE_VALUE(Name) \
627 case Value::Name##Val: \
628 return LLVM##Name##ValueKind;
629 #include "llvm/IR/Value.def"
636 return unwrap(Val)->getName().data();
640 unwrap(Val)->setName(Name);
654 os <<
"Printing <null> Value";
658 return strdup(buf.c_str());
666 return unwrap<Instruction>(Inst)->hasMetadata();
670 auto *
I = unwrap<Instruction>(Inst);
671 assert(
I &&
"Expected instruction");
672 if (
auto *MD =
I->getMetadata(KindID))
682 assert((isa<MDNode>(MD) || isa<ConstantAsMetadata>(MD)) &&
683 "Expected a metadata node or a canonicalized constant");
685 if (
MDNode *
N = dyn_cast<MDNode>(MD))
699 #define LLVM_DEFINE_VALUE_CAST(name) \
700 LLVMValueRef LLVMIsA##name(LLVMValueRef Val) { \
701 return wrap(static_cast<Value*>(dyn_cast_or_null<name>(unwrap(Val)))); \
707 if (
auto *MD = dyn_cast_or_null<MetadataAsValue>(
unwrap(Val)))
708 if (isa<MDNode>(MD->getMetadata()) ||
709 isa<ValueAsMetadata>(MD->getMetadata()))
715 if (
auto *MD = dyn_cast_or_null<MetadataAsValue>(
unwrap(Val)))
716 if (isa<MDString>(MD->getMetadata()))
752 if (
auto *
C = dyn_cast<ConstantAsMetadata>(Op))
753 return wrap(
C->getValue());
759 if (
auto *MD = dyn_cast<MetadataAsValue>(V)) {
760 if (
auto *
L = dyn_cast<ValueAsMetadata>(MD->getMetadata())) {
761 assert(Index == 0 &&
"Function-local metadata can only have one operand");
762 return wrap(
L->getValue());
765 cast<MDNode>(MD->getMetadata()), Index);
768 return wrap(cast<User>(V)->getOperand(Index));
773 return wrap(&cast<User>(V)->getOperandUse(Index));
777 unwrap<User>(Val)->setOperand(Index,
unwrap(Op));
782 if (isa<MetadataAsValue>(V))
785 return cast<User>(V)->getNumOperands();
803 return isa<Constant>(
unwrap(Ty));
808 return C->isNullValue();
813 return isa<UndefValue>(
unwrap(Val));
842 else if (
auto *C = dyn_cast<Constant>(V))
844 else if (
auto *MDV = dyn_cast<MetadataAsValue>(V)) {
845 MD = MDV->getMetadata();
846 assert(!isa<LocalAsMetadata>(MD) &&
"Unexpected function-local metadata "
847 "outside of direct argument to call");
851 "Expected only one operand to function-local metadata");
865 if (
const auto *MD = dyn_cast<MetadataAsValue>(
unwrap(V)))
866 if (
const MDString *S = dyn_cast<MDString>(MD->getMetadata())) {
867 *Length = S->getString().size();
868 return S->getString().data();
875 auto *MD = cast<MetadataAsValue>(
unwrap(V));
876 if (isa<ValueAsMetadata>(MD->getMetadata()))
878 return cast<MDNode>(MD->getMetadata())->getNumOperands();
882 auto *MD = cast<MetadataAsValue>(
unwrap(V));
883 if (
auto *MDV = dyn_cast<ValueAsMetadata>(MD->getMetadata())) {
884 *Dest =
wrap(MDV->getValue());
887 const auto *
N = cast<MDNode>(MD->getMetadata());
888 const unsigned numOperands =
N->getNumOperands();
890 for (
unsigned i = 0;
i < numOperands;
i++)
896 return N->getNumOperands();
930 const uint64_t Words[]) {
944 unsigned SLen, uint8_t Radix) {
963 return unwrap<ConstantInt>(ConstantVal)->getZExtValue();
967 return unwrap<ConstantInt>(ConstantVal)->getSExtValue();
971 ConstantFP *cFP = unwrap<ConstantFP>(ConstantVal) ;
974 if (Ty->isFloatTy()) {
979 if (Ty->isDoubleTy()) {
987 *LosesInfo = APFLosesInfo;
999 DontNullTerminate == 0));
1009 return wrap(unwrap<ConstantDataSequential>(C)->getElementAsConstant(idx));
1013 return unwrap<ConstantDataSequential>(
C)->isString();
1017 StringRef Str = unwrap<ConstantDataSequential>(
C)->getAsString();
1018 *Length = Str.
size();
1031 Constant **Elements = unwrap<Constant>(ConstantVals, Count);
1045 Constant **Elements = unwrap<Constant>(ConstantVals, Count);
1053 unwrap<Constant>(ScalarConstantVals, Size), Size)));
1062 #define HANDLE_INST(num, opc, clas) case num: return LLVM##opc;
1063 #include "llvm/IR/Instruction.def"
1071 #define HANDLE_INST(num, opc, clas) case LLVM##opc: return num;
1072 #include "llvm/IR/Instruction.def"
1115 unwrap<Constant>(RHSConstant)));
1121 unwrap<Constant>(RHSConstant)));
1127 unwrap<Constant>(RHSConstant)));
1132 unwrap<Constant>(RHSConstant)));
1137 unwrap<Constant>(RHSConstant)));
1143 unwrap<Constant>(RHSConstant)));
1149 unwrap<Constant>(RHSConstant)));
1154 unwrap<Constant>(RHSConstant)));
1159 unwrap<Constant>(RHSConstant)));
1165 unwrap<Constant>(RHSConstant)));
1171 unwrap<Constant>(RHSConstant)));
1176 unwrap<Constant>(RHSConstant)));
1181 unwrap<Constant>(RHSConstant)));
1187 unwrap<Constant>(RHSConstant)));
1192 unwrap<Constant>(RHSConstant)));
1198 unwrap<Constant>(RHSConstant)));
1203 unwrap<Constant>(RHSConstant)));
1208 unwrap<Constant>(RHSConstant)));
1213 unwrap<Constant>(RHSConstant)));
1218 unwrap<Constant>(RHSConstant)));
1223 unwrap<Constant>(RHSConstant)));
1228 unwrap<Constant>(RHSConstant)));
1233 unwrap<Constant>(RHSConstant)));
1239 unwrap<Constant>(LHSConstant),
1240 unwrap<Constant>(RHSConstant)));
1246 unwrap<Constant>(LHSConstant),
1247 unwrap<Constant>(RHSConstant)));
1252 unwrap<Constant>(RHSConstant)));
1257 unwrap<Constant>(RHSConstant)));
1262 unwrap<Constant>(RHSConstant)));
1270 nullptr, unwrap<Constant>(ConstantVal), IdxList));
1275 unsigned NumIndices) {
1276 Constant* Val = unwrap<Constant>(ConstantVal);
1375 unwrap(ToType), isSigned));
1387 unwrap<Constant>(ConstantIfTrue),
1388 unwrap<Constant>(ConstantIfFalse)));
1394 unwrap<Constant>(IndexConstant)));
1401 unwrap<Constant>(ElementValueConstant),
1402 unwrap<Constant>(IndexConstant)));
1409 unwrap<Constant>(VectorBConstant),
1410 unwrap<Constant>(MaskConstant)));
1421 unsigned *IdxList,
unsigned NumIdx) {
1423 unwrap<Constant>(ElementValueConstant),
1428 const char *Constraints,
1432 Constraints, HasSideEffects, IsAlignStack));
1446 return unwrap<GlobalValue>(Global)->isDeclaration();
1450 switch (unwrap<GlobalValue>(Global)->getLinkage()) {
1495 DEBUG(
errs() <<
"LLVMSetLinkage(): LLVMLinkOnceODRAutoHideLinkage is no "
1496 "longer supported.");
1521 <<
"LLVMSetLinkage(): LLVMDLLImportLinkage is no longer supported.");
1525 <<
"LLVMSetLinkage(): LLVMDLLExportLinkage is no longer supported.");
1532 <<
"LLVMSetLinkage(): LLVMGhostLinkage is no longer supported.");
1543 return unwrap<GlobalValue>(Global)->
getSection().data();
1547 unwrap<GlobalObject>(Global)->setSection(Section);
1552 unwrap<GlobalValue>(Global)->getVisibility());
1556 unwrap<GlobalValue>(Global)
1557 ->setVisibility(static_cast<GlobalValue::VisibilityTypes>(Viz));
1562 unwrap<GlobalValue>(Global)->getDLLStorageClass());
1566 unwrap<GlobalValue>(Global)->setDLLStorageClass(
1567 static_cast<GlobalValue::DLLStorageClassTypes>(Class));
1571 return unwrap<GlobalValue>(Global)->hasGlobalUnnamedAddr();
1575 unwrap<GlobalValue>(Global)->setUnnamedAddr(
1583 Value *
P = unwrap<Value>(V);
1585 return GV->getAlignment();
1586 if (
AllocaInst *AI = dyn_cast<AllocaInst>(P))
1587 return AI->getAlignment();
1588 if (
LoadInst *LI = dyn_cast<LoadInst>(P))
1589 return LI->getAlignment();
1591 return SI->getAlignment();
1594 "only GlobalValue, AllocaInst, LoadInst and StoreInst have alignment");
1598 Value *
P = unwrap<Value>(V);
1600 GV->setAlignment(Bytes);
1601 else if (
AllocaInst *AI = dyn_cast<AllocaInst>(P))
1602 AI->setAlignment(Bytes);
1603 else if (
LoadInst *LI = dyn_cast<LoadInst>(P))
1604 LI->setAlignment(Bytes);
1606 SI->setAlignment(Bytes);
1609 "only GlobalValue, AllocaInst, LoadInst and StoreInst have alignment");
1629 return wrap(
unwrap(M)->getNamedGlobal(Name));
1665 unwrap<GlobalVariable>(
GlobalVar)->eraseFromParent();
1677 ->setInitializer(unwrap<Constant>(ConstantVal));
1681 return unwrap<GlobalVariable>(
GlobalVar)->isThreadLocal();
1685 unwrap<GlobalVariable>(
GlobalVar)->setThreadLocal(IsThreadLocal != 0);
1689 return unwrap<GlobalVariable>(
GlobalVar)->isConstant();
1693 unwrap<GlobalVariable>(
GlobalVar)->setConstant(IsConstant != 0);
1697 switch (unwrap<GlobalVariable>(GlobalVar)->getThreadLocalMode()) {
1736 return unwrap<GlobalVariable>(
GlobalVar)->isExternallyInitialized();
1740 unwrap<GlobalVariable>(
GlobalVar)->setExternallyInitialized(IsExtInit);
1747 auto *PTy = cast<PointerType>(
unwrap(Ty));
1750 unwrap<Constant>(Aliasee),
unwrap(M)));
1768 if (I == Mod->
end())
1776 if (I == Mod->
begin())
1798 unwrap<Function>(Fn)->eraseFromParent();
1802 return unwrap<Function>(Fn)->hasPersonalityFn();
1806 return wrap(unwrap<Function>(Fn)->getPersonalityFn());
1810 unwrap<Function>(Fn)->setPersonalityFn(unwrap<Constant>(PersonalityFn));
1815 return F->getIntrinsicID();
1820 return unwrap<Function>(Fn)->getCallingConv();
1824 return unwrap<Function>(Fn)->setCallingConv(
1825 static_cast<CallingConv::ID>(CC));
1830 return F->
hasGC()? F->
getGC().c_str() :
nullptr;
1843 unwrap<Function>(
F)->addAttribute(Idx,
unwrap(A));
1850 return ASN->getNumAttributes();
1858 for (
auto A:
make_range(ASN->begin(), ASN->end()))
1865 return wrap(unwrap<Function>(F)->getAttribute(Idx,
1871 const char *K,
unsigned KLen) {
1872 return wrap(unwrap<Function>(F)->getAttribute(Idx,
StringRef(K, KLen)));
1881 const char *K,
unsigned KLen) {
1882 unwrap<Function>(
F)->removeAttribute(Idx,
StringRef(K, KLen));
1902 return unwrap<Function>(FnRef)->arg_size();
1906 Function *Fn = unwrap<Function>(FnRef);
1909 *ParamRefs++ =
wrap(&*
I);
1958 B.addAlignmentAttr(align);
1965 return wrap(static_cast<Value*>(
unwrap(BB)));
1969 return isa<BasicBlock>(
unwrap(Val));
1973 return wrap(unwrap<BasicBlock>(Val));
1977 return unwrap(BB)->getName().data();
1989 return unwrap<Function>(FnRef)->size();
1993 Function *Fn = unwrap<Function>(FnRef);
1995 *BasicBlocksRefs++ =
wrap(&BB);
1999 return wrap(&unwrap<Function>(Fn)->getEntryBlock());
2005 if (I == Func->
end())
2013 if (I == Func->
begin())
2057 unwrap(BBRef)->eraseFromParent();
2061 unwrap(BBRef)->removeFromParent();
2081 if (I == Block->
end())
2089 if (I == Block->
begin())
2111 unwrap<Instruction>(Inst)->removeFromParent();
2115 unwrap<Instruction>(Inst)->eraseFromParent();
2122 if (CE->getOpcode() == Instruction::ICmp)
2131 if (CE->getOpcode() == Instruction::FCmp)
2144 return wrap(
C->clone());
2159 return CallSite(unwrap<Instruction>(Instr))
2170 AttributeSet::get(Call->getContext(),
2181 auto CS =
CallSite(unwrap<Instruction>(C));
2190 auto CS =
CallSite(unwrap<Instruction>(C));
2194 for (
auto A:
make_range(ASN->begin(), ASN->end()))
2207 const char *K,
unsigned KLen) {
2209 .getAttribute(Idx,
StringRef(K, KLen)));
2219 const char *K,
unsigned KLen) {
2224 return wrap(
CallSite(unwrap<Instruction>(Instr)).getCalledValue());
2230 return unwrap<CallInst>(
Call)->isTailCall();
2234 unwrap<CallInst>(
Call)->setTailCall(isTailCall);
2240 return wrap(unwrap<InvokeInst>(Invoke)->getNormalDest());
2244 return wrap(unwrap<InvokeInst>(Invoke)->getUnwindDest());
2248 unwrap<InvokeInst>(Invoke)->setNormalDest(
unwrap(B));
2252 unwrap<InvokeInst>(Invoke)->setUnwindDest(
unwrap(B));
2258 return unwrap<TerminatorInst>(Term)->getNumSuccessors();
2262 return wrap(unwrap<TerminatorInst>(Term)->getSuccessor(i));
2266 return unwrap<TerminatorInst>(Term)->setSuccessor(i,
unwrap(block));
2272 return unwrap<BranchInst>(
Branch)->isConditional();
2276 return wrap(unwrap<BranchInst>(Branch)->getCondition());
2280 return unwrap<BranchInst>(
Branch)->setCondition(
unwrap(Cond));
2286 return wrap(unwrap<SwitchInst>(Switch)->getDefaultDest());
2292 return wrap(unwrap<AllocaInst>(Alloca)->getAllocatedType());
2298 return unwrap<GetElementPtrInst>(
GEP)->isInBounds();
2302 return unwrap<GetElementPtrInst>(
GEP)->setIsInBounds(InBounds);
2309 PHINode *PhiVal = unwrap<PHINode>(PhiNode);
2310 for (
unsigned I = 0;
I != Count; ++
I)
2315 return unwrap<PHINode>(PhiNode)->getNumIncomingValues();
2319 return wrap(unwrap<PHINode>(PhiNode)->getIncomingValue(Index));
2323 return wrap(unwrap<PHINode>(PhiNode)->getIncomingBlock(Index));
2330 if (
auto *
GEP = dyn_cast<GetElementPtrInst>(
I))
2331 return GEP->getNumIndices();
2332 if (
auto *EV = dyn_cast<ExtractValueInst>(
I))
2333 return EV->getNumIndices();
2334 if (
auto *IV = dyn_cast<InsertValueInst>(
I))
2335 return IV->getNumIndices();
2337 "LLVMGetNumIndices applies only to extractvalue and insertvalue!");
2342 if (
auto *EV = dyn_cast<ExtractValueInst>(
I))
2343 return EV->getIndices().data();
2344 if (
auto *IV = dyn_cast<InsertValueInst>(
I))
2345 return IV->getIndices().data();
2347 "LLVMGetIndices applies only to extractvalue and insertvalue!");
2364 auto I = Instr ? unwrap<Instruction>(Instr)->getIterator() : BB->
end();
2365 unwrap(Builder)->SetInsertPoint(BB,
I);
2375 unwrap(Builder)->SetInsertPoint(BB);
2379 return wrap(
unwrap(Builder)->GetInsertBlock());
2383 unwrap(Builder)->ClearInsertionPoint();
2387 unwrap(Builder)->Insert(unwrap<Instruction>(Instr));
2392 unwrap(Builder)->Insert(unwrap<Instruction>(Instr), Name);
2403 L ? cast<MDNode>(unwrap<MetadataAsValue>(
L)->getMetadata()) :
nullptr;
2410 Context,
unwrap(Builder)->getCurrentDebugLocation().getAsMDNode()));
2414 unwrap(Builder)->SetInstDebugLocation(unwrap<Instruction>(Inst));
2448 unsigned NumDests) {
2468 unwrap(B)->GetInsertBlock()->getParent()->setPersonalityFn(
2469 cast<Function>(
unwrap(PersFn)));
2483 unwrap<SwitchInst>(
Switch)->addCase(unwrap<ConstantInt>(OnVal),
unwrap(Dest));
2487 unwrap<IndirectBrInst>(IndirectBr)->addDestination(
unwrap(Dest));
2491 return unwrap<LandingPadInst>(LandingPad)->getNumClauses();
2495 return wrap(unwrap<LandingPadInst>(LandingPad)->getClause(Idx));
2499 unwrap<LandingPadInst>(LandingPad)->
2500 addClause(cast<Constant>(
unwrap(ClauseVal)));
2504 return unwrap<LandingPadInst>(LandingPad)->isCleanup();
2508 unwrap<LandingPadInst>(LandingPad)->setCleanup(Val);
2680 ITy,
unwrap(Ty), AllocSize,
2681 nullptr,
nullptr,
"");
2691 ITy,
unwrap(Ty), AllocSize,
2692 unwrap(Val),
nullptr,
"");
2765 return wrap(
unwrap(B)->CreateGEP(
nullptr,
unwrap(Pointer), IdxList, Name));
2773 unwrap(B)->CreateInBoundsGEP(
nullptr,
unwrap(Pointer), IdxList, Name));
2777 unsigned Idx,
const char *
Name) {
2778 return wrap(
unwrap(B)->CreateStructGEP(
nullptr,
unwrap(Pointer), Idx, Name));
2783 return wrap(
unwrap(B)->CreateGlobalString(Str, Name));
2788 return wrap(
unwrap(B)->CreateGlobalStringPtr(Str, Name));
2792 Value *
P = unwrap<Value>(MemAccessInst);
2793 if (
LoadInst *LI = dyn_cast<LoadInst>(P))
2794 return LI->isVolatile();
2799 Value *
P = unwrap<Value>(MemAccessInst);
2800 if (
LoadInst *LI = dyn_cast<LoadInst>(P))
2801 return LI->setVolatile(isVolatile);
2802 return cast<StoreInst>(
P)->setVolatile(isVolatile);
2806 Value *
P = unwrap<Value>(MemAccessInst);
2808 if (
LoadInst *LI = dyn_cast<LoadInst>(P))
2809 O = LI->getOrdering();
2811 O = cast<StoreInst>(
P)->getOrdering();
2816 Value *
P = unwrap<Value>(MemAccessInst);
2819 if (
LoadInst *LI = dyn_cast<LoadInst>(P))
2820 return LI->setOrdering(O);
2821 return cast<StoreInst>(
P)->setOrdering(O);
2936 return wrap(
unwrap(B)->CreateICmp(static_cast<ICmpInst::Predicate>(Op),
2943 return wrap(
unwrap(B)->CreateFCmp(static_cast<FCmpInst::Predicate>(Op),
2994 unsigned Index,
const char *
Name) {
3056 Value *
P = unwrap<Value>(AtomicInst);
3060 return cast<AtomicCmpXchgInst>(
P)->getSynchScope() ==
SingleThread;
3064 Value *
P = unwrap<Value>(AtomicInst);
3068 return I->setSynchScope(Sync);
3069 return cast<AtomicCmpXchgInst>(
P)->setSynchScope(Sync);
3073 Value *
P = unwrap<Value>(CmpXchgInst);
3079 Value *
P = unwrap<Value>(CmpXchgInst);
3082 return cast<AtomicCmpXchgInst>(
P)->setSuccessOrdering(O);
3086 Value *
P = unwrap<Value>(CmpXchgInst);
3092 Value *
P = unwrap<Value>(CmpXchgInst);
3095 return cast<AtomicCmpXchgInst>(
P)->setFailureOrdering(O);
3115 char **OutMessage) {
3118 if (std::error_code EC = MBOrErr.
getError()) {
3119 *OutMessage = strdup(EC.message().c_str());
3122 *OutMemBuf =
wrap(MBOrErr.
get().release());
3127 char **OutMessage) {
3129 if (std::error_code EC = MBOrErr.
getError()) {
3130 *OutMessage = strdup(EC.message().c_str());
3133 *OutMemBuf =
wrap(MBOrErr.
get().release());
3138 const char *InputData,
3139 size_t InputDataLength,
3140 const char *BufferName,
3145 RequiresNullTerminator).
release());
3149 const char *InputData,
3150 size_t InputDataLength,
3151 const char *BufferName) {
3159 return unwrap(MemBuf)->getBufferStart();
3163 return unwrap(MemBuf)->getBufferSize();
3188 reinterpret_cast<LLVMModuleRef>(P));
3192 return unwrap<legacy::PassManager>(PM)->run(*
unwrap(M));
3196 return unwrap<legacy::FunctionPassManager>(FPM)->doInitialization();
3200 return unwrap<legacy::FunctionPassManager>(FPM)->run(*unwrap<Function>(F));
3204 return unwrap<legacy::FunctionPassManager>(FPM)->doFinalization();
LLVMValueRef LLVMConstExactSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant)
LLVMValueRef LLVMConstInlineAsm(LLVMTypeRef Ty, const char *AsmString, const char *Constraints, LLVMBool HasSideEffects, LLVMBool IsAlignStack)
Subtract a value and return the old one.
static unsigned getBitWidth(Type *Ty, const DataLayout &DL)
Returns the bitwidth of the given scalar or pointer type (if unknown returns 0).
const char * LLVMGetBufferStart(LLVMMemoryBufferRef MemBuf)
static Constant * getFPTrunc(Constant *C, Type *Ty, bool OnlyIfReduced=false)
void LLVMDisposeBuilder(LLVMBuilderRef Builder)
void push_back(const T &Elt)
LLVMValueRef LLVMConstNamedStruct(LLVMTypeRef StructTy, LLVMValueRef *ConstantVals, unsigned Count)
Create a non-anonymous ConstantStruct from values.
use_iterator_impl< Use > use_iterator
LLVMValueRef LLVMInstructionClone(LLVMValueRef Inst)
Create a copy of 'this' instruction that is identical in all ways except the following: ...
LLVMRealPredicate LLVMGetFCmpPredicate(LLVMValueRef Inst)
Obtain the float predicate of an instruction.
std::error_code getError() const
LLVMBasicBlockRef LLVMInsertBasicBlockInContext(LLVMContextRef C, LLVMBasicBlockRef BBRef, const char *Name)
Insert a basic block in a function before another basic block.
Represents either an error or a value T.
void LLVMGetStructElementTypes(LLVMTypeRef StructTy, LLVMTypeRef *Dest)
Get the elements within a structure.
void LLVMGetParams(LLVMValueRef FnRef, LLVMValueRef *ParamRefs)
Obtain the parameters in a function.
LLVMValueRef LLVMGetInitializer(LLVMValueRef GlobalVar)
LLVMValueRef LLVMBuildICmp(LLVMBuilderRef B, LLVMIntPredicate Op, LLVMValueRef LHS, LLVMValueRef RHS, const char *Name)
static Constant * getString(LLVMContext &Context, StringRef Initializer, bool AddNull=true)
This method constructs a CDS and initializes it with a text string.
static Type * getDoubleTy(LLVMContext &C)
void LLVMSetCmpXchgFailureOrdering(LLVMValueRef CmpXchgInst, LLVMAtomicOrdering Ordering)
raw_ostream & errs()
This returns a reference to a raw_ostream for standard error.
static IntegerType * getInt1Ty(LLVMContext &C)
unsigned LLVMGetPointerAddressSpace(LLVMTypeRef PointerTy)
Obtain the address space of a pointer type.
static Constant * getFAdd(Constant *C1, Constant *C2)
void addIncoming(Value *V, BasicBlock *BB)
Add an incoming value to the end of the PHI list.
Special purpose, only applies to global arrays.
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
LLVMBool LLVMHasPersonalityFn(LLVMValueRef Fn)
Check whether the given function has a personality function.
static MDNode * extractMDNode(MetadataAsValue *MAV)
LLVMContext & getContext() const
getContext - Return a reference to the LLVMContext associated with this function. ...
*p = old <signed v ? old : v
LLVMValueRef LLVMBuildArrayAlloca(LLVMBuilderRef B, LLVMTypeRef Ty, LLVMValueRef Val, const char *Name)
LLVMValueRef LLVMConstXor(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant)
LLVMValueRef LLVMBuildZExt(LLVMBuilderRef B, LLVMValueRef Val, LLVMTypeRef DestTy, const char *Name)
static LLVMValueRef getMDNodeOperandImpl(LLVMContext &Context, const MDNode *N, unsigned Index)
LLVMBasicBlockRef LLVMGetEntryBasicBlock(LLVMValueRef Fn)
Obtain the basic block that corresponds to the entry point of a function.
LLVMValueRef LLVMGetLastFunction(LLVMModuleRef M)
Obtain an iterator to the last Function in a Module.
LLVMValueRef LLVMConstBitCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType)
LLVM Argument representation.
Not-And a value and return the old one.
LLVMValueRef LLVMBuildAtomicCmpXchg(LLVMBuilderRef B, LLVMValueRef Ptr, LLVMValueRef Cmp, LLVMValueRef New, LLVMAtomicOrdering SuccessOrdering, LLVMAtomicOrdering FailureOrdering, LLVMBool singleThread)
LLVMValueRef LLVMConstUDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant)
Externally visible function.
LLVMBool LLVMTypeIsSized(LLVMTypeRef Ty)
Whether the type has a known size.
LLVMValueRef LLVMConstSDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant)
void LLVMSetSection(LLVMValueRef Global, const char *Section)
unsigned LLVMAttributeIndex
struct LLVMOpaqueModule * LLVMModuleRef
The top-level container for all other LLVM Intermediate Representation (IR) objects.
LLVMMemoryBufferRef LLVMCreateMemoryBufferWithMemoryRangeCopy(const char *InputData, size_t InputDataLength, const char *BufferName)
provides both an Acquire and a Release barrier (for fences and operations which both read and write m...
const char * LLVMGetAsString(LLVMValueRef C, size_t *Length)
Get the given constant data sequential as a string.
LLVMValueRef LLVMGetIncomingValue(LLVMValueRef PhiNode, unsigned Index)
Obtain an incoming value to a PHI node as an LLVMValueRef.
static Constant * getNSWAdd(Constant *C1, Constant *C2)
void initializePrintModulePassWrapperPass(PassRegistry &)
A Module instance is used to store all the information related to an LLVM module. ...
struct LLVMOpaqueMemoryBuffer * LLVMMemoryBufferRef
LLVM uses a polymorphic type hierarchy which C cannot represent, therefore parameters must be passed ...
void LLVMSetSuccessor(LLVMValueRef Term, unsigned i, LLVMBasicBlockRef block)
Update the specified successor to point at the provided block.
float convertToFloat() const
LLVMValueRef LLVMBuildAdd(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, const char *Name)
LLVMBuilderRef LLVMCreateBuilder(void)
LLVMValueRef LLVMGetNextParam(LLVMValueRef Arg)
Obtain the next parameter to a function.
2: 32-bit floating point type
Same, but only replaced by something equivalent.
LLVMValueRef LLVMBuildNUWAdd(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, const char *Name)
static MDString * get(LLVMContext &Context, StringRef Str)
LLVMValueRef LLVMBuildStructGEP(LLVMBuilderRef B, LLVMValueRef Pointer, unsigned Idx, const char *Name)
LLVMAttributeRef LLVMGetEnumAttributeAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx, unsigned KindID)
LLVMValueRef LLVMGetNamedGlobal(LLVMModuleRef M, const char *Name)
LLVMBool LLVMIsOpaqueStruct(LLVMTypeRef StructTy)
Determine whether a structure is opaque.
LLVMMemoryBufferRef LLVMCreateMemoryBufferWithMemoryRange(const char *InputData, size_t InputDataLength, const char *BufferName, LLVMBool RequiresNullTerminator)
static Constant * getAnon(ArrayRef< Constant * > V, bool Packed=false)
Return an anonymous struct that has the specified elements.
LLVMValueRef LLVMGetFirstParam(LLVMValueRef Fn)
Obtain the first parameter to a function.
LLVMValueRef LLVMBuildSExt(LLVMBuilderRef B, LLVMValueRef Val, LLVMTypeRef DestTy, const char *Name)
LLVMValueRef LLVMAddAlias(LLVMModuleRef M, LLVMTypeRef Ty, LLVMValueRef Aliasee, const char *Name)
LLVMAttributeRef LLVMCreateStringAttribute(LLVMContextRef C, const char *K, unsigned KLength, const char *V, unsigned VLength)
Create a string attribute.
LLVMValueRef LLVMAlignOf(LLVMTypeRef Ty)
LLVMBool LLVMHasUnnamedAddr(LLVMValueRef Global)
Available for inspection, not emission.
void LLVMStopMultithreaded()
Deprecated: Multi-threading can only be enabled/disabled with the compile time define LLVM_ENABLE_THR...
LLVMValueRef LLVMConstRealOfStringAndSize(LLVMTypeRef RealTy, const char Str[], unsigned SLen)
void LLVMSetValueName(LLVMValueRef Val, const char *Name)
Set the string name of a value.
static Constant * getAddrSpaceCast(Constant *C, Type *Ty, bool OnlyIfReduced=false)
LLVMValueRef LLVMConstFPToUI(LLVMValueRef ConstantVal, LLVMTypeRef ToType)
Type::subtype_iterator param_iterator
const char * LLVMGetGC(LLVMValueRef Fn)
Obtain the name of the garbage collector to use during code generation.
LLVMPassManagerRef LLVMCreateFunctionPassManager(LLVMModuleProviderRef P)
Deprecated: Use LLVMCreateFunctionPassManagerForModule instead.
LLVMValueRef LLVMAddGlobal(LLVMModuleRef M, LLVMTypeRef Ty, const char *Name)
LLVMTypeRef LLVMGetAllocatedType(LLVMValueRef Alloca)
Obtain the type that is being allocated by the alloca instruction.
LLVMTypeRef LLVMHalfType(void)
Obtain a floating point type from the global context.
static std::unique_ptr< MemoryBuffer > getMemBuffer(StringRef InputData, StringRef BufferName="", bool RequiresNullTerminator=true)
Open the specified memory range as a MemoryBuffer.
LLVMValueRef LLVMBuildRet(LLVMBuilderRef B, LLVMValueRef V)
LLVMAttributeRef LLVMCreateEnumAttribute(LLVMContextRef C, unsigned KindID, uint64_t Val)
Create an enum attribute.
LLVMBasicBlockRef LLVMGetNextBasicBlock(LLVMBasicBlockRef BB)
Advance a basic block iterator.
LLVMBool LLVMCreateMemoryBufferWithContentsOfFile(const char *Path, LLVMMemoryBufferRef *OutMemBuf, char **OutMessage)
A global registry used in conjunction with static constructors to make pluggable components (like tar...
char * LLVMCreateMessage(const char *Message)
LLVMPassManagerRef LLVMCreatePassManager()
Constructs a new whole-module pass pipeline.
void addOperand(MDNode *M)
LLVMTypeRef LLVMFP128Type(void)
LLVMValueRef LLVMGetClause(LLVMValueRef LandingPad, unsigned Idx)
static Constant * getExactSDiv(Constant *C1, Constant *C2)
void setGC(std::string Str)
void setAttributes(AttributeSet PAL)
LLVMValueRef LLVMBuildFPToUI(LLVMBuilderRef B, LLVMValueRef Val, LLVMTypeRef DestTy, const char *Name)
static PointerType * get(Type *ElementType, unsigned AddressSpace)
This constructs a pointer to an object of the specified type in a numbered address space...
#define LLVM_FOR_EACH_VALUE_SUBCLASS(macro)
unsigned LLVMGetVectorSize(LLVMTypeRef VectorTy)
Obtain the number of elements in a vector type.
void(* LLVMDiagnosticHandler)(LLVMDiagnosticInfoRef, void *)
static Constant * getGetElementPtr(Type *Ty, Constant *C, ArrayRef< Constant * > IdxList, bool InBounds=false, Optional< unsigned > InRangeIndex=None, Type *OnlyIfReducedTy=nullptr)
Getelementptr form.
LLVMDiagnosticSeverity LLVMGetDiagInfoSeverity(LLVMDiagnosticInfoRef DI)
Return an enum LLVMDiagnosticSeverity.
*p = old <unsigned v ? old : v
static Constant * getIntToPtr(Constant *C, Type *Ty, bool OnlyIfReduced=false)
LLVMBool LLVMIsAtomicSingleThread(LLVMValueRef AtomicInst)
static Constant * getExtractElement(Constant *Vec, Constant *Idx, Type *OnlyIfReducedTy=nullptr)
const char * LLVMGetDataLayoutStr(LLVMModuleRef M)
Obtain the data layout for a module.
LLVMValueRef LLVMBuildCondBr(LLVMBuilderRef B, LLVMValueRef If, LLVMBasicBlockRef Then, LLVMBasicBlockRef Else)
Like Internal, but omit from symbol table.
LLVMTypeRef LLVMX86MMXType(void)
*p = old >unsigned v ? old : v
Externally visible function.
LLVMValueRef LLVMBuildFNeg(LLVMBuilderRef B, LLVMValueRef V, const char *Name)
LLVMValueRef LLVMBuildTruncOrBitCast(LLVMBuilderRef B, LLVMValueRef Val, LLVMTypeRef DestTy, const char *Name)
struct LLVMOpaquePassRegistry * LLVMPassRegistryRef
unsigned LLVMGetNumArgOperands(LLVMValueRef Instr)
Obtain the argument count for a call instruction.
struct LLVMOpaqueBuilder * LLVMBuilderRef
Represents an LLVM basic block builder.
const Function * getParent() const
Return the enclosing method, or null if none.
LLVMValueRef LLVMBuildSDiv(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, const char *Name)
unsigned LLVMGetLastEnumAttributeKind(void)
LLVMTypeRef LLVMX86FP80Type(void)
LLVMUseRef LLVMGetFirstUse(LLVMValueRef Val)
Obtain the first use of a value.
void LLVMClearInsertionPosition(LLVMBuilderRef Builder)
LLVMValueRef LLVMGetNextGlobal(LLVMValueRef GlobalVar)
4: 80-bit floating point type (X87)
LLVMTypeRef LLVMVectorType(LLVMTypeRef ElementType, unsigned ElementCount)
Create a vector type that contains a defined type and has a specific number of elements.
LLVMValueRef LLVMConstAnd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant)
unsigned LLVMGetMDKindIDInContext(LLVMContextRef C, const char *Name, unsigned SLen)
LLVMPassRegistryRef LLVMGetGlobalPassRegistry(void)
Return the global pass registry, for use with initialization functions.
LLVMValueRef LLVMBuildCast(LLVMBuilderRef B, LLVMOpcode Op, LLVMValueRef Val, LLVMTypeRef DestTy, const char *Name)
LLVMValueRef LLVMBuildFRem(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, const char *Name)
An instruction for reading from memory.
LLVMValueRef LLVMConstSelect(LLVMValueRef ConstantCondition, LLVMValueRef ConstantIfTrue, LLVMValueRef ConstantIfFalse)
1: 16-bit floating point type
LLVMValueRef LLVMConstTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType)
unsigned getBitWidth() const
Get the number of bits in this IntegerType.
LLVMBool LLVMValueIsBasicBlock(LLVMValueRef Val)
Determine whether an LLVMValueRef is itself a basic block.
static IntegerType * getInt64Ty(LLVMContext &C)
FunctionType * getType(LLVMContext &Context, ID id, ArrayRef< Type * > Tys=None)
Return the function type for an intrinsic.
LLVMTypeRef LLVMStructTypeInContext(LLVMContextRef C, LLVMTypeRef *ElementTypes, unsigned ElementCount, LLVMBool Packed)
Create a new structure type in a context.
AttrBuilder & addAttribute(Attribute::AttrKind Val)
Add an attribute to the builder.
an instruction that atomically reads a memory location, combines it with another value, and then stores the result back.
LLVMBasicBlockRef LLVMInsertBasicBlock(LLVMBasicBlockRef BBRef, const char *Name)
Insert a basic block in a function using the global context.
int LLVMHasMetadata(LLVMValueRef Inst)
Determine whether an instruction has any metadata attached.
static Constant * getSub(Constant *C1, Constant *C2, bool HasNUW=false, bool HasNSW=false)
const char * LLVMGetSection(LLVMValueRef Global)
static Instruction * CreateFree(Value *Source, Instruction *InsertBefore)
Generate the IR for a call to the builtin free function.
LLVMTypeRef LLVMInt16TypeInContext(LLVMContextRef C)
LLVMValueRef LLVMBuildFence(LLVMBuilderRef B, LLVMAtomicOrdering Ordering, LLVMBool isSingleThread, const char *Name)
void initializeCore(PassRegistry &)
Initialize all passes linked into the TransformUtils library.
static IntegerType * getInt16Ty(LLVMContext &C)
const Constant * getInitializer() const
getInitializer - Return the initializer for this global variable.
LLVMAttributeRef LLVMGetStringAttributeAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx, const char *K, unsigned KLen)
static Type * getX86_MMXTy(LLVMContext &C)
LLVMValueRef LLVMConstIntOfString(LLVMTypeRef IntTy, const char Str[], uint8_t Radix)
*p = old >signed v ? old : v
LLVMValueRef LLVMConstAddrSpaceCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType)
Lowest level of atomicity, guarantees somewhat sane results, lock free.
static Type * getX86_FP80Ty(LLVMContext &C)
void LLVMContextDispose(LLVMContextRef C)
Destroy a context instance.
128 bit floating point type (112-bit mantissa)
void LLVMSetGlobalConstant(LLVMValueRef GlobalVar, LLVMBool IsConstant)
void LLVMSetThreadLocal(LLVMValueRef GlobalVar, LLVMBool IsThreadLocal)
void LLVMSetModuleIdentifier(LLVMModuleRef M, const char *Ident, size_t Len)
Set the identifier of a module to a string Ident with length Len.
static Constant * getInsertElement(Constant *Vec, Constant *Elt, Constant *Idx, Type *OnlyIfReducedTy=nullptr)
ExternalWeak linkage description.
LLVMValueRef LLVMConstNull(LLVMTypeRef Ty)
Obtain a constant value referring to the null instance of a type.
LLVMValueRef LLVMConstReal(LLVMTypeRef RealTy, double N)
Obtain a constant value referring to a double floating point value.
LLVMValueRef LLVMBuildPointerCast(LLVMBuilderRef B, LLVMValueRef Val, LLVMTypeRef DestTy, const char *Name)
static Constant * getNullValue(Type *Ty)
Constructor to create a '0' constant of arbitrary type.
LLVMBool LLVMInitializeFunctionPassManager(LLVMPassManagerRef FPM)
Initializes all of the function passes scheduled in the function pass manager.
void LLVMRemoveCallSiteStringAttribute(LLVMValueRef C, LLVMAttributeIndex Idx, const char *K, unsigned KLen)
void LLVMSetOperand(LLVMValueRef Val, unsigned Index, LLVMValueRef Op)
Set an operand at a specific index in a llvm::User value.
iterator begin()
Instruction iterator methods.
long long LLVMConstIntGetSExtValue(LLVMValueRef ConstantVal)
Obtain the sign extended value for an integer constant value.
static Constant * getAdd(Constant *C1, Constant *C2, bool HasNUW=false, bool HasNSW=false)
static Constant * getFMul(Constant *C1, Constant *C2)
void addAttr(AttributeSet AS)
Add a Attribute to an argument.
element_iterator element_end() const
void LLVMSetInstrParamAlignment(LLVMValueRef Instr, unsigned index, unsigned align)
void initializeDominatorTreeWrapperPassPass(PassRegistry &)
LLVMTypeRef LLVMStructGetTypeAtIndex(LLVMTypeRef StructTy, unsigned i)
Get the type of the element at a given index in the structure.
LLVMOpcode LLVMGetInstructionOpcode(LLVMValueRef Inst)
Obtain the code opcode for an individual instruction.
LLVMTypeRef LLVMFP128TypeInContext(LLVMContextRef C)
Obtain a 128-bit floating point type (112-bit mantissa) from a context.
const char * LLVMGetStructName(LLVMTypeRef Ty)
Obtain the name of a structure.
StringRef getKindAsString() const
Return the attribute's kind as a string.
LLVMBasicBlockRef LLVMGetLastBasicBlock(LLVMValueRef Fn)
Obtain the last basic block in a function.
static LLVMAtomicOrdering mapToLLVMOrdering(AtomicOrdering Ordering)
Same, but only replaced by something equivalent.
LLVMValueRef LLVMBasicBlockAsValue(LLVMBasicBlockRef BB)
Convert a basic block instance to a value type.
static Constant * getIntegerCast(Constant *C, Type *Ty, bool isSigned)
Create a ZExt, Bitcast or Trunc for integer -> integer casts.
LLVMTypeRef LLVMLabelTypeInContext(LLVMContextRef C)
Create a label type in a context.
LLVMTypeRef LLVMDoubleTypeInContext(LLVMContextRef C)
Obtain a 64-bit floating point type from a context.
static Type * getTokenTy(LLVMContext &C)
static ManagedStatic< LLVMContext > GlobalContext
LLVMValueRef LLVMConstVector(LLVMValueRef *ScalarConstantVals, unsigned Size)
Create a ConstantVector from values.
bool hasGC() const
hasGC/getGC/setGC/clearGC - The name of the garbage collection algorithm to use during code generatio...
bool has_error() const
Return the value of the flag in this raw_fd_ostream indicating whether an output error has been encou...
Set the new value and return the one old.
LLVMValueRef LLVMBuildExactSDiv(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, const char *Name)
void(* LLVMYieldCallback)(LLVMContextRef, void *)
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Type::subtype_iterator element_iterator
LLVMValueRef LLVMSizeOf(LLVMTypeRef Ty)
LLVMBool LLVMIsNull(LLVMValueRef Val)
Determine whether a value instance is null.
Attribute unwrap(LLVMAttributeRef Attr)
static Type * getFloatTy(LLVMContext &C)
LLVMValueRef LLVMConstShuffleVector(LLVMValueRef VectorAConstant, LLVMValueRef VectorBConstant, LLVMValueRef MaskConstant)
ArrayRef< T > makeArrayRef(const T &OneElt)
Construct an ArrayRef from a single element.
LLVMBasicBlockRef LLVMGetSwitchDefaultDest(LLVMValueRef Switch)
Obtain the default destination basic block of a switch instruction.
LLVMValueRef LLVMConstRealOfString(LLVMTypeRef RealTy, const char *Text)
Obtain a constant for a floating point value parsed from a string.
LLVMValueRef LLVMBuildAggregateRet(LLVMBuilderRef B, LLVMValueRef *RetVals, unsigned N)
Class to represent struct types.
Sets the value if it's greater than the original using an unsigned comparison and return the old one...
A Use represents the edge between a Value definition and its users.
static Constant * getLShr(Constant *C1, Constant *C2, bool isExact=false)
param_iterator param_end() const
static Constant * getNUWNeg(Constant *C)
LLVMValueRef LLVMConstIntOfStringAndSize(LLVMTypeRef IntTy, const char Str[], unsigned SLen, uint8_t Radix)
Add a value and return the old one.
void LLVMPositionBuilder(LLVMBuilderRef Builder, LLVMBasicBlockRef Block, LLVMValueRef Instr)
LLVMTypeRef LLVMInt8TypeInContext(LLVMContextRef C)
unsigned LLVMGetFunctionCallConv(LLVMValueRef Fn)
Obtain the calling function of a function.
LLVMValueRef LLVMConstIntCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType, LLVMBool isSigned)
LLVMValueRef LLVMConstNUWAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant)
static Constant * get(ArrayRef< Constant * > V)
This provides a uniform API for creating instructions and inserting them into a basic block: either a...
void setThreadLocalMode(ThreadLocalMode Val)
void LLVMSetDataLayout(LLVMModuleRef M, const char *DataLayoutStr)
Set the data layout for a module.
LLVMValueRef LLVMConstFSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant)
unsigned LLVMGetIntTypeWidth(LLVMTypeRef IntegerTy)
This file contains the simple types necessary to represent the attributes associated with functions a...
LLVMBool LLVMIsExternallyInitialized(LLVMValueRef GlobalVar)
static Constant * getSExt(Constant *C, Type *Ty, bool OnlyIfReduced=false)
LLVMValueRef LLVMConstAShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant)
LLVMValueRef LLVMGetBasicBlockParent(LLVMBasicBlockRef BB)
Obtain the function to which a basic block belongs.
void LLVMSetCondition(LLVMValueRef Branch, LLVMValueRef Cond)
Set the condition of a branch instruction.
LLVMValueRef LLVMGetLastParam(LLVMValueRef Fn)
Obtain the last parameter to a function.
LLVMValueRef LLVMConstICmp(LLVMIntPredicate Predicate, LLVMValueRef LHSConstant, LLVMValueRef RHSConstant)
element_iterator element_begin() const
LLVMValueRef LLVMGetUndef(LLVMTypeRef Ty)
Obtain a constant value referring to an undefined value of a type.
Rename collisions when linking (static functions)
void addAttributes(unsigned i, AttributeSet Attrs)
adds the attributes to the list of attributes.
uint64_t LLVMGetEnumAttributeValue(LLVMAttributeRef A)
Get the enum attribute's value.
LLVMBool LLVMIsCleanup(LLVMValueRef LandingPad)
void LLVMSetVisibility(LLVMValueRef Global, LLVMVisibility Viz)
static Type * getPPC_FP128Ty(LLVMContext &C)
void LLVMSetNormalDest(LLVMValueRef Invoke, LLVMBasicBlockRef B)
Set the normal destination basic block.
LLVMValueRef LLVMConstSExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType)
void LLVMContextSetDiagnosticHandler(LLVMContextRef C, LLVMDiagnosticHandler Handler, void *DiagnosticContext)
Set the diagnostic handler for this context.
LLVMValueRef LLVMGetPreviousGlobal(LLVMValueRef GlobalVar)
LLVMValueRef LLVMBuildNSWAdd(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, const char *Name)
LLVMBool LLVMIsStringAttribute(LLVMAttributeRef A)
Expected< const typename ELFT::Shdr * > getSection(typename ELFT::ShdrRange Sections, uint32_t Index)
SIMD 'packed' format, or other vector type.
LLVMValueRef LLVMGetFirstInstruction(LLVMBasicBlockRef BB)
Obtain the first instruction in a basic block.
LLVMTypeRef LLVMFloatType(void)
AtomicOrdering
Atomic ordering for LLVM's memory model.
global_iterator global_begin()
void LLVMDisposeMessage(char *Message)
A load or store which is not atomic.
LLVMValueRef LLVMConstFPCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType)
LLVMValueRef LLVMBuildSRem(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, const char *Name)
struct LLVMOpaqueType * LLVMTypeRef
Each value in the LLVM IR has a type, an LLVMTypeRef.
LLVMValueRef LLVMGetPreviousInstruction(LLVMValueRef Inst)
Obtain the instruction that occurred before this one.
void LLVMContextSetYieldCallback(LLVMContextRef C, LLVMYieldCallback Callback, void *OpaqueHandle)
Set the yield callback function for this context.
static Constant * getZExt(Constant *C, Type *Ty, bool OnlyIfReduced=false)
void LLVMMoveBasicBlockBefore(LLVMBasicBlockRef BB, LLVMBasicBlockRef MovePos)
Move a basic block to before another one.
static Constant * getSizeOf(Type *Ty)
getSizeOf constant expr - computes the (alloc) size of a type (in address-units, not bits) in a targe...
LLVMValueRef LLVMConstInsertElement(LLVMValueRef VectorConstant, LLVMValueRef ElementValueConstant, LLVMValueRef IndexConstant)
void LLVMGetParamTypes(LLVMTypeRef FunctionTy, LLVMTypeRef *Dest)
Obtain the types of a function's parameters.
A constant value that is initialized with an expression using other constant values.
Class to represent function types.
char * LLVMPrintModuleToString(LLVMModuleRef M)
Return a string representation of the module.
static Type * getLabelTy(LLVMContext &C)
CallingConv::ID getCallingConv() const
getCallingConv/setCallingConv - get or set the calling convention of the call.
void LLVMDisposeModule(LLVMModuleRef M)
Destroy a module instance.
void LLVMSetInstDebugLocation(LLVMBuilderRef Builder, LLVMValueRef Inst)
opStatus convert(const fltSemantics &ToSemantics, roundingMode RM, bool *losesInfo)
LLVMBool LLVMIsGlobalConstant(LLVMValueRef GlobalVar)
LLVMContext & getContext() const
Return the LLVMContext in which this type was uniqued.
LLVMValueRef LLVMConstStructInContext(LLVMContextRef C, LLVMValueRef *ConstantVals, unsigned Count, LLVMBool Packed)
Create an anonymous ConstantStruct with the specified values.
static Constant * getFPCast(Constant *C, Type *Ty)
Create a FPExt, Bitcast or FPTrunc for fp -> fp casts.
LLVMBool LLVMIsTailCall(LLVMValueRef Call)
Obtain whether a call instruction is a tail call.
LLVMValueRef LLVMBlockAddress(LLVMValueRef F, LLVMBasicBlockRef BB)
void llvm_shutdown()
llvm_shutdown - Deallocate and destroy all ManagedStatic variables.
LLVMValueRef LLVMConstZExtOrBitCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType)
BinOp
This enumeration lists the possible modifications atomicrmw can make.
LLVMValueRef LLVMConstGEP(LLVMValueRef ConstantVal, LLVMValueRef *ConstantIndices, unsigned NumIndices)
struct LLVMOpaqueUse * LLVMUseRef
Used to get the users and usees of a Value.
LLVMValueRef LLVMConstInBoundsGEP(LLVMValueRef ConstantVal, LLVMValueRef *ConstantIndices, unsigned NumIndices)
Keep one copy of function when linking (inline)
static Constant * getAShr(Constant *C1, Constant *C2, bool isExact=false)
LLVMValueRef LLVMBuildOr(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, const char *Name)
void LLVMDeleteFunction(LLVMValueRef Fn)
Remove a function from its containing module and deletes it.
void LLVMRemoveCallSiteEnumAttribute(LLVMValueRef C, LLVMAttributeIndex Idx, unsigned KindID)
struct LLVMOpaqueContext * LLVMContextRef
The top-level container for all LLVM global data.
LLVMValueRef LLVMBuildFDiv(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, const char *Name)
LLVMValueRef LLVMConstFPToSI(LLVMValueRef ConstantVal, LLVMTypeRef ToType)
OR a value and return the old one.
LLVMBasicBlockRef LLVMGetPreviousBasicBlock(LLVMBasicBlockRef BB)
Go backwards in a basic block iterator.
This instruction compares its operands according to the predicate given to the constructor.
static Constant * getSelect(Constant *C, Constant *V1, Constant *V2, Type *OnlyIfReducedTy=nullptr)
Select constant expr.
LLVMValueRef LLVMGetFirstGlobal(LLVMModuleRef M)
void LLVMDumpModule(LLVMModuleRef M)
Dump a representation of a module to stderr.
static FunctionType * get(Type *Result, ArrayRef< Type * > Params, bool isVarArg)
This static method is the primary way of constructing a FunctionType.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
unsigned LLVMCountIncoming(LLVMValueRef PhiNode)
Obtain the number of incoming basic blocks to a PHI node.
LLVMValueRef LLVMBuildIntCast(LLVMBuilderRef B, LLVMValueRef Val, LLVMTypeRef DestTy, const char *Name)
LLVMTypeRef LLVMFloatTypeInContext(LLVMContextRef C)
Obtain a 32-bit floating point type from a context.
unsigned long long LLVMConstIntGetZExtValue(LLVMValueRef ConstantVal)
Obtain the zero extended value for an integer constant value.
static int map_from_llvmopcode(LLVMOpcode code)
static GCRegistry::Add< OcamlGC > B("ocaml","ocaml 3.10-compatible GC")
An instruction for storing to memory.
LLVMValueRef LLVMConstFMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant)
LLVMValueRef LLVMGetLastInstruction(LLVMBasicBlockRef BB)
Obtain the last instruction in a basic block.
LLVMValueRef LLVMBuildSub(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, const char *Name)
#define LLVM_EXTENSION
LLVM_EXTENSION - Support compilers where we have a keyword to suppress pedantic diagnostics.
LLVMUseRef LLVMGetNextUse(LLVMUseRef U)
Obtain the next use of a value.
LLVMValueRef LLVMAddFunction(LLVMModuleRef M, const char *Name, LLVMTypeRef FunctionTy)
Add a function to a module under a specified name.
LLVMValueRef LLVMBuildFAdd(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, const char *Name)
static Constant * getUDiv(Constant *C1, Constant *C2, bool isExact=false)
static Constant * getNSWNeg(Constant *C)
Keep one copy of function when linking (weak)
unsigned LLVMCountParamTypes(LLVMTypeRef FunctionTy)
Obtain the number of parameters this function accepts.
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE size_t size() const
size - Get the string size.
LLVMValueRef LLVMBuildNUWSub(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, const char *Name)
struct LLVMOpaqueAttributeRef * LLVMAttributeRef
Used to represent an attributes.
LLVMValueRef LLVMBuildPtrToInt(LLVMBuilderRef B, LLVMValueRef Val, LLVMTypeRef DestTy, const char *Name)
static Constant * getFDiv(Constant *C1, Constant *C2)
LLVMTypeRef LLVMStructCreateNamed(LLVMContextRef C, const char *Name)
Create an empty structure in a context having a specified name.
LLVMValueRef LLVMConstInt(LLVMTypeRef IntTy, unsigned long long N, LLVMBool SignExtend)
Obtain a constant value for an integer type.
static BinaryOperator * CreateAdd(Value *S1, Value *S2, const Twine &Name, Instruction *InsertBefore, Value *FlagsOp)
size_t LLVMGetBufferSize(LLVMMemoryBufferRef MemBuf)
LLVMValueRef LLVMBuildAnd(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, const char *Name)
void LLVMSetCmpXchgSuccessOrdering(LLVMValueRef CmpXchgInst, LLVMAtomicOrdering Ordering)
void LLVMSetLinkage(LLVMValueRef Global, LLVMLinkage Linkage)
static GCRegistry::Add< CoreCLRGC > E("coreclr","CoreCLR-compatible GC")
void initializePrintBasicBlockPassPass(PassRegistry &)
unsigned LLVMGetIntrinsicID(LLVMValueRef Fn)
Obtain the ID number from a function instance.
void LLVMAddTargetDependentFunctionAttr(LLVMValueRef Fn, const char *A, const char *V)
Add a target-dependent attribute to a function.
LLVMBasicBlockRef LLVMGetInstructionParent(LLVMValueRef Inst)
Obtain the basic block to which an instruction belongs.
LLVMTypeRef LLVMInt64TypeInContext(LLVMContextRef C)
LLVMValueRef LLVMGetLastGlobal(LLVMModuleRef M)
const char * LLVMGetBasicBlockName(LLVMBasicBlockRef BB)
Obtain the string name of a basic block.
LLVMAttributeRef LLVMGetCallSiteStringAttribute(LLVMValueRef C, LLVMAttributeIndex Idx, const char *K, unsigned KLen)
LLVMValueRef LLVMConstAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant)
unsigned LLVMGetArrayLength(LLVMTypeRef ArrayTy)
Obtain the length of an array type.
void LLVMDisposePassManager(LLVMPassManagerRef PM)
Frees the memory of a pass pipeline.
LLVMValueRef LLVMBuildIsNull(LLVMBuilderRef B, LLVMValueRef Val, const char *Name)
void LLVMSetVolatile(LLVMValueRef MemAccessInst, LLVMBool isVolatile)
LLVMTypeRef LLVMVoidTypeInContext(LLVMContextRef C)
Create a void type in a context.
11: Arbitrary bit width integers
PassManager manages ModulePassManagers.
static Constant * getBitCast(Constant *C, Type *Ty, bool OnlyIfReduced=false)
#define LLVM_DEFINE_VALUE_CAST(name)
ExternalWeak linkage description.
void LLVMSetUnnamedAddr(LLVMValueRef Global, LLVMBool HasUnnamedAddr)
LLVMValueRef LLVMConstNSWAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant)
LLVMValueRef LLVMConstNSWNeg(LLVMValueRef ConstantVal)
void LLVMSetTarget(LLVMModuleRef M, const char *Triple)
Set the target triple for a module.
static Constant * getInsertValue(Constant *Agg, Constant *Val, ArrayRef< unsigned > Idxs, Type *OnlyIfReducedTy=nullptr)
Same, but only replaced by something equivalent.
static Constant * getFNeg(Constant *C)
LLVMBasicBlockRef LLVMGetFirstBasicBlock(LLVMValueRef Fn)
Obtain the first basic block in a function.
LLVMValueRef LLVMBuildNUWNeg(LLVMBuilderRef B, LLVMValueRef V, const char *Name)
void LLVMSetCurrentDebugLocation(LLVMBuilderRef Builder, LLVMValueRef L)
const unsigned * LLVMGetIndices(LLVMValueRef Inst)
Obtain the indices as an array.
static Constant * getFRem(Constant *C1, Constant *C2)
void LLVMPositionBuilderAtEnd(LLVMBuilderRef Builder, LLVMBasicBlockRef Block)
void LLVMStructSetBody(LLVMTypeRef StructTy, LLVMTypeRef *ElementTypes, unsigned ElementCount, LLVMBool Packed)
Set the contents of a structure type.
LLVMValueRef LLVMBuildShl(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, const char *Name)
static ErrorOr< std::unique_ptr< MemoryBuffer > > getSTDIN()
Read all of stdin into a file buffer, and return it.
static IntegerType * getInt128Ty(LLVMContext &C)
Acquire provides a barrier of the sort necessary to acquire a lock to access other memory with normal...
static Constant * getInBoundsGetElementPtr(Type *Ty, Constant *C, ArrayRef< Constant * > IdxList)
Create an "inbounds" getelementptr.
LLVMValueRef LLVMBuildInsertElement(LLVMBuilderRef B, LLVMValueRef VecVal, LLVMValueRef EltVal, LLVMValueRef Index, const char *Name)
static ConstantPointerNull * get(PointerType *T)
Static factory methods - Return objects of the specified value.
LLVMValueRef LLVMBuildAlloca(LLVMBuilderRef B, LLVMTypeRef Ty, const char *Name)
LLVMTypeRef LLVMInt32Type(void)
void LLVMGetAttributesAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx, LLVMAttributeRef *Attrs)
LLVMValueRef LLVMBuildPhi(LLVMBuilderRef B, LLVMTypeRef Ty, const char *Name)
LLVM Basic Block Representation.
LLVMValueRef LLVMIsAMDString(LLVMValueRef Val)
Sets the value if it's greater than the original using an unsigned comparison and return the old one...
LLVMValueRef LLVMGetMetadata(LLVMValueRef Inst, unsigned KindID)
Return metadata associated with an instruction value.
The instances of the Type class are immutable: once they are created, they are never changed...
void LLVMAddClause(LLVMValueRef LandingPad, LLVMValueRef ClauseVal)
unsigned LLVMCountBasicBlocks(LLVMValueRef FnRef)
Obtain the number of basic blocks in a function.
This is an important class for using LLVM in a threaded context.
const Function * getParent() const
LLVMBool LLVMIsPackedStruct(LLVMTypeRef StructTy)
Determine whether a structure is packed.
void LLVMReplaceAllUsesWith(LLVMValueRef OldVal, LLVMValueRef NewVal)
Replace all uses of a value with another one.
LLVMValueRef LLVMBuildFPToSI(LLVMBuilderRef B, LLVMValueRef Val, LLVMTypeRef DestTy, const char *Name)
LLVMBool LLVMStartMultithreaded()
Deprecated: Multi-threading can only be enabled/disabled with the compile time define LLVM_ENABLE_THR...
LLVMDiagnosticHandler LLVMContextGetDiagnosticHandler(LLVMContextRef C)
Get the diagnostic handler of this context.
LLVMContextRef LLVMGetModuleContext(LLVMModuleRef M)
Obtain the context to which this module is associated.
LLVMValueRef LLVMConstFDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant)
static BlockAddress * get(Function *F, BasicBlock *BB)
Return a BlockAddress for the specified function and basic block.
This is an important base class in LLVM.
LLVMValueRef LLVMBuildNSWSub(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, const char *Name)
LLVMValueRef LLVMGetNamedFunction(LLVMModuleRef M, const char *Name)
Obtain a Function value from a Module by its name.
LLVMValueRef LLVMConstFNeg(LLVMValueRef ConstantVal)
This file contains the declarations for the subclasses of Constant, which represent the different fla...
unsigned LLVMCountStructElementTypes(LLVMTypeRef StructTy)
Get the number of elements defined inside the structure.
param_iterator param_begin() const
LLVMThreadLocalMode LLVMGetThreadLocalMode(LLVMValueRef GlobalVar)
LLVMValueRef LLVMBuildSIToFP(LLVMBuilderRef B, LLVMValueRef Val, LLVMTypeRef DestTy, const char *Name)
char * LLVMPrintValueToString(LLVMValueRef Val)
Return a string representation of the value.
LLVMValueRef LLVMBuildExtractElement(LLVMBuilderRef B, LLVMValueRef VecVal, LLVMValueRef Index, const char *Name)
LLVMValueRef LLVMBuildFMul(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, const char *Name)
static Constant * getAnd(Constant *C1, Constant *C2)
void LLVMSetDLLStorageClass(LLVMValueRef Global, LLVMDLLStorageClass Class)
static Constant * get(ArrayType *T, ArrayRef< Constant * > V)
ConstantFP - Floating Point Values [float, double].
LLVMTypeRef LLVMPPCFP128TypeInContext(LLVMContextRef C)
Obtain a 128-bit floating point type (two 64-bits) from a context.
80 bit floating point type (X87)
LLVMValueRef LLVMBuildPtrDiff(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, const char *Name)
LLVMValueRef LLVMBuildInBoundsGEP(LLVMBuilderRef B, LLVMValueRef Pointer, LLVMValueRef *Indices, unsigned NumIndices, const char *Name)
static Constant * getSExtOrBitCast(Constant *C, Type *Ty)
LLVMValueRef LLVMConstNUWMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant)
bool llvm_is_multithreaded()
Returns true if LLVM is compiled with support for multi-threading, and false otherwise.
LLVMValueRef LLVMConstExtractValue(LLVMValueRef AggConstant, unsigned *IdxList, unsigned NumIdx)
LLVMValueRef LLVMBuildExactUDiv(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, const char *Name)
void LLVMAddDestination(LLVMValueRef IndirectBr, LLVMBasicBlockRef Dest)
LLVMValueRef LLVMConstOr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant)
void LLVMInstructionEraseFromParent(LLVMValueRef Inst)
Remove and delete an instruction.
static Constant * getShuffleVector(Constant *V1, Constant *V2, Constant *Mask, Type *OnlyIfReducedTy=nullptr)
LLVMUseRef LLVMGetOperandUse(LLVMValueRef Val, unsigned Index)
Obtain the use of an operand at a specific index in a llvm::User value.
void LLVMMoveBasicBlockAfter(LLVMBasicBlockRef BB, LLVMBasicBlockRef MovePos)
Move a basic block to after another one.
LLVMValueRef LLVMGetUsedValue(LLVMUseRef U)
Obtain the value this use corresponds to.
static Type * getVoidTy(LLVMContext &C)
LLVMTypeRef LLVMArrayType(LLVMTypeRef ElementType, unsigned ElementCount)
Create a fixed size array type that refers to a specific type.
LLVMValueRef LLVMGetElementAsConstant(LLVMValueRef C, unsigned idx)
Get an element at specified index as a constant.
LLVMBool LLVMIsUndef(LLVMValueRef Val)
Determine whether a value instance is undefined.
char * LLVMGetDiagInfoDescription(LLVMDiagnosticInfoRef DI)
Return a string representation of the DiagnosticInfo.
void LLVMSetParamAlignment(LLVMValueRef Arg, unsigned align)
Set the alignment for a function parameter.
LLVMValueRef LLVMBuildResume(LLVMBuilderRef B, LLVMValueRef Exn)
LLVMValueRef LLVMConstString(const char *Str, unsigned Length, LLVMBool DontNullTerminate)
Create a ConstantDataSequential with string content in the global context.
This instruction compares its operands according to the predicate given to the constructor.
LLVMTypeRef LLVMIntTypeInContext(LLVMContextRef C, unsigned NumBits)
MDNode * getOperand(unsigned i) const
void setCallingConv(CallingConv::ID CC)
LLVMBasicBlockRef LLVMGetSuccessor(LLVMValueRef Term, unsigned i)
Return the specified successor.
6: 128-bit floating point type (two 64-bits, PowerPC)
LLVMValueRef LLVMConstSRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant)
static BasicBlock * Create(LLVMContext &Context, const Twine &Name="", Function *Parent=nullptr, BasicBlock *InsertBefore=nullptr)
Creates a new BasicBlock.
LLVMValueRef LLVMBuildUnreachable(LLVMBuilderRef B)
static Constant * getICmp(unsigned short pred, Constant *LHS, Constant *RHS, bool OnlyIfReduced=false)
get* - Return some common constants without having to specify the full Instruction::OPCODE identifier...
LLVMValueRef LLVMBuildInvoke(LLVMBuilderRef B, LLVMValueRef Fn, LLVMValueRef *Args, unsigned NumArgs, LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch, const char *Name)
self_iterator getIterator()
void LLVMShutdown()
Deallocate and destroy all ManagedStatic variables.
LLVMTypeRef LLVMPPCFP128Type(void)
Class to represent integer types.
LLVMValueRef LLVMConstIntToPtr(LLVMValueRef ConstantVal, LLVMTypeRef ToType)
LLVMTypeRef LLVMTokenTypeInContext(LLVMContextRef C)
And a value and return the old one.
LLVMBool LLVMIsEnumAttribute(LLVMAttributeRef A)
Check for the different types of attributes.
LLVMValueRef LLVMConstPointerCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType)
LLVMValueRef LLVMBuildNot(LLVMBuilderRef B, LLVMValueRef V, const char *Name)
LLVMBasicBlockRef LLVMGetInsertBlock(LLVMBuilderRef Builder)
const char * LLVMGetTarget(LLVMModuleRef M)
Obtain the target triple for a module.
static Constant * get(StructType *T, ArrayRef< Constant * > V)
LLVMTypeRef LLVMInt16Type(void)
Sets the value if it's greater than the original using a signed comparison and return the old one...
static Constant * getNot(Constant *C)
unsigned LLVMGetEnumAttributeKind(LLVMAttributeRef A)
Get the unique id corresponding to the enum attribute passed as argument.
void LLVMPositionBuilderBefore(LLVMBuilderRef Builder, LLVMValueRef Instr)
void LLVMSetPersonalityFn(LLVMValueRef Fn, LLVMValueRef PersonalityFn)
Set the personality function attached to the function.
static Constant * getAllOnesValue(Type *Ty)
Get the all ones value.
LLVMTypeRef LLVMGetTypeByName(LLVMModuleRef M, const char *Name)
Obtain a Type from a module by its registered name.
LLVMValueRef LLVMGetPersonalityFn(LLVMValueRef Fn)
Obtain the personality function attached to the function.
unsigned LLVMGetNumClauses(LLVMValueRef LandingPad)
LLVMOpcode LLVMGetConstOpcode(LLVMValueRef ConstantVal)
unsigned LLVMGetInstructionCallConv(LLVMValueRef Instr)
Obtain the calling convention for a call instruction.
void LLVMDumpValue(LLVMValueRef Val)
Dump a representation of a value to stderr.
LLVMValueRef LLVMConstSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant)
struct LLVMOpaqueModuleProvider * LLVMModuleProviderRef
Interface used to provide a module to JIT or interpreter.
void LLVMGetNamedMetadataOperands(LLVMModuleRef M, const char *Name, LLVMValueRef *Dest)
Obtain the named metadata operands for a module.
FunctionPassManager manages FunctionPasses and BasicBlockPassManagers.
LLVMValueRef LLVMConstUIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType)
int LLVMGetNumOperands(LLVMValueRef Val)
Obtain the number of operands in a llvm::User value.
static UndefValue * get(Type *T)
Static factory methods - Return an 'undef' object of the specified type.
void * LLVMContextGetDiagnosticContext(LLVMContextRef C)
Get the diagnostic context of this context.
unsigned LLVMGetCallSiteAttributeCount(LLVMValueRef C, LLVMAttributeIndex Idx)
LLVMValueRef LLVMBuildGEP(LLVMBuilderRef B, LLVMValueRef Pointer, LLVMValueRef *Indices, unsigned NumIndices, const char *Name)
LLVMValueRef LLVMAddGlobalInAddressSpace(LLVMModuleRef M, LLVMTypeRef Ty, const char *Name, unsigned AddressSpace)
struct LLVMOpaqueDiagnosticInfo * LLVMDiagnosticInfoRef
LLVMContext & getContext() const
All values hold a context through their type.
LLVMValueRef LLVMBuildTrunc(LLVMBuilderRef B, LLVMValueRef Val, LLVMTypeRef DestTy, const char *Name)
const char * LLVMGetDataLayout(LLVMModuleRef M)
C setMetadata(LLVMContext::MD_range, MDNode::get(Context, LowAndHigh))
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Like Private, but linker removes.
LLVMValueRef LLVMGetParam(LLVMValueRef FnRef, unsigned index)
Obtain the parameter at the specified index.
LLVMValueRef LLVMConstStringInContext(LLVMContextRef C, const char *Str, unsigned Length, LLVMBool DontNullTerminate)
Create a ConstantDataSequential and initialize it with a string.
LLVMValueRef LLVMConstURem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant)
Triple - Helper class for working with autoconf configuration names.
LLVMTypeRef LLVMVoidType(void)
These are similar to the above functions except they operate on the global context.
LLVMValueRef LLVMBuildCall(LLVMBuilderRef B, LLVMValueRef Fn, LLVMValueRef *Args, unsigned NumArgs, const char *Name)
static Type * getFP128Ty(LLVMContext &C)
LLVMBasicBlockRef LLVMAppendBasicBlockInContext(LLVMContextRef C, LLVMValueRef FnRef, const char *Name)
Append a basic block to the end of a function.
LLVMTypeRef LLVMGetElementType(LLVMTypeRef WrappedTy)
Obtain the type of elements within a sequential type.
LLVMValueRef LLVMBuildNeg(LLVMBuilderRef B, LLVMValueRef V, const char *Name)
void LLVMDisposeMemoryBuffer(LLVMMemoryBufferRef MemBuf)
LLVMValueRef LLVMBuildUIToFP(LLVMBuilderRef B, LLVMValueRef Val, LLVMTypeRef DestTy, const char *Name)
void LLVMSetFunctionCallConv(LLVMValueRef Fn, unsigned CC)
Set the calling convention of a function.
Like Internal, but omit from symbol table.
void LLVMGetBasicBlocks(LLVMValueRef FnRef, LLVMBasicBlockRef *BasicBlocksRefs)
Obtain all of the basic blocks in a function.
Sets the value if it's Smaller than the original using a signed comparison and return the old one...
static AtomicOrdering mapFromLLVMOrdering(LLVMAtomicOrdering Ordering)
global_iterator global_end()
AttributeSet getAttributes() const
getAttributes/setAttributes - get or set the parameter attributes of the call.
static Constant * getFCmp(unsigned short pred, Constant *LHS, Constant *RHS, bool OnlyIfReduced=false)
LLVMContextRef LLVMGetTypeContext(LLVMTypeRef Ty)
Obtain the context to which this type instance is associated.
static Constant * getPointerCast(Constant *C, Type *Ty)
Create a BitCast, AddrSpaceCast, or a PtrToInt cast constant expression.
iterator_range< T > make_range(T x, T y)
Convenience function for iterating over sub-ranges.
static Constant * getSIToFP(Constant *C, Type *Ty, bool OnlyIfReduced=false)
LLVMValueRef LLVMGetOperand(LLVMValueRef Val, unsigned Index)
Obtain an operand at a specific index in a llvm::User value.
LLVMValueRef LLVMConstTruncOrBitCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType)
static Type * getHalfTy(LLVMContext &C)
unsigned LLVMCountParams(LLVMValueRef FnRef)
Obtain the number of parameters in a function.
static IntegerType * get(LLVMContext &C, unsigned NumBits)
This static method is the primary way of constructing an IntegerType.
const MDOperand & getOperand(unsigned I) const
LLVMModuleProviderRef LLVMCreateModuleProviderForExistingModule(LLVMModuleRef M)
Changes the type of M so it can be passed to FunctionPassManagers and the JIT.
void LLVMInsertIntoBuilder(LLVMBuilderRef Builder, LLVMValueRef Instr)
LLVMValueRef LLVMBuildFPCast(LLVMBuilderRef B, LLVMValueRef Val, LLVMTypeRef DestTy, const char *Name)
LLVMValueRef LLVMBuildRetVoid(LLVMBuilderRef B)
Iterator for intrusive lists based on ilist_node.
LLVMValueRef LLVMBuildGlobalString(LLVMBuilderRef B, const char *Str, const char *Name)
LLVMValueRef LLVMConstPointerNull(LLVMTypeRef Ty)
Obtain a constant that is a constant pointer pointing to NULL for a specified type.
void LLVMSetInitializer(LLVMValueRef GlobalVar, LLVMValueRef ConstantVal)
LLVMVisibility LLVMGetVisibility(LLVMValueRef Global)
LLVMValueRef LLVMConstNUWSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant)
void LLVMInitializeCore(LLVMPassRegistryRef R)
LLVMContextRef LLVMContextCreate()
Create a new context.
LLVMTypeKind LLVMGetTypeKind(LLVMTypeRef Ty)
Obtain the enumerated type of a Type instance.
LLVMTypeRef LLVMTypeOf(LLVMValueRef Val)
Obtain the type of a value.
LLVMValueRef LLVMConstAllOnes(LLVMTypeRef Ty)
Obtain a constant value referring to the instance of a type consisting of all ones.
16: SIMD 'packed' format, or other vector type
LLVMValueRef LLVMConstFPTrunc(LLVMValueRef ConstantVal, LLVMTypeRef ToType)
static StructType * get(LLVMContext &Context, ArrayRef< Type * > Elements, bool isPacked=false)
This static method is the primary way to create a literal StructType.
static Constant * getSDiv(Constant *C1, Constant *C2, bool isExact=false)
LLVMValueRef LLVMGetCalledValue(LLVMValueRef Instr)
Obtain the pointer to the function invoked by this instruction.
LLVMValueRef LLVMConstInsertValue(LLVMValueRef AggConstant, LLVMValueRef ElementValueConstant, unsigned *IdxList, unsigned NumIdx)
LLVMValueRef LLVMBuildURem(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, const char *Name)
bool hasName() const
Return true if this is a named struct that has a non-empty name.
LLVMTypeRef LLVMLabelType(void)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small...
Keep one copy of function when linking (inline)
Arbitrary bit width integers.
Module.h This file contains the declarations for the Module class.
Type * getType() const
All values are typed, get the type of this value.
LLVMValueRef LLVMGetCondition(LLVMValueRef Branch)
Return the condition of a branch instruction.
Attribute::AttrKind getKindAsEnum() const
Return the attribute's kind as an enum (Attribute::AttrKind).
LLVMValueRef LLVMBuildFCmp(LLVMBuilderRef B, LLVMRealPredicate Op, LLVMValueRef LHS, LLVMValueRef RHS, const char *Name)
static Constant * getNUWMul(Constant *C1, Constant *C2)
struct LLVMOpaqueBasicBlock * LLVMBasicBlockRef
Represents a basic block of instructions in LLVM IR.
LLVMValueRef LLVMGetNextInstruction(LLVMValueRef Inst)
Obtain the instruction that occurs after the one specified.
void LLVMDeleteGlobal(LLVMValueRef GlobalVar)
Xor a value and return the old one.
LLVMValueRef LLVMConstSExtOrBitCast(LLVMValueRef ConstantVal, LLVMTypeRef ToType)
LLVMValueRef LLVMBuildXor(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, const char *Name)
LLVMValueRef LLVMBuildUDiv(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, const char *Name)
static Constant * getNSWSub(Constant *C1, Constant *C2)
static Constant * getTrunc(Constant *C, Type *Ty, bool OnlyIfReduced=false)
static Constant * get(Type *Ty, uint64_t V, bool isSigned=false)
If Ty is a vector type, return a Constant with a splat of the given value.
LLVMBool LLVMIsFunctionVarArg(LLVMTypeRef FunctionTy)
Returns whether a function type is variadic.
LLVMValueRef LLVMGetCurrentDebugLocation(LLVMBuilderRef Builder)
static Constant * get(Type *Ty, double V)
This returns a ConstantFP, or a vector containing a splat of a ConstantFP, for the specified value in...
unsigned LLVMGetNamedMetadataNumOperands(LLVMModuleRef M, const char *Name)
Obtain the number of operands for named metadata in a module.
void LLVMSetAtomicSingleThread(LLVMValueRef AtomicInst, LLVMBool NewValue)
LLVMTypeRef LLVMDoubleType(void)
32 bit floating point type
LLVMValueRef LLVMBuildInsertValue(LLVMBuilderRef B, LLVMValueRef AggVal, LLVMValueRef EltVal, unsigned Index, const char *Name)
LLVMValueRef LLVMGetUser(LLVMUseRef U)
Obtain the user value for a user.
void setLinkage(LinkageTypes LT)
LLVMValueRef LLVMConstFPExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType)
static GCRegistry::Add< ShadowStackGC > C("shadow-stack","Very portable GC for uncooperative code generators")
provides Acquire semantics for loads and Release semantics for stores.
unsigned getNumAttributes() const
Return the number of attributes this AttributeSet contains.
static LLVMOpcode map_to_llvmopcode(int opcode)
struct LLVMOpaquePassManager * LLVMPassManagerRef
LLVMTypeRef LLVMStructType(LLVMTypeRef *ElementTypes, unsigned ElementCount, LLVMBool Packed)
Create a new structure type in the global context.
unsigned getNumArgOperands() const
LLVMValueRef LLVMBuildShuffleVector(LLVMBuilderRef B, LLVMValueRef V1, LLVMValueRef V2, LLVMValueRef Mask, const char *Name)
double LLVMConstRealGetDouble(LLVMValueRef ConstantVal, LLVMBool *LosesInfo)
Obtain the double value for an floating point constant value.
LLVMValueRef LLVMBuildGlobalStringPtr(LLVMBuilderRef B, const char *Str, const char *Name)
void LLVMSetExternallyInitialized(LLVMValueRef GlobalVar, LLVMBool IsExtInit)
bool hasInitializer() const
Definitions have initializers, declarations don't.
Class for arbitrary precision integers.
LLVMValueRef LLVMBuildMalloc(LLVMBuilderRef B, LLVMTypeRef Ty, const char *Name)
static std::unique_ptr< MemoryBuffer > getMemBufferCopy(StringRef InputData, const Twine &BufferName="")
Open the specified memory range as a MemoryBuffer, copying the contents and taking ownership of it...
LLVMValueRef LLVMIsAMDNode(LLVMValueRef Val)
Same, but only replaced by something equivalent.
LLVMAttributeRef LLVMGetCallSiteEnumAttribute(LLVMValueRef C, LLVMAttributeIndex Idx, unsigned KindID)
LLVMValueRef LLVMBuildFree(LLVMBuilderRef B, LLVMValueRef PointerVal)
LLVMTypeRef LLVMFunctionType(LLVMTypeRef ReturnType, LLVMTypeRef *ParamTypes, unsigned ParamCount, LLVMBool IsVarArg)
Obtain a function type consisting of a specified signature.
StringRef getName() const
Return the name for this struct type if it has an identity.
LLVMValueRef LLVMBuildBitCast(LLVMBuilderRef B, LLVMValueRef Val, LLVMTypeRef DestTy, const char *Name)
LLVMBool LLVMIsThreadLocal(LLVMValueRef GlobalVar)
Maximum length of the test input If
static Constant * getFPToUI(Constant *C, Type *Ty, bool OnlyIfReduced=false)
static AttributeSetNode * get(LLVMContext &C, ArrayRef< Attribute > Attrs)
LLVMValueRef LLVMConstPtrToInt(LLVMValueRef ConstantVal, LLVMTypeRef ToType)
static char getTypeID(Type *Ty)
LLVMBool LLVMRunPassManager(LLVMPassManagerRef PM, LLVMModuleRef M)
Initializes, executes on the provided module, and finalizes all of the passes scheduled in the pass m...
LLVMValueRef LLVMGetBasicBlockTerminator(LLVMBasicBlockRef BB)
Obtain the terminator instruction for a basic block.
The file should be opened in text mode on platforms that make this distinction.
LLVMValueRef LLVMConstStruct(LLVMValueRef *ConstantVals, unsigned Count, LLVMBool Packed)
Create a ConstantStruct in the global Context.
static Constant * getZExtOrBitCast(Constant *C, Type *Ty)
LLVMBool LLVMIsConstantString(LLVMValueRef C)
Returns true if the specified constant is an array of i8.
void addAttribute(unsigned i, Attribute::AttrKind Kind)
LLVMValueRef LLVMConstFCmp(LLVMRealPredicate Predicate, LLVMValueRef LHSConstant, LLVMValueRef RHSConstant)
LLVMTypeRef LLVMX86MMXTypeInContext(LLVMContextRef C)
Create a X86 MMX type in a context.
LLVMValueRef LLVMConstMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant)
double convertToDouble() const
LLVMBool LLVMIsDeclaration(LLVMValueRef Global)
static const fltSemantics & IEEEdouble()
static Instruction * CreateMalloc(Instruction *InsertBefore, Type *IntPtrTy, Type *AllocTy, Value *AllocSize, Value *ArraySize=nullptr, Function *MallocF=nullptr, const Twine &Name="")
Generate the IR for a call to malloc:
LLVMValueRef LLVMBuildFPExt(LLVMBuilderRef B, LLVMValueRef Val, LLVMTypeRef DestTy, const char *Name)
Basic diagnostic printer that uses an underlying raw_ostream.
LLVMValueRef LLVMConstNeg(LLVMValueRef ConstantVal)
void LLVMAddIncoming(LLVMValueRef PhiNode, LLVMValueRef *IncomingValues, LLVMBasicBlockRef *IncomingBlocks, unsigned Count)
Add an incoming value to the end of a PHI list.
static Constant * getFSub(Constant *C1, Constant *C2)
LLVMValueRef LLVMBuildExtractValue(LLVMBuilderRef B, LLVMValueRef AggVal, unsigned Index, const char *Name)
LLVMValueRef LLVMBuildAShr(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, const char *Name)
static Constant * getTruncOrBitCast(Constant *C, Type *Ty)
void LLVMRemoveBasicBlockFromParent(LLVMBasicBlockRef BBRef)
Remove a basic block from a function.
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata * > MDs)
LLVMValueRef LLVMConstFAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant)
static Constant * getNeg(Constant *C, bool HasNUW=false, bool HasNSW=false)
LLVMValueRef LLVMConstNSWSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant)
LLVMValueRef LLVMBuildMul(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, const char *Name)
void LLVMAddNamedMetadataOperand(LLVMModuleRef M, const char *Name, LLVMValueRef Val)
Add an operand to named metadata.
LLVMBool LLVMIsInBounds(LLVMValueRef GEP)
Check whether the given GEP instruction is inbounds.
LLVMValueRef LLVMGetPreviousParam(LLVMValueRef Arg)
Obtain the previous parameter to a function.
LLVMModuleRef LLVMModuleCreateWithName(const char *ModuleID)
Create a new, empty module in the global context.
unsigned LLVMGetNumIndices(LLVMValueRef Inst)
Obtain the number of indices.
void LLVMAddCase(LLVMValueRef Switch, LLVMValueRef OnVal, LLVMBasicBlockRef Dest)
static Constant * getNSWMul(Constant *C1, Constant *C2)
LLVMValueRef LLVMBuildArrayMalloc(LLVMBuilderRef B, LLVMTypeRef Ty, LLVMValueRef Val, const char *Name)
LLVMAttributeRef wrap(Attribute Attr)
A raw_ostream that writes to a file descriptor.
char * LLVMPrintTypeToString(LLVMTypeRef Ty)
Return a string representation of the type.
LLVMBool LLVMIsConditional(LLVMValueRef Branch)
Return if a branch is conditional.
void LLVMRemoveEnumAttributeAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx, unsigned KindID)
LLVMValueRef LLVMBuildIntToPtr(LLVMBuilderRef B, LLVMValueRef Val, LLVMTypeRef DestTy, const char *Name)
static IntegerType * getInt32Ty(LLVMContext &C)
LLVMValueRef LLVMConstIntOfArbitraryPrecision(LLVMTypeRef IntTy, unsigned NumWords, const uint64_t Words[])
Obtain a constant value for an integer of arbitrary precision.
LLVMTypeRef LLVMInt64Type(void)
16 bit floating point type
static ErrorOr< std::unique_ptr< MemoryBuffer > > getFile(const Twine &Filename, int64_t FileSize=-1, bool RequiresNullTerminator=true, bool IsVolatileSize=false)
Open the specified file as a MemoryBuffer, returning a new MemoryBuffer if successful, otherwise returning null.
unsigned LLVMGetEnumAttributeKindForName(const char *Name, size_t SLen)
Return an unique id given the name of a enum attribute, or 0 if no attribute by that name exists...
LLVMTypeRef LLVMHalfTypeInContext(LLVMContextRef C)
Obtain a 16-bit floating point type from a context.
LLVMBasicBlockRef LLVMAppendBasicBlock(LLVMValueRef FnRef, const char *Name)
Append a basic block to the end of a function using the global context.
const char * LLVMGetStringAttributeValue(LLVMAttributeRef A, unsigned *Length)
Get the string attribute's value.
guarantees that if you take all the operations affecting a specific address, a consistent ordering ex...
LLVMTypeRef LLVMInt128TypeInContext(LLVMContextRef C)
LLVMValueRef LLVMConstNUWNeg(LLVMValueRef ConstantVal)
LLVMValueRef LLVMBuildAtomicRMW(LLVMBuilderRef B, LLVMAtomicRMWBinOp op, LLVMValueRef PTR, LLVMValueRef Val, LLVMAtomicOrdering ordering, LLVMBool singleThread)
void LLVMDeleteBasicBlock(LLVMBasicBlockRef BBRef)
Remove a basic block from a function and delete it.
LLVMAtomicOrdering LLVMGetCmpXchgSuccessOrdering(LLVMValueRef CmpXchgInst)
LLVMValueRef LLVMBuildLShr(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, const char *Name)
unsigned LLVMGetNumSuccessors(LLVMValueRef Term)
Return the number of successors that this terminator has.
LLVMValueRef LLVMBuildIsNotNull(LLVMBuilderRef B, LLVMValueRef Val, const char *Name)
unsigned LLVMGetMDKindID(const char *Name, unsigned SLen)
LLVMBool LLVMIsConstant(LLVMValueRef Ty)
Determine whether the specified value instance is constant.
const std::string & getGC() const
static Constant * getPtrToInt(Constant *C, Type *Ty, bool OnlyIfReduced=false)
LLVMBasicBlockRef LLVMGetUnwindDest(LLVMValueRef Invoke)
Return the unwind destination basic block.
LLVMValueRef LLVMBuildFSub(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, const char *Name)
static Constant * getOr(Constant *C1, Constant *C2)
LLVMBasicBlockRef LLVMGetIncomingBlock(LLVMValueRef PhiNode, unsigned Index)
Obtain an incoming value to a PHI node as an LLVMBasicBlockRef.
void LLVMSetUnwindDest(LLVMValueRef Invoke, LLVMBasicBlockRef B)
Set the unwind destination basic block.
LLVMTypeRef LLVMInt1TypeInContext(LLVMContextRef C)
Obtain an integer type from a context with specified bit width.
LLVMBool LLVMGetVolatile(LLVMValueRef MemAccessInst)
LLVMTypeRef LLVMInt1Type(void)
Obtain an integer type from the global context with a specified bit width.
void initializeVerifierLegacyPassPass(PassRegistry &)
void LLVMGetCallSiteAttributes(LLVMValueRef C, LLVMAttributeIndex Idx, LLVMAttributeRef *Attrs)
LLVMTypeRef LLVMIntType(unsigned NumBits)
void LLVMSetInstructionCallConv(LLVMValueRef Instr, unsigned CC)
Set the calling convention for a call instruction.
LLVMPassManagerRef LLVMCreateFunctionPassManagerForModule(LLVMModuleRef M)
Constructs a new function-by-function pass pipeline over the module provider.
LLVMModuleRef LLVMModuleCreateWithNameInContext(const char *ModuleID, LLVMContextRef C)
Create a new, empty module in a specific context.
LLVMValueRef LLVMBuildSwitch(LLVMBuilderRef B, LLVMValueRef V, LLVMBasicBlockRef Else, unsigned NumCases)
LLVMValueRef LLVMConstArray(LLVMTypeRef ElementTy, LLVMValueRef *ConstantVals, unsigned Length)
Create a ConstantArray from values.
void removeAttribute(unsigned i, Attribute::AttrKind Kind)
128 bit floating point type (two 64-bits)
static ArrayType * get(Type *ElementType, uint64_t NumElements)
This static method is the primary way to construct an ArrayType.
void LLVMDumpType(LLVMTypeRef Ty)
Dump a representation of a type to stderr.
static Constant * getShl(Constant *C1, Constant *C2, bool HasNUW=false, bool HasNSW=false)
Keep one copy of named function when linking (weak)
bool isStringAttribute() const
Return true if the attribute is a string (target-dependent) attribute.
static BinaryOperator * CreateNeg(Value *S1, const Twine &Name, Instruction *InsertBefore, Value *FlagsOp)
Rename collisions when linking (static functions).
LLVMTypeRef LLVMInt8Type(void)
static Attribute get(LLVMContext &Context, AttrKind Kind, uint64_t Val=0)
Return a uniquified Attribute object.
Special purpose, only applies to global arrays.
static InlineAsm * get(FunctionType *Ty, StringRef AsmString, StringRef Constraints, bool hasSideEffects, bool isAlignStack=false, AsmDialect asmDialect=AD_ATT)
InlineAsm::get - Return the specified uniqued inline asm string.
LLVMValueRef LLVMConstSIToFP(LLVMValueRef ConstantVal, LLVMTypeRef ToType)
AttributeSet getAttributes(LLVMContext &C, ID id)
Return the attributes for an intrinsic.
LLVMValueRef LLVMConstLShr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant)
LLVMBool LLVMFinalizeFunctionPassManager(LLVMPassManagerRef FPM)
Finalizes all of the function passes scheduled in in the function pass manager.
void close()
Manually flush the stream and close the file.
LLVMIntPredicate LLVMGetICmpPredicate(LLVMValueRef Inst)
Obtain the predicate of an instruction.
void LLVMSetCleanup(LLVMValueRef LandingPad, LLVMBool Val)
LLVMValueRef LLVMConstShl(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant)
LLVMValueRef LLVMBuildNUWMul(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, const char *Name)
Like LinkerPrivate, but is weak.
LLVMValueRef LLVMConstNot(LLVMValueRef ConstantVal)
LLVMValueRef LLVMBuildLandingPad(LLVMBuilderRef B, LLVMTypeRef Ty, LLVMValueRef PersFn, unsigned NumClauses, const char *Name)
const APFloat & getValueAPF() const
unsigned LLVMGetAttributeCountAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx)
3: 64-bit floating point type
LLVMValueRef LLVMGetFirstFunction(LLVMModuleRef M)
Obtain an iterator to the first Function in a Module.
StringRef getValueAsString() const
Return the attribute's value as a string.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
LLVMBool LLVMPrintModuleToFile(LLVMModuleRef M, const char *Filename, char **ErrorMessage)
Print a representation of a module to a file.
LLVMValueRef LLVMBuildVAArg(LLVMBuilderRef B, LLVMValueRef List, LLVMTypeRef Ty, const char *Name)
void LLVMSetThreadLocalMode(LLVMValueRef GlobalVar, LLVMThreadLocalMode Mode)
static Constant * getSRem(Constant *C1, Constant *C2)
Release is similar to Acquire, but with a barrier of the sort necessary to release a lock...
LLVMBuilderRef LLVMCreateBuilderInContext(LLVMContextRef C)
LLVMAtomicOrdering LLVMGetOrdering(LLVMValueRef MemAccessInst)
void LLVMSetMetadata(LLVMValueRef Inst, unsigned KindID, LLVMValueRef Val)
Set metadata associated with an instruction value.
LLVMValueRef LLVMGetParamParent(LLVMValueRef V)
Obtain the function to which this argument belongs.
A raw_ostream that writes to an std::string.
const char * LLVMGetValueName(LLVMValueRef Val)
Obtain the string name of a value.
LLVMValueRef LLVMBuildSExtOrBitCast(LLVMBuilderRef B, LLVMValueRef Val, LLVMTypeRef DestTy, const char *Name)
LLVMValueRef LLVMBuildBr(LLVMBuilderRef B, LLVMBasicBlockRef Dest)
void LLVMAddCallSiteAttribute(LLVMValueRef C, LLVMAttributeIndex Idx, LLVMAttributeRef A)
Module * getParent()
Get the module that this global value is contained inside of...
LLVM Value Representation.
LLVMValueRef LLVMBuildZExtOrBitCast(LLVMBuilderRef B, LLVMValueRef Val, LLVMTypeRef DestTy, const char *Name)
LLVMBool LLVMCreateMemoryBufferWithSTDIN(LLVMMemoryBufferRef *OutMemBuf, char **OutMessage)
LLVMLinkage LLVMGetLinkage(LLVMValueRef Global)
static Constant * getURem(Constant *C1, Constant *C2)
unsigned getArgNo() const
Return the index of this formal argument in its containing function.
static VectorType * get(Type *ElementType, unsigned NumElements)
This static method is the primary way to construct an VectorType.
static StructType * create(LLVMContext &Context, StringRef Name)
This creates an identified struct.
LLVMBasicBlockRef LLVMValueAsBasicBlock(LLVMValueRef Val)
Convert an LLVMValueRef to an LLVMBasicBlockRef instance.
std::underlying_type< E >::type Mask()
Get a bitmask with 1s in all places up to the high-order bit of E's largest value.
LLVMValueRef LLVMGetPreviousFunction(LLVMValueRef Fn)
Decrement a Function iterator to the previous Function.
static const Function * getParent(const Value *V)
void LLVMSetOrdering(LLVMValueRef MemAccessInst, LLVMAtomicOrdering Ordering)
LLVMValueRef LLVMBuildIndirectBr(LLVMBuilderRef B, LLVMValueRef Addr, unsigned NumDests)
void LLVMSetGC(LLVMValueRef Fn, const char *GC)
Define the garbage collector to use during code generation.
LLVMDLLStorageClass LLVMGetDLLStorageClass(LLVMValueRef Global)
static Constant * getUIToFP(Constant *C, Type *Ty, bool OnlyIfReduced=false)
LLVMValueRef LLVMBuildNSWNeg(LLVMBuilderRef B, LLVMValueRef V, const char *Name)
static Constant * getFPToSI(Constant *C, Type *Ty, bool OnlyIfReduced=false)
LLVMValueRef LLVMConstExactUDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant)
LLVMTypeRef LLVMGetReturnType(LLVMTypeRef FunctionTy)
Obtain the Type this function Type returns.
unsigned getNumOperands() const
LLVMValueRef LLVMBuildNSWMul(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS, const char *Name)
LLVMValueRef LLVMBuildStore(LLVMBuilderRef B, LLVMValueRef Val, LLVMValueRef PointerVal)
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE const char * data() const
data - Get a pointer to the start of the string (which may not be null terminated).
LLVMValueRef LLVMBuildBinOp(LLVMBuilderRef B, LLVMOpcode Op, LLVMValueRef LHS, LLVMValueRef RHS, const char *Name)
void(* YieldCallbackTy)(LLVMContext *Context, void *OpaqueHandle)
Defines the type of a yield callback.
const char * LLVMGetModuleIdentifier(LLVMModuleRef M, size_t *Len)
Obtain the identifier of a module.
static Constant * getExtractValue(Constant *Agg, ArrayRef< unsigned > Idxs, Type *OnlyIfReducedTy=nullptr)
LLVMValueRef LLVMConstZExt(LLVMValueRef ConstantVal, LLVMTypeRef ToType)
StringRef - Represent a constant reference to a string, i.e.
LLVMBool LLVMIsMultithreaded()
Check whether LLVM is executing in thread-safe mode or not.
PassRegistry - This class manages the registration and intitialization of the pass subsystem as appli...
AttrBuilder & addAlignmentAttr(unsigned Align)
This turns an int alignment (which must be a power of 2) into the form used internally in Attribute...
LLVMContextRef LLVMGetGlobalContext()
Obtain the global context instance.
LLVMValueRef LLVMConstNSWMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant)
ManagedStatic - This transparently changes the behavior of global statics to be lazily constructed on...
static Function * Create(FunctionType *Ty, LinkageTypes Linkage, const Twine &N="", Module *M=nullptr)
LLVMTypeRef LLVMInt32TypeInContext(LLVMContextRef C)
LLVMAtomicOrdering LLVMGetCmpXchgFailureOrdering(LLVMValueRef CmpXchgInst)
void initializePrintFunctionPassWrapperPass(PassRegistry &)
static Constant * getExactUDiv(Constant *C1, Constant *C2)
LLVMBool LLVMRunFunctionPassManager(LLVMPassManagerRef FPM, LLVMValueRef F)
Executes all of the function passes scheduled in the function pass manager on the provided function...
static bool isVolatile(Instruction *Inst)
64 bit floating point type
9: MMX vectors (64 bits, X86 specific)
static Constant * getAlignOf(Type *Ty)
getAlignOf constant expr - computes the alignment of a type in a target independent way (Note: the re...
LLVMTypeRef LLVMPointerType(LLVMTypeRef ElementType, unsigned AddressSpace)
Create a pointer type that points to a defined type.
static Constant * getMul(Constant *C1, Constant *C2, bool HasNUW=false, bool HasNSW=false)
LLVMValueRef LLVMBuildLoad(LLVMBuilderRef B, LLVMValueRef PointerVal, const char *Name)
void LLVMInstructionRemoveFromParent(LLVMValueRef Inst)
Remove and delete an instruction.
LLVMValueRef LLVMConstExtractElement(LLVMValueRef VectorConstant, LLVMValueRef IndexConstant)
void LLVMSetTailCall(LLVMValueRef Call, LLVMBool isTailCall)
Set whether a call instruction is a tail call.
static Constant * getNUWSub(Constant *C1, Constant *C2)
static BinaryOperator * CreateMul(Value *S1, Value *S2, const Twine &Name, Instruction *InsertBefore, Value *FlagsOp)
This file defines the node class used internally by AttributeSet.
void LLVMSetModuleInlineAsm(LLVMModuleRef M, const char *Asm)
Set inline assembly for a module.
LLVMValueRef LLVMBuildAddrSpaceCast(LLVMBuilderRef B, LLVMValueRef Val, LLVMTypeRef DestTy, const char *Name)
LLVMBasicBlockRef LLVMGetNormalDest(LLVMValueRef Invoke)
Return the normal destination basic block.
AttributeSet addAttributes(LLVMContext &C, unsigned Index, AttributeSet Attrs) const
Add attributes to the attribute set at the given index.
const char * LLVMGetStringAttributeKind(LLVMAttributeRef A, unsigned *Length)
Get the string attribute's kind.
static Constant * getFPExtend(Constant *C, Type *Ty, bool OnlyIfReduced=false)
LLVMValueRef LLVMConstFRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant)
static GCRegistry::Add< ErlangGC > A("erlang","erlang-compatible garbage collector")
static Constant * getNUWAdd(Constant *C1, Constant *C2)
unsigned LLVMGetAlignment(LLVMValueRef V)
Obtain the preferred alignment of the value.
LLVMValueRef LLVMGetNextFunction(LLVMValueRef Fn)
Advance a Function iterator to the next Function.
void LLVMAddAttributeAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx, LLVMAttributeRef A)
Add an attribute to a function.
static IntegerType * getInt8Ty(LLVMContext &C)
void LLVMDisposeModuleProvider(LLVMModuleProviderRef MP)
Destroys the module M.
void LLVMRemoveStringAttributeAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx, const char *K, unsigned KLen)
LLVMTypeRef LLVMInt128Type(void)
LLVMValueRef LLVMBuildSelect(LLVMBuilderRef B, LLVMValueRef If, LLVMValueRef Then, LLVMValueRef Else, const char *Name)
const BasicBlock * getParent() const
static GlobalAlias * create(Type *Ty, unsigned AddressSpace, LinkageTypes Linkage, const Twine &Name, Constant *Aliasee, Module *Parent)
If a parent module is specified, the alias is automatically inserted into the end of the specified mo...
LLVMTypeRef LLVMX86FP80TypeInContext(LLVMContextRef C)
Obtain a 80-bit floating point type (X87) from a context.
struct LLVMOpaqueValue * LLVMValueRef
Represents an individual value in LLVM IR.
Type * getTypeAtIndex(const Value *V) const
Given an index value into the type, return the type of the element.
void LLVMInsertIntoBuilderWithName(LLVMBuilderRef Builder, LLVMValueRef Instr, const char *Name)
an instruction to allocate memory on the stack
static Constant * getXor(Constant *C1, Constant *C2)
AttrKind
This enumeration lists the attributes that can be associated with parameters, function results...
LLVMValueRef LLVMBuildFPTrunc(LLVMBuilderRef B, LLVMValueRef Val, LLVMTypeRef DestTy, const char *Name)
5: 128-bit floating point type (112-bit mantissa)
void LLVMSetIsInBounds(LLVMValueRef GEP, LLVMBool InBounds)
Set the given GEP instruction to be inbounds or not.
void LLVMSetAlignment(LLVMValueRef V, unsigned Bytes)
Set the preferred alignment of the value.
LLVMValueKind LLVMGetValueKind(LLVMValueRef Val)
Obtain the enumerated type of a Value instance.
LLVMModuleRef LLVMGetGlobalParent(LLVMValueRef Global)