The fixpoint analysis framework that orchestrates the attribute deduction. More...

#include "llvm/Transforms/IPO/Attributor.h"

Collaboration diagram for llvm::Attributor:

[legend]

Classes
struct	ArgumentReplacementInfo
	Helper struct used in the communication between an abstract attribute (AA) that wants to change the signature of a function and the Attributor which applies the changes. More...

Public Types
using	SimplifictionCallbackTy = std::function< std::optional< Value * >(const IRPosition &, const AbstractAttribute *, bool &)>
	Register `CB` as a simplification callback.

using	VirtualUseCallbackTy = std::function< bool(Attributor &, const AbstractAttribute *)>

Public Member Functions
	Attributor (SetVector< Function * > &Functions, InformationCache &InfoCache, AttributorConfig Configuration)
	Constructor.

	~Attributor ()

ChangeStatus	run ()
	Run the analyses until a fixpoint is reached or enforced (timeout).

template<typename AAType >
const AAType &	getAAFor (const AbstractAttribute &QueryingAA, const IRPosition &IRP, DepClassTy DepClass)
	Lookup an abstract attribute of type `AAType` at position `IRP`.

template<typename AAType >
const AAType &	getAndUpdateAAFor (const AbstractAttribute &QueryingAA, const IRPosition &IRP, DepClassTy DepClass)
	Similar to getAAFor but the return abstract attribute will be updated (via `AbstractAttribute::update`) even if it is found in the cache.

template<typename AAType >
const AAType &	getOrCreateAAFor (IRPosition IRP, const AbstractAttribute *QueryingAA, DepClassTy DepClass, bool ForceUpdate=false, bool UpdateAfterInit=true)
	The version of getAAFor that allows to omit a querying abstract attribute.

template<typename AAType >
const AAType &	getOrCreateAAFor (const IRPosition &IRP)

template<typename AAType >
AAType *	lookupAAFor (const IRPosition &IRP, const AbstractAttribute *QueryingAA=nullptr, DepClassTy DepClass=DepClassTy::OPTIONAL, bool AllowInvalidState=false)
	Return the attribute of `AAType` for `IRP` if existing and valid.

void	registerForUpdate (AbstractAttribute &AA)
	Allows a query AA to request an update if a new query was received.

void	recordDependence (const AbstractAttribute &FromAA, const AbstractAttribute &ToAA, DepClassTy DepClass)
	Explicitly record a dependence from `FromAA` to `ToAA`, that is if `FromAA` changes `ToAA` should be updated as well.

template<typename AAType >
AAType &	registerAA (AAType &AA)
	Introduce a new abstract attribute into the fixpoint analysis.

InformationCache &	getInfoCache ()
	Return the internal information cache.

bool	isModulePass () const
	Return true if this is a module pass, false otherwise.

bool	isRunOn (Function &Fn) const
	Return true if we derive attributes for `Fn`.

bool	isRunOn (Function *Fn) const

void	identifyDefaultAbstractAttributes (Function &F)
	Determine opportunities to derive 'default' attributes in `F` and create abstract attribute objects for them.

bool	isFunctionIPOAmendable (const Function &F)
	Determine whether the function `F` is IPO amendable.

void	markLiveInternalFunction (const Function &F)
	Mark the internal function `F` as live.

void	removeCallSite (CallInst *CI)
	Helper function to remove callsite.

bool	changeUseAfterManifest (Use &U, Value &NV)
	Record that `U` is to be replaces with `NV` after information was manifested.

bool	changeAfterManifest (const IRPosition IRP, Value &NV, bool ChangeDroppable=true)
	Helper function to replace all uses associated with `IRP` with `NV`.

void	changeToUnreachableAfterManifest (Instruction *I)
	Record that `I` is to be replaced with `unreachable` after information was manifested.

void	registerInvokeWithDeadSuccessor (InvokeInst &II)
	Record that `II` has at least one dead successor block.

void	deleteAfterManifest (Instruction &I)
	Record that `I` is deleted after information was manifested.

void	deleteAfterManifest (BasicBlock &BB)
	Record that `BB` is deleted after information was manifested.

void	registerManifestAddedBasicBlock (BasicBlock &BB)

void	deleteAfterManifest (Function &F)
	Record that `F` is deleted after information was manifested.

std::optional< Constant * >	getAssumedConstant (const IRPosition &IRP, const AbstractAttribute &AA, bool &UsedAssumedInformation)
	If `IRP` is assumed to be a constant, return it, if it is unclear yet, return std::nullopt, otherwise return `nullptr`.

std::optional< Constant * >	getAssumedConstant (const Value &V, const AbstractAttribute &AA, bool &UsedAssumedInformation)

std::optional< Value * >	getAssumedSimplified (const IRPosition &IRP, const AbstractAttribute &AA, bool &UsedAssumedInformation, AA::ValueScope S)
	If `V` is assumed simplified, return it, if it is unclear yet, return std::nullopt, otherwise return `nullptr`.

std::optional< Value * >	getAssumedSimplified (const Value &V, const AbstractAttribute &AA, bool &UsedAssumedInformation, AA::ValueScope S)

std::optional< Value * >	getAssumedSimplified (const IRPosition &V, const AbstractAttribute *AA, bool &UsedAssumedInformation, AA::ValueScope S)
	If `V` is assumed simplified, return it, if it is unclear yet, return std::nullopt, otherwise return `nullptr`.

bool	getAssumedSimplifiedValues (const IRPosition &IRP, const AbstractAttribute *AA, SmallVectorImpl< AA::ValueAndContext > &Values, AA::ValueScope S, bool &UsedAssumedInformation)
	Try to simplify `IRP` and in the scope `S`.

void	registerSimplificationCallback (const IRPosition &IRP, const SimplifictionCallbackTy &CB)

bool	hasSimplificationCallback (const IRPosition &IRP)
	Return true if there is a simplification callback for `IRP`.

void	registerVirtualUseCallback (const Value &V, const VirtualUseCallbackTy &CB)

std::optional< Value * >	translateArgumentToCallSiteContent (std::optional< Value * > V, CallBase &CB, const AbstractAttribute &AA, bool &UsedAssumedInformation)
	Translate `V` from the callee context into the call site context.

bool	isAssumedDead (const AbstractAttribute &AA, const AAIsDead *LivenessAA, bool &UsedAssumedInformation, bool CheckBBLivenessOnly=false, DepClassTy DepClass=DepClassTy::OPTIONAL)
	Return true if `AA` (or its context instruction) is assumed dead.

bool	isAssumedDead (const Instruction &I, const AbstractAttribute QueryingAA, const AAIsDead LivenessAA, bool &UsedAssumedInformation, bool CheckBBLivenessOnly=false, DepClassTy DepClass=DepClassTy::OPTIONAL, bool CheckForDeadStore=false)
	Return true if `I` is assumed dead.

bool	isAssumedDead (const Use &U, const AbstractAttribute QueryingAA, const AAIsDead FnLivenessAA, bool &UsedAssumedInformation, bool CheckBBLivenessOnly=false, DepClassTy DepClass=DepClassTy::OPTIONAL)
	Return true if `U` is assumed dead.

bool	isAssumedDead (const IRPosition &IRP, const AbstractAttribute QueryingAA, const AAIsDead FnLivenessAA, bool &UsedAssumedInformation, bool CheckBBLivenessOnly=false, DepClassTy DepClass=DepClassTy::OPTIONAL)
	Return true if `IRP` is assumed dead.

bool	isAssumedDead (const BasicBlock &BB, const AbstractAttribute QueryingAA, const AAIsDead FnLivenessAA, DepClassTy DepClass=DepClassTy::OPTIONAL)
	Return true if `BB` is assumed dead.

bool	checkForAllUses (function_ref< bool(const Use &, bool &)> Pred, const AbstractAttribute &QueryingAA, const Value &V, bool CheckBBLivenessOnly=false, DepClassTy LivenessDepClass=DepClassTy::OPTIONAL, bool IgnoreDroppableUses=true, function_ref< bool(const Use &OldU, const Use &NewU)> EquivalentUseCB=nullptr)
	Check `Pred` on all (transitive) uses of `V`.

template<typename RemarkKind , typename RemarkCallBack >
void	emitRemark (Instruction *I, StringRef RemarkName, RemarkCallBack &&RemarkCB) const
	Emit a remark generically.

template<typename RemarkKind , typename RemarkCallBack >
void	emitRemark (Function *F, StringRef RemarkName, RemarkCallBack &&RemarkCB) const
	Emit a remark on a function.

bool	isValidFunctionSignatureRewrite (Argument &Arg, ArrayRef< Type * > ReplacementTypes)
	Check if we can rewrite a function signature.

bool	registerFunctionSignatureRewrite (Argument &Arg, ArrayRef< Type * > ReplacementTypes, ArgumentReplacementInfo::CalleeRepairCBTy &&CalleeRepairCB, ArgumentReplacementInfo::ACSRepairCBTy &&ACSRepairCB)
	Register a rewrite for a function signature.

bool	checkForAllCallSites (function_ref< bool(AbstractCallSite)> Pred, const AbstractAttribute &QueryingAA, bool RequireAllCallSites, bool &UsedAssumedInformation)
	Check `Pred` on all function call sites.

bool	checkForAllCallSites (function_ref< bool(AbstractCallSite)> Pred, const Function &Fn, bool RequireAllCallSites, const AbstractAttribute *QueryingAA, bool &UsedAssumedInformation, bool CheckPotentiallyDead=false)
	Check `Pred` on all call sites of `Fn`.

bool	checkForAllReturnedValuesAndReturnInsts (function_ref< bool(Value &, const SmallSetVector< ReturnInst *, 4 > &)> Pred, const AbstractAttribute &QueryingAA)
	Check `Pred` on all values potentially returned by `F`.

bool	checkForAllReturnedValues (function_ref< bool(Value &)> Pred, const AbstractAttribute &QueryingAA)
	Check `Pred` on all values potentially returned by the function associated with `QueryingAA`.

bool	checkForAllInstructions (function_ref< bool(Instruction &)> Pred, const Function *Fn, const AbstractAttribute &QueryingAA, const ArrayRef< unsigned > &Opcodes, bool &UsedAssumedInformation, bool CheckBBLivenessOnly=false, bool CheckPotentiallyDead=false)
	Check `Pred` on all instructions in `Fn` with an opcode present in `Opcodes`.

bool	checkForAllInstructions (function_ref< bool(Instruction &)> Pred, const AbstractAttribute &QueryingAA, const ArrayRef< unsigned > &Opcodes, bool &UsedAssumedInformation, bool CheckBBLivenessOnly=false, bool CheckPotentiallyDead=false)
	Check `Pred` on all instructions with an opcode present in `Opcodes`.

bool	checkForAllCallLikeInstructions (function_ref< bool(Instruction &)> Pred, const AbstractAttribute &QueryingAA, bool &UsedAssumedInformation, bool CheckBBLivenessOnly=false, bool CheckPotentiallyDead=false)
	Check `Pred` on all call-like instructions (=CallBased derived).

bool	checkForAllReadWriteInstructions (function_ref< bool(Instruction &)> Pred, AbstractAttribute &QueryingAA, bool &UsedAssumedInformation)
	Check `Pred` on all Read/Write instructions.

const DataLayout &	getDataLayout () const
	Return the data layout associated with the anchor scope.

Static Public Member Functions
static void	createShallowWrapper (Function &F)
	Create a shallow wrapper for `F` such that `F` has internal linkage afterwards.

static bool	isInternalizable (Function &F)
	Returns true if the function `F` can be internalized.

static Function *	internalizeFunction (Function &F, bool Force=false)
	Make another copy of the function `F` such that the copied version has internal linkage afterwards and can be analysed.

static bool	internalizeFunctions (SmallPtrSetImpl< Function * > &FnSet, DenseMap< Function , Function > &FnMap)
	Make copies of each function in the set `FnSet` such that the copied version has internal linkage afterwards and can be analysed.

Public Attributes
BumpPtrAllocator &	Allocator
	The allocator used to allocate memory, e.g. for `AbstractAttribute`s.

Detailed Description

The fixpoint analysis framework that orchestrates the attribute deduction.

The Attributor provides a general abstract analysis framework (guided fixpoint iteration) as well as helper functions for the deduction of (LLVM-IR) attributes. However, also other code properties can be deduced, propagated, and ultimately manifested through the Attributor framework. This is particularly useful if these properties interact with attributes and a co-scheduled deduction allows to improve the solution. Even if not, thus if attributes/properties are completely isolated, they should use the Attributor framework to reduce the number of fixpoint iteration frameworks in the code base. Note that the Attributor design makes sure that isolated attributes are not impacted, in any way, by others derived at the same time if there is no cross-reasoning performed.

The public facing interface of the Attributor is kept simple and basically allows abstract attributes to one thing, query abstract attributes in-flight. There are two reasons to do this: a) The optimistic state of one abstract attribute can justify an optimistic state of another, allowing to framework to end up with an optimistic (=best possible) fixpoint instead of one based solely on information in the IR. b) This avoids reimplementing various kinds of lookups, e.g., to check for existing IR attributes, in favor of a single lookups interface provided by an abstract attribute subclass.

NOTE: The mechanics of adding a new "concrete" abstract attribute are described in the file comment.

Definition at line 1473 of file Attributor.h.

Member Typedef Documentation

◆ SimplifictionCallbackTy

using llvm::Attributor::SimplifictionCallbackTy = std::function<std::optional<Value *>( const IRPosition &, const AbstractAttribute *, bool &)>

Register CB as a simplification callback.

Attributor::getAssumedSimplified will use these callbacks before we it will ask AAValueSimplify. It is important to ensure this is called before identifyDefaultAbstractAttributes, assuming the latter is called at all.

Definition at line 1886 of file Attributor.h.

◆ VirtualUseCallbackTy

using llvm::Attributor::VirtualUseCallbackTy = std::function<bool(Attributor &, const AbstractAttribute *)>

Definition at line 1898 of file Attributor.h.

Constructor & Destructor Documentation

◆ Attributor()

llvm::Attributor::Attributor	(	SetVector< Function * > &	Functions,
		InformationCache &	InfoCache,
		AttributorConfig	Configuration
	)

inline

Constructor.

Parameters

Functions	The set of functions we are deriving attributes for.
InfoCache	Cache to hold various information accessible for the abstract attributes.
Configuration	The Attributor configuration which determines what generic features to use.

Definition at line 1482 of file Attributor.h.

◆ ~Attributor()

Attributor::~Attributor ( )

Definition at line 1368 of file Attributor.cpp.

References llvm::AbstractAttribute::~AbstractAttribute().

Member Function Documentation

◆ changeAfterManifest()

bool llvm::Attributor::changeAfterManifest	(	const IRPosition	IRP,
		Value &	NV,
		bool	ChangeDroppable = `true`
	)

inline

Helper function to replace all uses associated with IRP with NV.

Return true if there is any change. The flag ChangeDroppable indicates if dropppable uses should be changed too.

Definition at line 1781 of file Attributor.h.

References assert(), changeUseAfterManifest(), llvm::IRPosition::getAssociatedValue(), llvm::IRPosition::getCallSiteArgNo(), llvm::IRPosition::getCtxI(), llvm::IRPosition::getPositionKind(), llvm::IRPosition::IRP_CALL_SITE_ARGUMENT, and llvm::Value::stripPointerCasts().

◆ changeToUnreachableAfterManifest()

void llvm::Attributor::changeToUnreachableAfterManifest ( Instruction * I )

inline

Record that I is to be replaced with unreachable after information was manifested.

Definition at line 1802 of file Attributor.h.

References I.

◆ changeUseAfterManifest()

bool llvm::Attributor::changeUseAfterManifest	(	Use &	U,
		Value &	NV
	)

inline

Record that U is to be replaces with NV after information was manifested.

This also triggers deletion of trivially dead istructions.

Definition at line 1767 of file Attributor.h.

References assert().

Referenced by changeAfterManifest().

◆ checkForAllCallLikeInstructions()

bool llvm::Attributor::checkForAllCallLikeInstructions	(	function_ref< bool(Instruction &)>	Pred,
		const AbstractAttribute &	QueryingAA,
		bool &	UsedAssumedInformation,
		bool	CheckBBLivenessOnly = `false`,
		bool	CheckPotentiallyDead = `false`
	)

inline

Check Pred on all call-like instructions (=CallBased derived).

See checkForAllCallLikeInstructions(...) for more information.

Definition at line 2198 of file Attributor.h.

References checkForAllInstructions().

◆ checkForAllCallSites() [1/2]

bool Attributor::checkForAllCallSites	(	function_ref< bool(AbstractCallSite)>	Pred,
		const AbstractAttribute &	QueryingAA,
		bool	RequireAllCallSites,
		bool &	UsedAssumedInformation
	)

Check Pred on all function call sites.

This method will evaluate Pred on call sites and return true if Pred holds in every call sites. However, this is only possible all call sites are known, hence the function has internal linkage. If true is returned, UsedAssumedInformation is set if assumed information was used to skip or simplify potential call sites.

Definition at line 1684 of file Attributor.cpp.

References checkForAllCallSites(), llvm::dbgs(), llvm::IRPosition::getAssociatedFunction(), llvm::AbstractAttribute::getIRPosition(), and LLVM_DEBUG.

Referenced by checkForAllCallSites(), checkForAllUses(), and isValidFunctionSignatureRewrite().

◆ checkForAllCallSites() [2/2]

bool Attributor::checkForAllCallSites	(	function_ref< bool(AbstractCallSite)>	Pred,
		const Function &	Fn,
		bool	RequireAllCallSites,
		const AbstractAttribute *	QueryingAA,
		bool &	UsedAssumedInformation,
		bool	CheckPotentiallyDead = `false`
	)

Check Pred on all call sites of Fn.

This method will evaluate Pred on call sites and return true if Pred holds in every call sites. However, this is only possible all call sites are known, hence the function has internal linkage. If true is returned, UsedAssumedInformation is set if assumed information was used to skip or simplify potential call sites.

Definition at line 1703 of file Attributor.cpp.

References llvm::Function::arg_size(), assert(), llvm::dbgs(), DEBUG_WITH_TYPE, llvm::Function::getArg(), llvm::AbstractCallSite::getCallArgOperand(), llvm::AbstractCallSite::getCalledFunction(), llvm::AbstractCallSite::getCalleeUseForCallback(), llvm::AbstractCallSite::getInstruction(), llvm::Value::getName(), llvm::AbstractCallSite::getNumArgOperands(), llvm::Value::getType(), llvm::GlobalValue::hasLocalLinkage(), isAssumedDead(), llvm::AbstractCallSite::isCallbackCall(), llvm::AbstractCallSite::isCallee(), LLVM_DEBUG, llvm::make_pointer_range(), llvm::Value::uses(), Uses, and VERBOSE_DEBUG_TYPE.

◆ checkForAllInstructions() [1/2]

bool Attributor::checkForAllInstructions	(	function_ref< bool(Instruction &)>	Pred,
		const AbstractAttribute &	QueryingAA,
		const ArrayRef< unsigned > &	Opcodes,
		bool &	UsedAssumedInformation,
		bool	CheckBBLivenessOnly = `false`,
		bool	CheckPotentiallyDead = `false`
	)

Check Pred on all instructions with an opcode present in Opcodes.

This method will evaluate Pred on all instructions with an opcode present in Opcode and return true if Pred holds on all of them.

Definition at line 1914 of file Attributor.cpp.

References checkForAllInstructions(), llvm::IRPosition::getAssociatedFunction(), and llvm::AbstractAttribute::getIRPosition().

◆ checkForAllInstructions() [2/2]

bool Attributor::checkForAllInstructions	(	function_ref< bool(Instruction &)>	Pred,
		const Function *	Fn,
		const AbstractAttribute &	QueryingAA,
		const ArrayRef< unsigned > &	Opcodes,
		bool &	UsedAssumedInformation,
		bool	CheckBBLivenessOnly = `false`,
		bool	CheckPotentiallyDead = `false`
	)

Check Pred on all instructions in Fn with an opcode present in Opcodes.

This method will evaluate Pred on all instructions with an opcode present in Opcode and return true if Pred holds on all of them.

Definition at line 1887 of file Attributor.cpp.

References checkForAllInstructionsImpl(), llvm::IRPosition::function(), llvm::InformationCache::getOpcodeInstMapForFunction(), llvm::GlobalValue::isDeclaration(), and llvm::NONE.

Referenced by checkForAllCallLikeInstructions(), and checkForAllInstructions().

◆ checkForAllReadWriteInstructions()

bool Attributor::checkForAllReadWriteInstructions	(	function_ref< bool(Instruction &)>	Pred,
		AbstractAttribute &	QueryingAA,
		bool &	UsedAssumedInformation
	)

Check Pred on all Read/Write instructions.

This method will evaluate Pred on all instructions that read or write to memory present in the information cache and return true if Pred holds on all of them.

Definition at line 1927 of file Attributor.cpp.

References llvm::IRPosition::function(), llvm::IRPosition::getAssociatedFunction(), llvm::AbstractAttribute::getIRPosition(), llvm::InformationCache::getReadOrWriteInstsForFunction(), I, llvm::IRPosition::inst(), isAssumedDead(), and llvm::NONE.

◆ checkForAllReturnedValues()

bool Attributor::checkForAllReturnedValues	(	function_ref< bool(Value &)>	Pred,
		const AbstractAttribute &	QueryingAA
	)

Check Pred on all values potentially returned by the function associated with QueryingAA.

This is the context insensitive version of the method above.

Definition at line 1835 of file Attributor.cpp.

References llvm::IRPosition::function(), llvm::IRPosition::getAssociatedFunction(), llvm::IRPosition::getCallBaseContext(), llvm::AbstractAttribute::getIRPosition(), and llvm::REQUIRED.

◆ checkForAllReturnedValuesAndReturnInsts()

bool Attributor::checkForAllReturnedValuesAndReturnInsts	(	function_ref< bool(Value &, const SmallSetVector< ReturnInst *, 4 > &)>	Pred,
		const AbstractAttribute &	QueryingAA
	)

Check Pred on all values potentially returned by F.

This method will evaluate Pred on all values potentially returned by the function associated with QueryingAA. The returned values are matched with their respective return instructions. Returns true if Pred holds on all of them.

Definition at line 1812 of file Attributor.cpp.

References llvm::IRPosition::function(), llvm::IRPosition::getAssociatedFunction(), llvm::AbstractAttribute::getIRPosition(), and llvm::REQUIRED.

◆ checkForAllUses()

bool Attributor::checkForAllUses	(	function_ref< bool(const Use &, bool &)>	Pred,
		const AbstractAttribute &	QueryingAA,
		const Value &	V,
		bool	CheckBBLivenessOnly = `false`,
		DepClassTy	LivenessDepClass = `DepClassTy::OPTIONAL`,
		bool	IgnoreDroppableUses = `true`,
		function_ref< bool(const Use &OldU, const Use &NewU)>	EquivalentUseCB = `nullptr`
	)

Check Pred on all (transitive) uses of V.

This method will evaluate Pred on all (transitive) uses of the associated value and return true if Pred holds every time. If uses are skipped in favor of equivalent ones, e.g., if we look through memory, the EquivalentUseCB will be used to give the caller an idea what original used was replaced by a new one (or new ones). The visit is cut short if EquivalentUseCB returns false and the function will return false as well.

Definition at line 1564 of file Attributor.cpp.

References checkForAllCallSites(), llvm::dbgs(), DEBUG_WITH_TYPE, llvm::SmallVectorBase< Size_T >::empty(), F, llvm::IRPosition::function(), llvm::IRPosition::getAnchorScope(), llvm::AbstractAttribute::getIRPosition(), llvm::AA::getPotentialCopiesOfStoredValue(), llvm::SmallPtrSetImpl< PtrType >::insert(), isAssumedDead(), LLVM_DEBUG, llvm::NONE, llvm::SmallVectorImpl< T >::pop_back_val(), llvm::SmallVectorTemplateBase< T, bool >::push_back(), SI, llvm::SetVector< T, Vector, Set >::size(), llvm::SmallVectorBase< Size_T >::size(), and VERBOSE_DEBUG_TYPE.

◆ createShallowWrapper()

void Attributor::createShallowWrapper ( Function & F )

static

Create a shallow wrapper for F such that F has internal linkage afterwards.

It also sets the original F 's name to anonymous

A wrapper is a function with the same type (and attributes) as F that will only call F and return the result, if any.

Assuming the declaration of looks like: rty F(aty0 arg0, ..., atyN argN);

The wrapper will then look as follows: rty wrapper(aty0 arg0, ..., atyN argN) { return F(arg0, ..., argN); }

Definition at line 2564 of file Attributor.cpp.

References llvm::CallBase::addFnAttr(), Arg, assert(), llvm::Function::Create(), llvm::CallInst::Create(), llvm::ReturnInst::Create(), llvm::BasicBlock::Create(), F, getName(), llvm::Value::getType(), llvm::GlobalValue::InternalLinkage, llvm::Type::isVoidTy(), llvm::CallInst::setTailCall(), and Wrapper.

Referenced by runAttributorOnFunctions().

◆ deleteAfterManifest() [1/3]

void llvm::Attributor::deleteAfterManifest ( BasicBlock & BB )

inline

Record that BB is deleted after information was manifested.

This also triggers deletion of trivially dead istructions.

Definition at line 1819 of file Attributor.h.

◆ deleteAfterManifest() [2/3]

void llvm::Attributor::deleteAfterManifest ( Function & F )

inline

Record that F is deleted after information was manifested.

Definition at line 1828 of file Attributor.h.

References llvm::AttributorConfig::DeleteFns, and F.

◆ deleteAfterManifest() [3/3]

void llvm::Attributor::deleteAfterManifest ( Instruction & I )

inline

Record that I is deleted after information was manifested.

This also triggers deletion of trivially dead istructions.

Definition at line 1815 of file Attributor.h.

References I.

◆ emitRemark() [1/2]

template<typename RemarkKind , typename RemarkCallBack >

void llvm::Attributor::emitRemark	(	Function *	F,
		StringRef	RemarkName,
		RemarkCallBack &&	RemarkCB
	)		const

inline

Emit a remark on a function.

Definition at line 2010 of file Attributor.h.

References F, llvm::AttributorConfig::OREGetter, llvm::AttributorConfig::PassName, and llvm::StringRef::startswith().

◆ emitRemark() [2/2]

template<typename RemarkKind , typename RemarkCallBack >

void llvm::Attributor::emitRemark	(	Instruction *	I,
		StringRef	RemarkName,
		RemarkCallBack &&	RemarkCB
	)		const

inline

Emit a remark generically.

This template function can be used to generically emit a remark. The RemarkKind should be one of the following:

OptimizationRemark to indicate a successful optimization attempt
OptimizationRemarkMissed to report a failed optimization attempt
OptimizationRemarkAnalysis to provide additional information about an optimization attempt

The remark is built using a callback function RemarkCB that takes a RemarkKind as input and returns a RemarkKind.

Definition at line 1989 of file Attributor.h.

References F, I, llvm::AttributorConfig::OREGetter, llvm::AttributorConfig::PassName, and llvm::StringRef::startswith().

◆ getAAFor()

template<typename AAType >

const AAType & llvm::Attributor::getAAFor	(	const AbstractAttribute &	QueryingAA,
		const IRPosition &	IRP,
		DepClassTy	DepClass
	)

inline

Lookup an abstract attribute of type AAType at position IRP.

While no abstract attribute is found equivalent positions are checked, see SubsumingPositionIterator. Thus, the returned abstract attribute might be anchored at a different position, e.g., the callee if IRP is a call base.

This method is the only (supported) way an abstract attribute can retrieve information from another abstract attribute. As an example, take an abstract attribute that determines the memory access behavior for a argument (readnone, readonly, ...). It should use getAAFor to get the most optimistic information for other abstract attributes in-flight, e.g. the one reasoning about the "captured" state for the argument or the one reasoning on the memory access behavior of the function as a whole.

If the DepClass enum is set to DepClassTy::None the dependence from QueryingAA to the return abstract attribute is not automatically recorded. This should only be used if the caller will record the dependence explicitly if necessary, thus if it the returned abstract attribute is used for reasoning. To record the dependences explicitly use the Attributor::recordDependence method.

Definition at line 1518 of file Attributor.h.

◆ getAndUpdateAAFor()

template<typename AAType >

const AAType & llvm::Attributor::getAndUpdateAAFor	(	const AbstractAttribute &	QueryingAA,
		const IRPosition &	IRP,
		DepClassTy	DepClass
	)

inline

Similar to getAAFor but the return abstract attribute will be updated (via AbstractAttribute::update) even if it is found in the cache.

This is especially useful for AAIsDead as changes in liveness can make updates possible/useful that were not happening before as the abstract attribute was assumed dead.

Definition at line 1530 of file Attributor.h.

◆ getAssumedConstant() [1/2]

std::optional< Constant * > Attributor::getAssumedConstant	(	const IRPosition &	IRP,
		const AbstractAttribute &	AA,
		bool &	UsedAssumedInformation
	)

If IRP is assumed to be a constant, return it, if it is unclear yet, return std::nullopt, otherwise return nullptr.

Definition at line 1267 of file Attributor.cpp.

References llvm::CallingConv::C, llvm::SmallVectorBase< Size_T >::empty(), llvm::IRPosition::getAssociatedValue(), getAssumedSimplifiedValues(), llvm::AAPotentialValues::getSingleValue(), and llvm::AA::Interprocedural.

Referenced by getAssumedConstant().

◆ getAssumedConstant() [2/2]

std::optional< Constant * > llvm::Attributor::getAssumedConstant	(	const Value &	V,
		const AbstractAttribute &	AA,
		bool &	UsedAssumedInformation
	)

inline

Definition at line 1838 of file Attributor.h.

References getAssumedConstant(), and llvm::IRPosition::value().

◆ getAssumedSimplified() [1/3]

std::optional< Value * > llvm::Attributor::getAssumedSimplified	(	const IRPosition &	IRP,
		const AbstractAttribute &	AA,
		bool &	UsedAssumedInformation,
		AA::ValueScope	S
	)

inline

If V is assumed simplified, return it, if it is unclear yet, return std::nullopt, otherwise return nullptr.

Definition at line 1846 of file Attributor.h.

References getAssumedSimplified().

Referenced by getAssumedSimplified(), identifyDefaultAbstractAttributes(), and translateArgumentToCallSiteContent().

◆ getAssumedSimplified() [2/3]

std::optional< Value * > Attributor::getAssumedSimplified	(	const IRPosition &	V,
		const AbstractAttribute *	AA,
		bool &	UsedAssumedInformation,
		AA::ValueScope	S
	)

If V is assumed simplified, return it, if it is unclear yet, return std::nullopt, otherwise return nullptr.

Same as the public version except that it can be used without recording dependences on any AA.

Definition at line 1296 of file Attributor.cpp.

References llvm::SmallVectorBase< Size_T >::empty(), llvm::IRPosition::getAssociatedValue(), getAssumedSimplifiedValues(), llvm::IRPosition::getPositionKind(), llvm::AAPotentialValues::getSingleValue(), llvm::IRPosition::IRP_CALL_SITE_RETURNED, and llvm::IRPosition::IRP_RETURNED.

◆ getAssumedSimplified() [3/3]

std::optional< Value * > llvm::Attributor::getAssumedSimplified	(	const Value &	V,
		const AbstractAttribute &	AA,
		bool &	UsedAssumedInformation,
		AA::ValueScope	S
	)

inline

Definition at line 1852 of file Attributor.h.

References getAssumedSimplified(), and llvm::IRPosition::value().

◆ getAssumedSimplifiedValues()

bool Attributor::getAssumedSimplifiedValues	(	const IRPosition &	IRP,
		const AbstractAttribute *	AA,
		SmallVectorImpl< AA::ValueAndContext > &	Values,
		AA::ValueScope	S,
		bool &	UsedAssumedInformation
	)

Try to simplify IRP and in the scope S.

If successful, true is returned and all potential values IRP can take are put into Values. If the result in Values contains select or PHI instructions it means those could not be simplified to a single value. Recursive calls with these instructions will yield their respective potential values. If false is returned no other information is valid.

Definition at line 1319 of file Attributor.cpp.

References llvm::IRPosition::getAnchorScope(), llvm::AA::Interprocedural, llvm::AA::isValidInScope(), llvm::OPTIONAL, and llvm::SmallVectorTemplateBase< T, bool >::push_back().

Referenced by getAssumedConstant(), and getAssumedSimplified().

◆ getDataLayout()

const DataLayout & llvm::Attributor::getDataLayout ( ) const

inline

Return the data layout associated with the anchor scope.

Definition at line 2271 of file Attributor.h.

◆ getInfoCache()

InformationCache & llvm::Attributor::getInfoCache ( )

inline

Return the internal information cache.

Definition at line 1712 of file Attributor.h.

Referenced by getOrCreateAAFor().

◆ getOrCreateAAFor() [1/2]

template<typename AAType >

const AAType & llvm::Attributor::getOrCreateAAFor ( const IRPosition & IRP )

inline

Definition at line 1632 of file Attributor.h.

References llvm::NONE.

◆ getOrCreateAAFor() [2/2]

template<typename AAType >

const AAType & llvm::Attributor::getOrCreateAAFor	(	IRPosition	IRP,
		const AbstractAttribute *	QueryingAA,
		DepClassTy	DepClass,
		bool	ForceUpdate = `false`,
		bool	UpdateAfterInit = `true`
	)

inline

The version of getAAFor that allows to omit a querying abstract attribute.

Using this after Attributor started running is restricted to only the Attributor itself. Initial seeding of AAs can be done via this function. NOTE: ForceUpdate is ignored in any stage other than the update stage.

Definition at line 1542 of file Attributor.h.

References llvm::AttributorConfig::Allowed, llvm::detail::DenseSetImpl< ValueT, MapTy, ValueInfoT >::count(), llvm::IRPosition::getAnchorScope(), llvm::IRPosition::getAssociatedFunction(), getInfoCache(), llvm::AbstractAttribute::getState(), llvm::Function::hasFnAttribute(), llvm::InformationCache::isInModuleSlice(), isModulePass(), isRunOn(), llvm::AbstractState::isValidState(), llvm::MaxInitializationChainLength, recordDependence(), registerAA(), and llvm::IRPosition::stripCallBaseContext().

◆ hasSimplificationCallback()

bool llvm::Attributor::hasSimplificationCallback ( const IRPosition & IRP )

inline

Return true if there is a simplification callback for IRP.

Definition at line 1894 of file Attributor.h.

◆ identifyDefaultAbstractAttributes()

void Attributor::identifyDefaultAbstractAttributes ( Function & F )

Determine opportunities to derive 'default' attributes in F and create abstract attribute objects for them.

Parameters

F	The function that is checked for attribute opportunities.

Note that abstract attribute instances are generally created even if the IR already contains the information they would deduce. The most important reason for this is the single interface, the one of the abstract attribute instance, which can be queried without the need to look at the IR in various places.

Definition at line 3151 of file Attributor.cpp.

References AnnotateDeclarationCallSites, Arg, llvm::IRPosition::argument(), assert(), Callee, llvm::IRPosition::callsite_argument(), llvm::IRPosition::callsite_function(), llvm::IRPosition::callsite_returned(), checkForAllInstructionsImpl(), E, EnableHeapToStack, F, llvm::IRPosition::function(), getAssumedSimplified(), llvm::InformationCache::getOpcodeInstMapForFunction(), llvm::getPointerOperand(), I, llvm::IRPosition::inst(), llvm::AA::Intraprocedural, isModulePass(), llvm::AttributeFuncs::isNoFPClassCompatibleType(), llvm::Type::isPointerTy(), llvm::IRPosition::returned(), SI, SimplifyAllLoads, Success, and llvm::IRPosition::value().

Referenced by markLiveInternalFunction().

◆ internalizeFunction()

Function * Attributor::internalizeFunction	(	Function &	F,
		bool	Force = `false`
	)

static

Make another copy of the function F such that the copied version has internal linkage afterwards and can be analysed.

Then we replace all uses of the original function to the copied one

Only non-locally linked functions that have linkonce_odr or weak_odr linkage can be internalized because these linkages guarantee that other definitions with the same name have the same semantics as this one.

This will only be run if the attributor-allow-deep-wrappers option is set, or if the function is called with Force set to true.

If the function F failed to be internalized the return value will be a null pointer.

Definition at line 2618 of file Attributor.cpp.

References AllowDeepWrapper, F, internalizeFunctions(), and isInternalizable().

Referenced by runAttributorOnFunctions().

◆ internalizeFunctions()

bool Attributor::internalizeFunctions	(	SmallPtrSetImpl< Function * > &	FnSet,
		DenseMap< Function , Function > &	FnMap
	)

static

Make copies of each function in the set FnSet such that the copied version has internal linkage afterwards and can be analysed.

Then we replace all uses of the original function to the copied one. The map FnMap contains a mapping of functions to their internalized versions.

Only non-locally linked functions that have linkonce_odr or weak_odr linkage can be internalized because these linkages guarantee that other definitions with the same name have the same semantics as this one.

This version will internalize all the functions in the set FnSet at once and then replace the uses. This prevents internalized functions being called by external functions when there is an internalized version in the module.

Definition at line 2631 of file Attributor.cpp.

References llvm::GlobalObject::addMetadata(), Arg, llvm::Function::arg_begin(), llvm::DenseMapBase< DerivedT, KeyT, ValueT, KeyInfoT, BucketT >::clear(), llvm::CloneFunctionInto(), llvm::Function::Create(), llvm::GlobalValue::DefaultVisibility, F, llvm::GlobalObject::hasMetadata(), isInternalizable(), llvm::LocalChangesOnly, llvm::DenseMapBase< DerivedT, KeyT, ValueT, KeyInfoT, BucketT >::lookup(), llvm::GlobalValue::PrivateLinkage, llvm::GlobalValue::setDSOLocal(), llvm::GlobalValue::setLinkage(), and llvm::GlobalValue::setVisibility().

Referenced by internalizeFunction(), and llvm::OpenMPOptPass::run().

◆ isAssumedDead() [1/5]

bool Attributor::isAssumedDead	(	const AbstractAttribute &	AA,
		const AAIsDead *	LivenessAA,
		bool &	UsedAssumedInformation,
		bool	CheckBBLivenessOnly = `false`,
		DepClassTy	DepClass = `DepClassTy::OPTIONAL`
	)

Return true if AA (or its context instruction) is assumed dead.

If LivenessAA is not provided it is queried.

Definition at line 1377 of file Attributor.cpp.

References llvm::SetVector< T, Vector, Set >::count(), llvm::IRPosition::getAnchorScope(), llvm::AbstractAttribute::getIRPosition(), and isAssumedDead().

Referenced by checkForAllCallSites(), checkForAllReadWriteInstructions(), checkForAllUses(), and isAssumedDead().

◆ isAssumedDead() [2/5]

bool Attributor::isAssumedDead	(	const BasicBlock &	BB,
		const AbstractAttribute *	QueryingAA,
		const AAIsDead *	FnLivenessAA,
		DepClassTy	DepClass = `DepClassTy::OPTIONAL`
	)

Return true if BB is assumed dead.

If LivenessAA is not provided it is queried.

Definition at line 1542 of file Attributor.cpp.

References F, llvm::IRPosition::function(), llvm::IRPosition::getAnchorScope(), llvm::BasicBlock::getParent(), llvm::AAIsDead::isAssumedDead(), llvm::NONE, and recordDependence().

◆ isAssumedDead() [3/5]

bool Attributor::isAssumedDead	(	const Instruction &	I,
		const AbstractAttribute *	QueryingAA,
		const AAIsDead *	LivenessAA,
		bool &	UsedAssumedInformation,
		bool	CheckBBLivenessOnly = `false`,
		DepClassTy	DepClass = `DepClassTy::OPTIONAL`,
		bool	CheckForDeadStore = `false`
	)

Return true if I is assumed dead.

If LivenessAA is not provided it is queried.

Definition at line 1435 of file Attributor.cpp.

References F, llvm::IRPosition::function(), llvm::IRPosition::getAnchorScope(), llvm::IRPosition::getCallBaseContext(), I, llvm::IRPosition::inst(), llvm::AAIsDead::isAssumedDead(), llvm::AAIsDead::isKnownDead(), llvm::AAIsDead::isRemovableStore(), llvm::NONE, and recordDependence().

◆ isAssumedDead() [4/5]

bool Attributor::isAssumedDead	(	const IRPosition &	IRP,
		const AbstractAttribute *	QueryingAA,
		const AAIsDead *	FnLivenessAA,
		bool &	UsedAssumedInformation,
		bool	CheckBBLivenessOnly = `false`,
		DepClassTy	DepClass = `DepClassTy::OPTIONAL`
	)

Return true if IRP is assumed dead.

If FnLivenessAA is not provided it is queried.

Definition at line 1496 of file Attributor.cpp.

References llvm::IRPosition::callsite_returned(), llvm::IRPosition::getAssociatedValue(), llvm::IRPosition::getCtxI(), llvm::IRPosition::getPositionKind(), llvm::IRPosition::IRP_CALL_SITE, llvm::IRPosition::IRP_FLOAT, llvm::AAIsDead::isAssumedDead(), isAssumedDead(), llvm::AAIsDead::isKnownDead(), llvm::NONE, llvm::OPTIONAL, and recordDependence().

◆ isAssumedDead() [5/5]

bool Attributor::isAssumedDead	(	const Use &	U,
		const AbstractAttribute *	QueryingAA,
		const AAIsDead *	FnLivenessAA,
		bool &	UsedAssumedInformation,
		bool	CheckBBLivenessOnly = `false`,
		DepClassTy	DepClass = `DepClassTy::OPTIONAL`
	)

Return true if U is assumed dead.

If FnLivenessAA is not provided it is queried.

Definition at line 1388 of file Attributor.cpp.

References llvm::IRPosition::callsite_argument(), llvm::BasicBlock::getTerminator(), llvm::IRPosition::inst(), llvm::AAIsDead::IS_REMOVABLE, isAssumedDead(), llvm::BitIntegerState< base_ty, BestState, WorstState >::isKnown(), llvm::AAIsDead::isRemovableStore(), llvm::NONE, PHI, recordDependence(), llvm::IRPosition::returned(), SI, and llvm::IRPosition::value().

◆ isFunctionIPOAmendable()

bool llvm::Attributor::isFunctionIPOAmendable ( const Function & F )

inline

Determine whether the function F is IPO amendable.

If a function is exactly defined or it has alwaysinline attribute and is viable to be inlined, we say it is IPO amendable

Definition at line 1739 of file Attributor.h.

References F.

◆ isInternalizable()

bool Attributor::isInternalizable ( Function & F )

static

Returns true if the function F can be internalized.

i.e. it has a compatible linkage.

Definition at line 2611 of file Attributor.cpp.

References F, and llvm::GlobalValue::isInterposableLinkage().

Referenced by internalizeFunction(), internalizeFunctions(), and llvm::OpenMPOptPass::run().

◆ isModulePass()

bool llvm::Attributor::isModulePass ( ) const

inline

Return true if this is a module pass, false otherwise.

Definition at line 1715 of file Attributor.h.

References llvm::AttributorConfig::IsModulePass.

Referenced by getOrCreateAAFor(), and identifyDefaultAbstractAttributes().

◆ isRunOn() [1/2]

bool llvm::Attributor::isRunOn ( Function & Fn ) const

inline

Return true if we derive attributes for Fn.

Definition at line 1718 of file Attributor.h.

References isRunOn().

Referenced by getOrCreateAAFor(), and isRunOn().

◆ isRunOn() [2/2]

bool llvm::Attributor::isRunOn ( Function * Fn ) const

inline

Definition at line 1719 of file Attributor.h.

References llvm::SetVector< T, Vector, Set >::count(), and llvm::SetVector< T, Vector, Set >::empty().

◆ isValidFunctionSignatureRewrite()

bool Attributor::isValidFunctionSignatureRewrite	(	Argument &	Arg,
		ArrayRef< Type * >	ReplacementTypes
	)

Check if we can rewrite a function signature.

The argument Arg is replaced with new ones defined by the number, order, and types in ReplacementTypes.

Returns: True, if the replacement can be registered, via registerFunctionSignatureRewrite, false otherwise.

Definition at line 2692 of file Attributor.cpp.

References Arg, checkForAllCallSites(), checkForAllInstructionsImpl(), llvm::dbgs(), llvm::Function::getAttributes(), llvm::AbstractCallSite::getCalledFunction(), llvm::AbstractCallSite::getCalledOperand(), llvm::AbstractCallSite::getInstruction(), llvm::InformationCache::getOpcodeInstMapForFunction(), llvm::Function::getReturnType(), llvm::GlobalValue::getType(), llvm::Value::getType(), llvm::AttributeList::hasAttrSomewhere(), I, llvm::AbstractCallSite::isCallbackCall(), llvm::CallBase::isMustTailCall(), llvm::Function::isVarArg(), LLVM_DEBUG, and llvm::AttributorConfig::RewriteSignatures.

Referenced by registerFunctionSignatureRewrite().

◆ lookupAAFor()

template<typename AAType >

AAType * llvm::Attributor::lookupAAFor	(	const IRPosition &	IRP,
		const AbstractAttribute *	QueryingAA = `nullptr`,
		DepClassTy	DepClass = `DepClassTy::OPTIONAL`,
		bool	AllowInvalidState = `false`
	)

inline

Return the attribute of AAType for IRP if existing and valid.

This also allows non-AA users lookup.

Definition at line 1640 of file Attributor.h.

References llvm::AbstractAttribute::getState(), llvm::AbstractState::isValidState(), llvm::NONE, and recordDependence().

◆ markLiveInternalFunction()

void llvm::Attributor::markLiveInternalFunction ( const Function & F )

inline

Mark the internal function F as live.

This will trigger the identification and initialization of attributes for F.

Definition at line 1747 of file Attributor.h.

References assert(), llvm::AttributorConfig::DefaultInitializeLiveInternals, F, identifyDefaultAbstractAttributes(), and llvm::AttributorConfig::InitializationCallback.

◆ recordDependence()

void Attributor::recordDependence	(	const AbstractAttribute &	FromAA,
		const AbstractAttribute &	ToAA,
		DepClassTy	DepClass
	)

Explicitly record a dependence from FromAA to ToAA, that is if FromAA changes ToAA should be updated as well.

This method should be used in conjunction with the getAAFor method and with the DepClass enum passed to the method set to None. This can be beneficial to avoid false dependences but it requires the users of getAAFor to explicitly record true dependences through this method. The DepClass flag indicates if the dependence is striclty necessary. That means for required dependences, if FromAA changes to an invalid state, ToAA can be moved to a pessimistic fixpoint because it required information from FromAA but none are available anymore.

Definition at line 3123 of file Attributor.cpp.

References llvm::AbstractAttribute::getState(), llvm::AbstractState::isAtFixpoint(), and llvm::NONE.

Referenced by getOrCreateAAFor(), isAssumedDead(), and lookupAAFor().

◆ registerAA()

template<typename AAType >

AAType & llvm::Attributor::registerAA ( AAType & AA )

inline

Introduce a new abstract attribute into the fixpoint analysis.

Note that ownership of the attribute is given to the Attributor. It will invoke delete for the Attributor on destruction of the Attributor.

Attributes are identified by their IR position (AAType::getIRPosition()) and the address of their static member (see AAType::ID).

Definition at line 1691 of file Attributor.h.

References assert(), llvm::AADepGraphNode::Deps, llvm::SetVector< T, Vector, Set >::insert(), llvm::REQUIRED, and llvm::AADepGraph::SyntheticRoot.

Referenced by getOrCreateAAFor().

◆ registerForUpdate()

void Attributor::registerForUpdate ( AbstractAttribute & AA )

Allows a query AA to request an update if a new query was received.

Definition at line 2105 of file Attributor.cpp.

References assert(), and llvm::AbstractAttribute::isQueryAA().

◆ registerFunctionSignatureRewrite()

bool Attributor::registerFunctionSignatureRewrite	(	Argument &	Arg,
		ArrayRef< Type * >	ReplacementTypes,
		ArgumentReplacementInfo::CalleeRepairCBTy &&	CalleeRepairCB,
		ArgumentReplacementInfo::ACSRepairCBTy &&	ACSRepairCB
	)

Register a rewrite for a function signature.

The argument Arg is replaced with new ones defined by the number, order, and types in ReplacementTypes. The rewiring at the call sites is done through ACSRepairCB and at the callee site through CalleeRepairCB.

Returns: True, if the replacement was registered, false otherwise.

Definition at line 2757 of file Attributor.cpp.

References Arg, llvm::Function::arg_size(), assert(), llvm::dbgs(), llvm::SmallVectorBase< Size_T >::empty(), isValidFunctionSignatureRewrite(), LLVM_DEBUG, llvm::SmallVectorImpl< T >::resize(), and llvm::ArrayRef< T >::size().

◆ registerInvokeWithDeadSuccessor()

void llvm::Attributor::registerInvokeWithDeadSuccessor ( InvokeInst & II )

inline

Record that II has at least one dead successor block.

This information is used, e.g., to replace II with a call, after information was manifested.

Definition at line 1809 of file Attributor.h.

◆ registerManifestAddedBasicBlock()

void llvm::Attributor::registerManifestAddedBasicBlock ( BasicBlock & BB )

inline

Definition at line 1823 of file Attributor.h.

◆ registerSimplificationCallback()

void llvm::Attributor::registerSimplificationCallback	(	const IRPosition &	IRP,
		const SimplifictionCallbackTy &	CB
	)

inline

Definition at line 1888 of file Attributor.h.

◆ registerVirtualUseCallback()

void llvm::Attributor::registerVirtualUseCallback	(	const Value &	V,
		const VirtualUseCallbackTy &	CB
	)

inline

Definition at line 1900 of file Attributor.h.

◆ removeCallSite()

void llvm::Attributor::removeCallSite ( CallInst * CI )

inline

Helper function to remove callsite.

Definition at line 1758 of file Attributor.h.

References llvm::AttributorConfig::CGUpdater, and llvm::CallGraphUpdater::removeCallSite().

◆ run()

ChangeStatus Attributor::run ( )

Run the analyses until a fixpoint is reached or enforced (timeout).

The attributes registered with this Attributor can be used after as long as the Attributor is not destroyed (it owns the attributes now).

\Returns CHANGED if the IR was changed, otherwise UNCHANGED.

Definition at line 2486 of file Attributor.cpp.

References DumpDepGraph, llvm::AADepGraph::dumpGraph(), llvm::AttributorCallGraph::populateAll(), llvm::AADepGraph::print(), llvm::AttributorCallGraph::print(), PrintCallGraph, PrintDependencies, ViewDepGraph, and llvm::AADepGraph::viewGraph().

◆ translateArgumentToCallSiteContent()

std::optional< Value * > Attributor::translateArgumentToCallSiteContent	(	std::optional< Value * >	V,
		CallBase &	CB,
		const AbstractAttribute &	AA,
		bool &	UsedAssumedInformation
	)

Translate V from the callee context into the call site context.

Definition at line 1352 of file Attributor.cpp.

References Arg, llvm::IRPosition::callsite_argument(), getAssumedSimplified(), llvm::CallBase::getCalledFunction(), and llvm::AA::Intraprocedural.

Member Data Documentation

◆ Allocator

BumpPtrAllocator& llvm::Attributor::Allocator

The allocator used to allocate memory, e.g. for AbstractAttributes.

Definition at line 2274 of file Attributor.h.

The documentation for this struct was generated from the following files:

include/llvm/Transforms/IPO/Attributor.h
lib/Transforms/IPO/Attributor.cpp

Classes

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Detailed Description

Member Typedef Documentation

◆ SimplifictionCallbackTy

◆ VirtualUseCallbackTy

Constructor & Destructor Documentation

◆ Attributor()

◆ ~Attributor()

Member Function Documentation

◆ changeAfterManifest()

◆ changeToUnreachableAfterManifest()

◆ changeUseAfterManifest()

◆ checkForAllCallLikeInstructions()

◆ checkForAllCallSites() [1/2]

◆ checkForAllCallSites() [2/2]

◆ checkForAllInstructions() [1/2]

◆ checkForAllInstructions() [2/2]

◆ checkForAllReadWriteInstructions()

◆ checkForAllReturnedValues()

◆ checkForAllReturnedValuesAndReturnInsts()

◆ checkForAllUses()

◆ createShallowWrapper()

◆ deleteAfterManifest() [1/3]

◆ deleteAfterManifest() [2/3]

◆ deleteAfterManifest() [3/3]

◆ emitRemark() [1/2]

◆ emitRemark() [2/2]

◆ getAAFor()

◆ getAndUpdateAAFor()

◆ getAssumedConstant() [1/2]

◆ getAssumedConstant() [2/2]

◆ getAssumedSimplified() [1/3]

◆ getAssumedSimplified() [2/3]

◆ getAssumedSimplified() [3/3]

◆ getAssumedSimplifiedValues()

◆ getDataLayout()

◆ getInfoCache()

◆ getOrCreateAAFor() [1/2]

◆ getOrCreateAAFor() [2/2]

◆ hasSimplificationCallback()

◆ identifyDefaultAbstractAttributes()

◆ internalizeFunction()

◆ internalizeFunctions()

◆ isAssumedDead() [1/5]

◆ isAssumedDead() [2/5]

◆ isAssumedDead() [3/5]

◆ isAssumedDead() [4/5]

◆ isAssumedDead() [5/5]

◆ isFunctionIPOAmendable()

◆ isInternalizable()

◆ isModulePass()

◆ isRunOn() [1/2]

◆ isRunOn() [2/2]

◆ isValidFunctionSignatureRewrite()

◆ lookupAAFor()

◆ markLiveInternalFunction()

◆ recordDependence()

◆ registerAA()

◆ registerForUpdate()

◆ registerFunctionSignatureRewrite()

◆ registerInvokeWithDeadSuccessor()

◆ registerManifestAddedBasicBlock()

◆ registerSimplificationCallback()

◆ registerVirtualUseCallback()

◆ removeCallSite()

◆ run()

◆ translateArgumentToCallSiteContent()

Member Data Documentation

◆ Allocator